# OpenSoldat: building and running the 1.8 multiplayer action game

> OpenSoldat is an open source 2D side-view multiplayer action game written primarily in Pascal. The repository documents a CMake-based build for Linux, Windows and macOS, separate client and server programs, and an unfinished 1.8 development branch.

**opensoldat/opensoldat** — OpenSoldat is a unique 2D (side-view) multiplayer action game

- Repository: https://github.com/opensoldat/opensoldat
- Stars: 1,466 · Forks: 100
- Language: Pascal
- License: MIT
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/opensoldat-opensoldat

## What OpenSoldat is built to provide

OpenSoldat addresses the need for a source-available multiplayer action game whose client and server can be modified by a community. It is a 2D side-view game rather than a first-person shooter, and the README places its visual and action influences in games such as Liero, Worms, Quake and Counter-Strike. Its stated focus is fast-paced multiplayer action with blood and gore. The intended users are players who want to run a local or networked match, as well as Pascal developers who want to change the game rather than consume a packaged release.

The repository is not presented as a single monolithic binary source tree. It contains a client directory, a server directory and a shared directory, with a top-level CMake configuration and a 3rdparty directory. The README explicitly describes building a client, a server or both, so deployment can be separated across machines. The source corresponds to the 1.8 version and is described as unfinished. That status matters for adoption. This is development source for a particular game version, not a guarantee of a stable release with a complete support policy.

## Client, server and shared code structure

The documented runtime sequence is straightforward: start `opensoldatserver`, then launch the game client with `-join ip port`. The default example points the client at `127.0.0.1:23073`, while the more general form is `-join ip port`. This separates the game server process from the graphical client process. A user can therefore run the server on one machine and connect a client from another, provided the network path and server address are configured correctly. The README does not document firewall settings, NAT traversal, authentication or server configuration files, so those parts of deployment cannot be inferred from this source.

The repository layout supports that separation more directly than a generic game wrapper would. `client/` contains the client project, `server/` contains the server project and `shared/` is available for code shared between them. The Pascal project names shown for the Lazarus route are `server/opensoldatserver.lpi` and `client/opensoldat.lpi`. CMake is the documented default route because it automates build steps, downloads assets and handles prebuilt libraries. The alternate route requires the developer to assemble libraries and assets manually. This is an important architectural trade-off. CMake reduces setup work for a standard Linux build, while the alternative is more demanding but gives direct control over which libraries and project files are used.

## Linux CMake build for OpenSoldat 1.8

The simplest documented Linux path uses CMake, which the README says downloads OpenSoldat assets and avoids manual installation of prebuilt game libraries. The repository needs to be obtained before these commands can run. After the dependency installation, create a build directory and configure the project. The dependency command is the one published in the README:

```bash
sudo apt-get install build-essential g++ cmake git fpc libprotobuf-dev protobuf-compiler libssl-dev libsdl2-dev libopenal-dev libphysfs-dev libfreetype6
```

The next commands create `build`, change into it and configure CMake. The README presents these as separate steps:

```bash
mkdir build && cd build
cmake ..
make
```

After `make` completes, the generated files should be available in the build tree. The README does not give exact executable paths for every CMake-generated target, so it does not justify adding a guessed path. The next documented action is to run `opensoldatserver` and connect with the client:

```bash
opensoldatserver
```

In a second terminal, use the documented local connection example:

```bash
opensoldat -join 127.0.0.1 23073
```

This is the first real use documented by the project: start the server, then join it from a client. The README does not explain how to create a map, configure a match, select a weapon or add players, so the build guide should not be treated as a full gameplay manual.

## Windows, macOS and Lazarus alternatives

Windows uses Visual Studio with the C++ compiler and build tools, vcpkg, FreePascal 3.2.2 and CMake. The README provides an exact vcpkg command for `sdl2`, `physfs`, `openssl`, `protobuf`, `freetype` and `openal-soft`, then sets the OpenSSL and PhysFS directories before configuring with the `NMake Makefiles` generator. The compiler path is added to `PATH`, and `CROSS_WINDOWS_64=1` is passed to CMake. This route has more environment setup than the Ubuntu instructions, but it makes the dependency and toolchain choices explicit.

The macOS route uses Homebrew for `openssl@3`, `protobuf`, `fpc`, `cmake`, `sdl2`, `physfs` and `freetype2`. It also sets `PKG_CONFIG_PATH` so CMake can locate the Homebrew OpenSSL libraries. The documented commands are:

```bash
brew install openssl@3 protobuf fpc cmake sdl2 physfs freetype2
mkdir build && cd build
export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/usr/local/opt/openssl@3/lib/pkgconfig
cmake -DOPENSSL_ROOT_DIR=$(brew --prefix openssl@3) ..
make
```

Lazarus is a real alternative build method, not merely a different editor around the same documented command. It opens each Pascal project directly and compiles with `CTRL + F9`. The dependency burden changes. CMake automatically handles assets and library acquisition in the documented Linux path, whereas the other-method instructions require copying prebuilt libraries into `client/build` and `server/build`, obtaining `soldat.smod` from the `opensoldat/base` repository, and copying `play-regular.ttf` into `client/build`. That is more manual and more sensitive to directory layout.

## CMake flags and the unfinished 1.8 boundary

The build can be adjusted through CMake options. The README identifies client selection, server selection, asset inclusion and cross-compilation as supported customization areas. It gives one complete example: configure a Release server build with assets and disable the client:

```bash
cmake .. -DCMAKE_BUILD_TYPE=Release -DADD_ASSETS=1 -DBUILD_CLIENT=0
```

The README directs developers to the `CMakeLists.txt` files for the complete option list and defaults. That is an important limitation of the published guide. It does not document every flag, and option names can differ between the top-level and subdirectory configuration. A developer who needs a specialized client, server or cross-compiled target should inspect those files rather than infer behavior from the example.

The 1.8 status creates another boundary. The source is described as having undergone many changes compared with the original version, but not being in a finished state. That means a successful compilation is not equivalent to a feature-complete or release-ready game. The repository also does not document rollback procedures, migration notes for existing Soldat installations, or a supported upgrade path between source revisions. The last push recorded for the repository was on 2026-09-26. That date indicates recent repository activity, but the README still labels the code unfinished, so recent commits should not be confused with a declared stable release status.

## Practical limitations and project fit

The clearest limitation is incomplete documentation around the game systems needed to operate a successful server. The README explains how to compile and connect, but it does not document port changes, server administration, map selection, player permissions, persistence or troubleshooting. The required client address is explicit, yet the server's network exposure is not explained. A developer deploying beyond localhost will need to resolve those operational questions independently.

A second limitation is the dependency surface. The project depends on FreePascal, SDL2, OpenAL, FreeType, PhysFS and GameNetworkingSockets, with Protobuf and OpenSSL appearing in the platform build commands. Different operating systems therefore do not share one identical setup. The Linux route is the clearest path because the README calls it the simplest and gives an Ubuntu package list. Windows and macOS require additional toolchain or package-manager configuration.

Compared with the original Soldat version, the repository's 1.8 source has changed substantially, as the README states, but it does not provide a detailed architectural comparison or a compatibility guide. That makes migration from an existing installation a poor fit for a project selected only for a drop-in upgrade. OpenSoldat is more appropriate for a developer who wants the source, can accept the unfinished 1.8 state and is prepared to inspect `CMakeLists.txt`, Pascal project files and related repositories.

## Conclusion

OpenSoldat suits developers who want to compile and modify a cross-platform 2D multiplayer game with separate client and server code. It is a poor fit for someone expecting a finished 1.8 release, packaged game assets, or documented rollback procedures. Verify the compiler and native library versions, inspect the CMake options, and confirm that the generated client can reach the server address before adopting the project.

## FAQ

### How do I build OpenSoldat on Ubuntu?

Install the packages listed in the README, create a build directory, run `cmake ..` and then run `make`. CMake 3.14 or later is required.

### How do I start an OpenSoldat server and connect a client?

Run `opensoldatserver`, then run `opensoldat -join 127.0.0.1 23073` on the same machine. The general client form is `-join ip port`.

### Can I build OpenSoldat without CMake?

Yes. The README documents opening `server/opensoldatserver.lpi` and `client/opensoldat.lpi` in Lazarus and compiling each with `CTRL + F9`. This route requires manual preparation of libraries and assets.

## Sources

- [Issues](https://github.com/opensoldat/opensoldat/issues)
- [License: MIT](https://github.com/opensoldat/opensoldat/blob/develop/LICENSE)
- [opensoldat/opensoldat on GitHub](https://github.com/opensoldat/opensoldat)
- [README](https://github.com/opensoldat/opensoldat/blob/develop/README.md)
- [Releases](https://github.com/opensoldat/opensoldat/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/opensoldat-opensoldat