OpenTS: releases ship a .pdb, saves remember pointer width, and the licence has two layers
A modern and faithful open source rebuild of the Tiberian Sun engine.
At a glance
- What is it?
- OpenTS rebuilds the Tiberian Sun engine as a standalone program rather than patching the retail executable, and drops into an existing Tiberian Sun install. Its most consequential details are in the release archives, the save format, and a GPL Section 7 carve-out for Electronic Arts derived code.
- Who is it for?
- OpenTS is worth using if you own Tiberian Sun, want a maintained engine rather than a patched retail binary, and can stay on one pointer width for your saves and multiplayer. Do not adopt it expecting a self-contained game, because the assets come from your own copy and the Linux situation is unsupported with Wine merely plausible.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly C++, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- OpenTS-Developers/OpenTS632 ★ · +106
| Repository | 2026-09-21 | 2026-11-15 |
|---|---|---|
| OpenTS-Developers/OpenTS | 526 | 632 |
106 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Every release zip ships Game.pdb alongside the executable
The recommended builds are the releases, and each platform zip is named in a fixed pattern, `OpenTS-<version>-Win32.zip` and `OpenTS-<version>-x64.zip`. What is inside each one is stated as three files: `Game.exe`, `Language.dll`, and `Game.pdb`.
`Game.pdb` is a Windows program database, the debug information file that a C++ toolchain emits alongside a binary. It is the artefact that maps addresses in the executable back to source files, types and line numbers, and it typically carries the absolute paths of the machine that produced the build.
Shipping it in a public release archive rather than as a separate symbols artefact is a choice with two consequences. Anyone can reconstruct the module layout and source paths of your build from a download, and the archive grows by the size of the debug database for no runtime benefit, since a program database is read by a debugger and not by the game.
Nothing in the download instructions mentions removing it. If you are redistributing a build, or building your own and passing the artefact to someone else, that file is the one to drop before you do.
`Language.dll` is the other entry worth understanding: localisation is a separate dynamic library rather than data compiled into the executable, so the engine expects that file to be present and to match the build.
Saves and netcode remember the pointer width of the build that wrote them, and nothing checks
There are two builds, and they are not interchangeable in either direction. The 32-bit build runs on both 32-bit and 64-bit Windows and has the longer runtime history. The 64-bit build runs on 64-bit Windows only.
The compatibility rule is stated without hedging: keep a saved game with the platform that wrote it, and play a network game with peers on the same platform. The reason given is that the two builds write saves and network packets at their own pointer widths, and neither build checks which platform produced the data it is reading.
That last clause is the finding. A format that embeds the writer's pointer width and omits any validation of it does not fail cleanly. The documented symptoms are a failed load or a desync, which is to say either an obvious error or a subtle one. There is no version byte to reject, no checksum over the header, no handshake check that both peers agree on width before a game starts.
So the practical shape is a fork in the road early. The build with the longer history, and the one that runs on older 64-bit machines, writes a format the other build cannot read. Switching later means abandoning saves and finding a new multiplayer community, and the manual is the place where that constraint is documented rather than discovered.
GPL version 3 or later, with additional Section 7 terms on the Electronic Arts derived parts
The licence is described in two sentences that need to be read as two layers. OpenTS is under the GNU General Public License version 3 or later, and material derived from Electronic Arts source remains subject to additional GPL Section 7 terms recorded in `LICENSE.md`.
Section 7 is the clause that lets a copyright holder grant extra permissions beyond the GPL's terms. For a project assembled from a mixture of reverse engineering and an upstream GPL source release, that is exactly the mechanism you would expect: the community-written parts stay plain GPLv3, and the parts traceable to Electronic Arts published source carry an additional condition.
The practical problem is that the README does not say which files fall on which side. If you want to redistribute a modified engine, or combine it with your own code, you need to know the provenance of the specific files you are shipping, and the visible text gives you a licence file to read and no map to read it with. `THIRD_PARTY_NOTICES.md` covers bundled dependencies and their licences, which is a third category: neither community code nor EA code.
There is also a mismatch worth flagging to anyone reading this repository programmatically. The recorded licence field for the project could not be determined and comes back as unasserted, while `LICENSE.md` at the root and the licence section both state GPL version 3 or later with the Section 7 addition. The files are more specific than the metadata, so the files are what to trust.
Nightlies are unvalidated, expire after 90 days, and arrive through a proxy service
Two build workflows run in this repository. One produces releases and carries the badge at the top of the README. The other, named for nightly engine builds, produces development snapshots.
The nightlies are described in three clauses worth separating. They contain the latest merged changes without release validation. They expire after 90 days. And they can be downloaded without a GitHub account through a third-party service that fetches workflow artefacts on the reader's behalf.
Each clause constrains a different thing. No validation means a nightly is the merged state of `main` with whatever review happened, which for a project that states its review capacity is limited is a meaningful caveat. The 90-day expiry means a nightly URL is not a stable reference: any documentation, script, or Docker base image you point at a nightly artefact stops resolving after three months. And the proxy in the middle means an unvalidated binary reaches your disk through a service that is not the project's own infrastructure.
Releases remain the recommended path, and the split is a sensible one for a project at version 0.1.0. The thing to avoid is treating a nightly as if it were a release because it was convenient on one day.
It is an engine dropped into a game you already own, and four lines say what it is not
Installation is three steps. Install Tiberian Sun from Command and Conquer The Ultimate Collection on Steam or the EA App, extract the release zip into the Tiberian Sun game directory, and run `Game.exe`.
There is no installer, no extra runtime library, and no launch argument. The zip replaces or adds to the engine inside an existing game directory, and the original assets come from that copy.
The framing matters more than the steps, and it is stated in a dedicated block. OpenTS is not a remaster or a remake, not an official Electronic Arts source release, and not a distribution of the original game assets. The project also states that it is independent and not affiliated with or endorsed by Electronic Arts.
Read together, those lines describe a project whose legal position depends on you already owning the game. That is why the assets are not in the repository, why there is no installer that could fetch them for you, and why the funding link in the badge row points at a creator page rather than a store.
Platform support is narrow in the same spirit. Windows 10 version 1903, build 18362, and newer is the supported floor, earlier versions are untested and unsupported, Wine may work, and there is no supported native Linux build. Building from source needs Visual Studio 2022 and CMake, for both 32-bit and 64-bit Windows.
Faithful to the game and modern at the display: the renderer is bgfx at 4K and ultrawide
The reconstruction is described as a mix of two sources. It continues a community reconstruction preserved in an archived repository, built from Electronic Arts published source for related Command and Conquer games, and completed through reverse engineering against the original executable. A separate document is said to record the lineage and the methods.
So the engine is not written from nothing, and it is not a decompile. Part of it descends from a GPL source release the publisher made, and part of it was recovered by observing the shipped program.
Against that, the graphics layer is a modern third-party library rather than a reconstruction. The renderer uses bgfx, and supports modern resolutions through 4K including ultrawide.
That pairing is the interesting tension. A project whose stated value is fidelity is running a rendering backend the original never had, on display modes the original never supported. It is a deliberate trade and a common one in this kind of work, but it means pixel-for-pixel comparison with Tiberian Sun 2.03 is not the goal the renderer supports.
The tree is consistent with borrowed code being part of the deal. There is a `.gitmodules` file and a `thirdparty/` directory, so dependencies arrive as submodules rather than vendored in place, alongside `THIRD_PARTY_NOTICES.md` to account for them.
Version 0.1.0 claims full campaign play-through and no known regression
The state section makes three claims and hedges one of them.
Release 0.1.0 runs the full Tiberian Sun 2.03 Firestorm game. The GDI, Nod and Firestorm campaigns, skirmish, and save and load have received full play-through testing. No user-visible regression from the original game is currently known.
The hedge is multiplayer: LAN multiplayer has had more limited testing. So the testing statement covers the three campaigns and the skirmish mode exhaustively and covers the network path only partially, on a topology, local, that people often do not use.
That asymmetry is worth keeping in view alongside the version number. A 0.1.0 that has been played through end to end, with no known user-visible regression, is a stronger claim than the version string suggests, and it is the kind of claim that ages badly if a regression turns up later without a note explaining when it appeared.
The plan section sets three milestones in order. The current focus is the first: CnCNet and client support, including porting the parts of an existing patch collection that requires. The second is feature parity with Vinifera and the rest of that patch collection. The third is extending Tiberian Sun toward parity with Red Alert 2 and Yuri's Revenge, and matching or exceeding the popular Yuri's Revenge engine extensions. Long term the engine moves incrementally toward an entity-component architecture, with a project direction document explaining the reasoning.
The root carries agent configuration for four tools and six documentation trees
This is a documentation-heavy repository, and the layout says so. Alongside `code/`, `cmake/`, `ui/`, `thirdparty/`, and `tests/`, the root holds `docs/`, `manual/`, `Run/`, and four separate documentation files named for their audiences: `CONTRIBUTING.md`, `THIRD_PARTY_NOTICES.md`, `ACKNOWLEDGEMENTS.md`, and `LICENSE.md`.
Then there is the tooling configuration. The root has `AGENTS.md` and `CLAUDE.md`, and four dot-directories: `.agents/`, `.claude/`, `.codex/`, and `.cursor/`. A C++ engine project carrying per-tool agent setup for four different assistants is a deliberate bet that a good share of contributions will arrive through them.
Editor and build conventions are covered too, with `.clang-format`, `.editorconfig`, and a `.vscode/` directory.
Governance is stated plainly. Bug reports, proposals, documentation improvements and focused pull requests are welcome, and review capacity is limited, so non-trivial work is meant to be discussed with the maintainers before it is implemented. The contributing guide is said to explain current priorities and the review policy, with source conventions in a separate style document.
Two directories are worth naming without guessing at their contents. `Run/` sits at the root next to the build and source trees, which is where runtime data for this class of engine usually lives, and `tests/` is present although the README does not describe what it covers or how to run it.
Editorial conclusion
OpenTS is worth using if you own Tiberian Sun, want a maintained engine rather than a patched retail binary, and can stay on one pointer width for your saves and multiplayer. Do not adopt it expecting a self-contained game, because the assets come from your own copy and the Linux situation is unsupported with Wine merely plausible. Before you install, read LICENSE.md to find out which parts of the tree carry the additional Section 7 terms, strip Game.pdb from any archive you redistribute, decide whether a 90-day nightly is acceptable input to your setup, and treat the multi-platform compatibility warning as a hard rule rather than a caveat.
Frequently asked questions
What is OpenTS and what does it replace?
It is a community-led reconstruction of the Tiberian Sun engine, built as a standalone program rather than a patch or extension of the retail executable. You install Tiberian Sun yourself and extract the release zip into that game directory.
Which OpenTS builds can I use, and can I switch between them?
There is a 32-bit build that runs on both 32-bit and 64-bit Windows with the longer runtime history, and a 64-bit build for 64-bit Windows only. Saves and network packets are written at each build's own pointer width and neither build checks the writer, so keep saves and multiplayer peers on one platform.
What is in an OpenTS release archive?
Each platform zip contains Game.exe, Language.dll and Game.pdb, named OpenTS-<version>-Win32.zip or OpenTS-<version>-x64.zip. Game.pdb is the Windows debug information file, so remove it from any archive you redistribute.
What licence is OpenTS under?
The GNU General Public License version 3 or later, with material derived from Electronic Arts source remaining subject to additional GPL Section 7 terms recorded in LICENSE.md. Bundled dependencies and their licences are identified separately in THIRD_PARTY_NOTICES.md.
Can I run OpenTS on Linux?
There is no supported native Linux build. Wine may work, and the supported floor is Windows 10 version 1903, build 18362, or newer, with earlier versions untested and unsupported. Building from source requires Visual Studio 2022 and CMake for Windows targets.
How current are the OpenTS nightly builds?
Nightlies are development snapshots from a workflow that carries the latest merged changes without release validation, and they expire after 90 days. They can be downloaded without a GitHub account through the nightly.link service, so a nightly reference will not stay valid indefinitely.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/opents-developers-opents)Star history chart for your README
[](https://hysenlabs.com/projects/opents-developers-opents)Was this useful?