OpenTS is a community-led, open-source reconstruction of Command & Conquer: Tiberian Sun. Instead of patching or extending the retail executable, it rebuilds the engine as a standalone program.
This fork carries native Apple Silicon builds of that engine for macOS and iOS. The iPad build is played by touch: it has no mouse pointer, a gesture layer in place of one, and an on-screen indicator that reports the mode the cursor would otherwise have shown. See Running on macOS and Running on iOS. Everything below describes OpenTS itself and applies here too.
OpenTS gives equal weight to two goals: maintaining a playable engine and providing a capable platform for modding and engine development. Work on one goal should not come at the expense of the other.
OpenTS is:
- an independent, community-led source reconstruction targeting Tiberian Sun 2.03 Firestorm;
- a playable engine based on Electronic Arts' GPL-released source for related Command & Conquer games and Tiberian Sun-specific reverse engineering; and
- the active base for maintenance, documentation, modernization, bug fixes, and new modding capabilities.
OpenTS is not:
- a remaster or remake;
- an official Electronic Arts source release; or
- a distribution of the original game assets.
OpenTS is an independent community project and is not affiliated with or endorsed by Electronic Arts.
- Discord: https://opents.net/discord
- Bug reports and proposals: GitHub issues
- Releases are the recommended builds. Each zip on the
releases page
contains
Game.exe,Language.dll, andGame.pdb. - Nightly builds are development snapshots from the Engine nightly workflow. Download the latest one without a GitHub account through nightly.link. Nightlies contain the latest merged changes without release validation and expire after 90 days.
- Install Tiberian Sun from Command & Conquer The Ultimate Collection on Steam or the EA App.
- Extract the release zip into the Tiberian Sun game directory.
- Run
Game.exe.
OpenTS supports Windows 10 version 1903 (build 18362) and newer. Earlier Windows versions are untested and unsupported. Wine may work, but there is no supported native Linux build.
OpenTS supplies the engine, not the game data: the installation above provides the original assets. There is no installer, and no extra runtime library or launch argument is required.
This fork builds and runs the engine natively on Apple Silicon. The game data still comes from a copy of Tiberian Sun you own.
Install the tools:
brew install cmake ninja
brew install --cask steamcmdFetch the game data from your own Steam account:
./scripts/get-assets.sh <your_steam_username>The script downloads app 2229880 into Run/, skips the Windows executables the
engine replaces, and checks that the archives startup needs actually arrived.
Steam Guard prompts for a code on first login. Quit the Steam desktop client
first: steamcmd shares its data directory, and a running client holds a lock
that makes steamcmd hang after "Verifying installation..." with no error. Set
OPENTS_GAME_DIR to put the data somewhere other than Run/.
Build the engine:
git submodule update --init --recursive
cmake -S . -B build/native -G Ninja \
-DCMAKE_BUILD_TYPE=Release \
-DOPENTS_EXPERIMENTAL_NATIVE=ON
cmake --build build/native --target OpenTSBuild the OpenTS target rather than everything: the C++ test harnesses pass
MSVC-only flags and link kernel32, so they do not configure here.
Run it:
build/native/bin/Game -DATADIR=Run -USERDIR=build/native/user-USERDIR is where saves, SUN.INI and logs are written, so pointing it at a
scratch directory leaves an existing install untouched. Full screen is a
setting in the display options screen.
Windows supplies the window, message loop and cursor itself; every other
platform gets them from platform/win32compat, which serves the Win32 surface
the engine is written against out of SDL.
Building OpenTS covers the build in full.
The same engine runs on iPad. It needs an Apple developer account to sign with and a device paired to the Mac; a paid account provisions for a year, a free one for seven days.
Copy the signing template and fill it in. The real file is git-ignored, so no team identifier, signing identity or device UDID is ever committed:
cp scripts/build/ios/ios-signing.env.example scripts/build/ios/ios-signing.envIt names OPENTS_IOS_TEAM_ID, OPENTS_IOS_CODESIGN_IDENTITY (use an Apple
Development identity — a Distribution one will not install directly),
OPENTS_IOS_BUNDLE_ID and OPENTS_IOS_DEVICE. Then build, sign, install, and
copy the game data into the app's own container:
./scripts/build/ios/package-ios.sh --clean --install --push-data --launch--push-data is only needed the first time, or when the data changes. After
that --resign-only --install is the fast loop. Unlock the device first —
a locked iPad refuses the install.
docs/BUILDING.md covers the presets, the on-device data layout and how the
bundle is put together.
There is no mouse pointer on iOS, so the cursor's two jobs are split: gestures do what the pointer did, and an indicator reports what its shape used to say.
| Gesture | Action |
|---|---|
| Tap | Select, or give the order under your finger |
| Drag with one finger | Rubber-band select |
| Drag with two fingers | Pan the map, 1:1, with a coasting flick |
| Press and hold | Cancel the current mode, then deselect |
| Tap during a movie | Skip it |
Nothing is dispatched until a gesture is known, so a second finger arriving turns a pending tap into a pan without leaving a stray click behind — which in this game would otherwise issue an order or place a building. Pinch zoom is deliberately absent: the tactical view magnifies an already-drawn frame rather than revealing more map, so pinching out would only blur it.
An icon in the bottom left corner shows the game's own cursor artwork, animated, whenever it is saying something a finger cannot: sell, repair, power, waypoint and super weapon modes while they are armed, and a unit that is standing somewhere it can deploy. It stays empty the rest of the time, because with no hover the shapes that merely describe what is under the pointer can only appear after the tap that already acted.
The frame is laid out for the device's own display rather than a fixed
resolution, and the frame rate is capped by MaxFrameRate in the [Video]
section of SUN.INI.
The OpenTS manual documents setup, runtime behavior, INI configuration, mapping, and source-level internals.
Release 0.1.0 runs the full Tiberian Sun 2.03 Firestorm game. The GDI, Nod, and Firestorm campaigns, skirmish, and save/load have received full play-through testing. LAN multiplayer has had more limited testing. No user-visible regression from the original game is currently known. The renderer uses bgfx and supports modern resolutions through 4K, including ultrawide.
The first of the project's three development milestones is the current focus:
- CnCNet and CnCNet client support, including porting the parts of ts-patches this requires.
- Feature parity with Vinifera and the rest of ts-patches.
- Extending Tiberian Sun with new features, striving toward feature parity with Red Alert 2 and Yuri's Revenge, and growing engine capabilities that match or exceed the popular Yuri's Revenge engine extensions.
Alongside these goals, the engine is modernized incrementally toward an entity-component architecture, and new development is shaped so that migration stays possible. Project direction explains the reasoning.
OpenTS builds as a 32-bit Windows target with Visual Studio 2022 and CMake. Building OpenTS documents the exact requirements, commands, and outputs.
Bug reports, proposals, documentation improvements, and focused pull requests are welcome. Review capacity is limited, so discuss non-trivial work with the maintainers before implementing it. CONTRIBUTING.md explains the current priorities and review policy; source conventions are in Style.
OpenTS continues the community reconstruction preserved in the TibSun archive, built from Electronic Arts' published source for related Command & Conquer games and completed through reverse engineering against the original executable. History records the reconstruction's lineage and methods.
OpenTS is licensed under the GNU General Public License, version 3 or later. Material derived from Electronic Arts source remains subject to the additional GPL Section 7 terms in LICENSE.md. Third-party notices identify bundled dependencies and their licenses.
ACKNOWLEDGEMENTS.md thanks the people, projects, and communities whose work made OpenTS possible.