OpenLoco: Install, Build and Play the Locomotion Reimplementation

OpenLoco's Locomotion Reimplementation and Save Constraints

OpenLoco addresses a specific problem: recreating Chris Sawyer's Locomotion in open source C++ while preserving compatibility with the original game's design. It is aimed at players who have the original assets, contributors interested in transport simulation code, and developers who want to study or extend that implementation. The README describes it as the spiritual successor to Transport Tycoon and compares its purpose with the relationship between OpenTTD and Transport Tycoon.

The original game was written in x86 assembly on top of the RollerCoaster Tycoon 2 engine. OpenLoco states that the engine changed enough that it no longer shares its codebase with OpenRCT2. As of December 2025, the project reports that it has completed reimplementing the game in C++. This is an important boundary for adoption: the repository is a replacement implementation, not merely a wrapper around an existing executable.

Compatibility also has limits. OpenLoco currently remains constrained by the CSL save formats, SV5 and SC5. The stated goals include a new save format and multiplayer support, but the README does not present either as a completed feature. Increased map and vehicle limits also depend on creating that new format.

SDL3, CMake and OpenLoco's C++ Build Layout

Based on the repository layout, the implementation is centered in `src/`, with project-wide build configuration in `CMakeLists.txt` and `CMakePresets.json`. Native resources are stored under `data/`, while `distribution/` contains distribution-related files. Code-quality configuration includes `.clang-format` and `.clang-tidy`, and dependency metadata is represented by `vcpkg.json` and `thirdparty/`.

The documented graphics and audio foundation includes SDL3, OpenAL, libpng and libzip. The build also uses yaml-cpp, fmt and sfl, which are fetched during CMake generation. Windows builds can require breakpad, Linux builds using libstdc++ can require tbb, and gtest is needed when tests are built. This dependency list gives contributors a concrete view of the runtime and build surface, although the README does not describe individual C++ classes or a detailed runtime architecture.

OpenLoco is not self-contained in the sense that matters for installation. Playing it still requires asset files from Chris Sawyer's Locomotion. Those assets are separate from the MIT-licensed project code, so an open source license for the implementation does not mean the original game data is bundled or replaced.

Downloading OpenLoco and Obtaining Required Game Assets

For players, the first documented route is the GitHub releases page rather than source compilation. Prebuilt releases are available for Windows, Linux and macOS. The architecture coverage is narrower than the operating-system list: the README specifies Windows builds for 64-bit and 32-bit systems, Linux builds for 64-bit only, and macOS builds for arm64 only.

The release page does not remove the asset requirement. The README directs users to acquire Chris Sawyer's Locomotion through Steam or GOG.com. OpenLoco needs those original asset files to play. It does not document an asset-conversion command, permitted asset location, or first-session setup procedure, so those details cannot be inferred safely from the README.

There are two additional platform warnings. The project does not publish BSD builds, so users on BSD systems are directed toward manual compilation. macOS releases are unsigned and unnotarized, which means Gatekeeper can block them. Gatekeeper may therefore require users to handle a local installation obstacle.

Building OpenLoco on Linux or macOS with CMake

Source builders need CMake 3.22 or later, either `make` or `ninja`, and the documented libraries. Linux users must also provide matching 32-bit dependencies when building x86-32. The README notes that some packages can be difficult to install for that target and offers the project's Docker images as a compilation workaround. macOS documentation requires the libraries in standard paths, for example through Homebrew, or permits vcpkg for dependency management.

The documented Linux build sequence is:

cmake --preset posix
cmake --build --preset posix-release

The macOS instructions use the same sequence after the required libraries are installed:

cmake --preset posix
cmake --build --preset posix-release

CMake generation downloads yaml-cpp's source release because of issues with distribution packages. The README says only arm64 macOS builds have been tested. It does not document a command for launching the resulting macOS executable or identify the generated output path, so the build commands are the only confirmed source-build steps.

Opening the First OpenLoco Build on Windows

Windows contributors need Windows 10 or 11 and Visual Studio 2022 with the desktop C++ workload and MFC component selected. Dependencies are managed through vcpkg. With the repository checked out, Visual Studio can open the local folder and generate the project files. That generation may download dependencies, so a first setup can take time.

The README also provides a direct CMake route. These commands generate the Windows configuration and build its release variant:

cmake --preset windows
cmake --build --preset windows-release

For the Visual Studio workflow, after project generation succeeds, the documented solution is `build/windows/openloco.sln`. Choosing Debug or Release and building the solution produces the executable. The README identifies the launch path as:

build/windows/<config>/OpenLoco.exe

The command-line examples above are build operations rather than a first-game script. OpenLoco still requires the original game assets, and the README does not specify a configuration flag or documented action for importing them.

Multiplayer and Save Limits in OpenLoco

OpenLoco identifies a solid multiplayer experience as a project goal, not as an available feature described in the README. For prospective players, that distinction matters. A build can therefore provide the reimplemented single-player game without offering a documented multiplayer server, client configuration, room system or synchronization model.

The current save-format constraint is equally specific. Maps and vehicles remain bounded by what the CSL SV5 and SC5 formats permit. The project says it aims to increase those limits, but also says that doing so requires a new save format, identified as NSF. Without that format, raising the limits is not simply a matter of changing constants in the C++ implementation.

This makes OpenLoco different from projects designed around a newly defined data model. It prioritizes compatibility with an existing game and its save files while preserving room for later expansion. The trade-off is concrete: existing format support constrains map and vehicle growth, and the announced multiplayer direction remains incomplete. The README does not define migration behavior between OpenLoco and Locomotion saves.

OpenLoco, OpenTTD and OpenRCT2 Implementation Trade-offs

OpenTTD is the clearest conceptual alternative for players interested in an open source transport management simulation. The README positions OpenLoco in a similar relationship to Transport Tycoon that OpenTTD has, but the projects are not interchangeable implementations of the same game. OpenLoco reproduces Chris Sawyer's Locomotion and retains its SV5 and SC5 constraints. The README does not document OpenTTD's save limits, architecture or compatibility, so no broader comparison is justified.

The README compares OpenLoco with OpenRCT2's improvement of RollerCoaster Tycoon. OpenLoco explicitly states that its engine has diverged substantially and that the projects do not share a codebase. That means fixes or engine changes from OpenRCT2 cannot be assumed to transfer directly. OpenLoco instead follows a Locomotion-specific architecture in C++, with its own repository, dependencies and release pipeline.

For contributors, this distinction affects reuse. Familiarity with SDL3 and CMake provides some transferable context, but shared ancestry is not offered as a shortcut. For players, the more immediate distinction is content compatibility: OpenLoco requires original Locomotion assets, while the README does not make that same asset requirement for the alternatives.

OpenLoco Maintenance, Dependencies and MIT Licensing

OpenLoco is not archived, and its last push was on 2026-10-14. Recent releases include v26.07.1 on 2026-07-27, v26.08 on 2026-08-13 and v26.09 on 2026-09-18. These facts indicate recent project output, but they do not by themselves document release compatibility, upgrade procedures or the stability of unfinished multiplayer work.

The upgrade burden includes the C++ codebase and a changing native dependency set. Contributors must keep the compiler, MFC on Windows, SDL3, OpenAL, libpng, libzip and other required libraries aligned with the build configuration. CMake generation can also fetch dependency source, so contributors need network access during setup. The repository includes `CHANGELOG.md`, but the README does not describe an upgrade policy or migration guarantees.

The project code is licensed under the MIT License. That license covers the OpenLoco implementation, while the README separately requires purchase or acquisition of the original Locomotion assets. Users distributing builds should preserve the applicable license notices and verify their rights to any original assets rather than treating the MIT license as asset clearance.

Editorial conclusion

OpenLoco suits players who own Chris Sawyer's Locomotion and want its open source implementation, along with C++ developers who accept its current save-format constraints. It is a poor fit for users seeking BSD builds or developers expecting an independent save format and completed multiplayer implementation. Before adopting it, verify that the relevant platform release is available, obtain the required original assets, and confirm that your maps and vehicles fit within the SV5 and SC5 limits.

Frequently asked questions

Official sources

1. License: MIT
2. OpenLoco/OpenLoco on GitHub
3. Project website
4. README
5. Releases