OpenRA: a C# RTS engine for Red Alert, Tiberian Dawn and Dune 2000

What OpenRA actually is, and who it is not for

OpenRA is an engine, not a game download in the usual sense. The README describes it as a "Libre/Free Real Time Strategy game engine supporting early Westwood classics", and the distributed mods it names are reimaginings of Command & Conquer: Red Alert, Command & Conquer: Tiberian Dawn and Dune 2000. The engine itself is written in C# and uses SDL and OpenGL, and the repository runs on Windows, Linux, *BSD and Mac OS X.

The audience splits in two. Players get a cross-platform client with the same rulesets across operating systems. Modders get a YAML-driven engine with an auto-generated trait documentation site, a Lua API for scripted missions, and a separate Mod SDK repository for total conversions. If you want a general-purpose engine for a new RTS of your own design, OpenRA is a poor fit: its data model is shaped around Westwood-style maps, tilesets and unit rules, and the README points newcomers to a Hacking wiki page it itself calls "now very outdated". That is an honest signal about how much engine-internals documentation you will find.

One legal point worth stating plainly: the README carries the line "EA has not endorsed and does not support this product." The project ships under GPL-3.0 and distributes its own assets and code, but the trademark and the original games belong to someone else.

How the engine is put together: projects, mods and traits

The repository layout is the fastest way to understand the architecture. OpenRA.Game/ holds the core engine. OpenRA.Mods.Common/ holds shared gameplay traits, while OpenRA.Mods.Cnc/ and OpenRA.Mods.D2k/ add content specific to the Command & Conquer line and to Dune 2000 respectively. OpenRA.Platforms.Default/ is the SDL and OpenGL platform layer, OpenRA.Server/ is the dedicated server, OpenRA.Utility/ is the command-line tool, and OpenRA.Launcher/ plus OpenRA.WindowsLauncher/ handle startup. OpenRA.Test/ holds tests. The solution file is OpenRA.slnx.

Game content lives in mods/, and the engine's behaviour is assembled from traits declared in YAML. The README links an auto-generated trait reference at docs.openra.net, which is what you read when you want to know which keys a unit or building accepts. Scripted missions use the Lua API documented at the same site. This split matters: you can change gameplay drastically through custom rules without touching C#, which is what the Mapping tutorial in the wiki is about.

The default branch is bleed, which is the development line rather than a stable tag. Releases are tagged separately, and there is a playtest line as well. If you are packaging OpenRA for other people, tracking bleed means tracking an unreleased state.

Installing OpenRA and running a first match

The README does not walk through installation. It points to INSTALL.md in the repository and to the Compiling wiki page for setting up a development environment. The Makefile is the entry point on Unix-like systems and documents its own targets in a comment block at the top.

The plain build command is make. The Makefile header states that running make compiles the project, and the toolchain section shows it invokes dotnet with a CONFIGURATION that defaults to Release.

make

If you would rather link against libraries already present on your system instead of the bundled native dependencies, the header gives a second form. DEPENDENCIES defaults to bundled, and the header documents the alternative.

make DEPENDENCIES=system

Before shipping a build, the header lists two checks worth running. One validates the official mods for erroneous YAML files, the other checks the engine and official mod DLLs for code style violations.

make test
make check

To install the three distributed mods, the header gives an install target that accepts prefix and bindir overrides, and separate targets for FreeDesktop startup scripts, AppStream metadata and the man page.

make prefix=/usr/local install
make install-linux-shortcuts

On Windows the repository provides make.cmd, and the launch scripts are launch-game.sh and launch-game.cmd for the client, launch-dedicated.sh and launch-dedicated.cmd for a server. The README also notes you can set up a Dedicated Game Server immediately, linking the wiki page for it. After a build, what you should see is a client that offers the Red Alert, Tiberian Dawn and Dune 2000 mods, since those are the mods the README says are distributed.

Where OpenRA gets in your way

The dependency situation is the first real constraint. The Makefile defaults DEPENDENCIES to bundled, which means the build pulls its own native libraries rather than using what is installed. That is convenient on a desktop and awkward in a distribution packaging context, where you are expected to build against system libraries. The DEPENDENCIES=system path exists, and a configure-system-libraries.sh script sits at the top level, but the Makefile header treats bundled as the default for a reason.

The second constraint is documentation drift. The README links the Hacking page as a "(now very outdated) overview of the engine". For anyone trying to understand the C# internals rather than the YAML surface, that is a warning, not a resource. The trait reference and Lua API are auto-generated and therefore current, but they describe the data model, not the reasoning behind it.

Third, the content boundary. If your interest is Red Alert 2, Tiberian Sun or an Android build, this repository does not cover it. The README names three distributed mods and no mobile platform in its supported list. Related searches for those titles exist, and the repository is silent on them.

Finally, there is no documented rollback path. The README does not discuss downgrading between releases, and the release tags are separate from the bleed branch. If you need reproducible deployments, pinning a release tag rather than tracking bleed is the only mechanism the material actually shows.

OpenRA compared with CnCNet and the remastered collection

The two comparisons people search for most are CnCNet and the Command & Conquer Remastered Collection, and they differ from OpenRA in kind rather than degree.

CnCNet is an online multiplayer service for the original Westwood games. Its approach is to keep the original executables and supply matchmaking and networking around them. OpenRA takes the opposite route: it is a new engine, written in C#, that reimplements the games and their rules. That means OpenRA can change balance, pathfinding and interface in ways a service layered over the original binaries cannot, and it also means OpenRA's behaviour is not byte-identical to the originals. If your goal is fidelity to the shipped 1990s executables, a service that runs those executables is the closer match.

The Remastered Collection is a commercial release from the rights holder. It ships source code for its own engine under a different arrangement and is sold as a product. OpenRA is GPL-3.0 and free, and the README explicitly states that EA has not endorsed or supported it. The trade-off is support and assets: a commercial remaster comes with official art and official backing, while OpenRA comes with a community forum, an IRC channel and a Discord, and a Mod SDK you download separately to start your own total conversion.

Maintenance, releases and what GPL-3.0 means for your build

The repository is not archived, and the last push was on 2026-09-14, so the development line is current. Releases are tagged on their own schedule: release-20250303, release-20250330 and playtest-20260222 appear in the release list. Notice the gap between the March 2025 releases and the February 2026 playtest, and that the playtest is not a stable release. If you need a stable artefact, the release tags are what you have; if you need the newest engine behaviour, you are on bleed or a playtest.

Upgrade cost depends on which surface you touch. YAML mods are validated by make test, which catches malformed rules before you ship, and the trait documentation is regenerated so you can check whether a key you rely on still exists. C# changes are the expensive ones, because trait APIs move and the Hacking page that would explain them is flagged as outdated. Budget for reading the source when the docs run out.

On licensing: OpenRA is GPL-3.0. The README states it is made available under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 or any later version. The practical consequence for anyone distributing a modified engine is that the GPL's source-availability terms apply to what you distribute. This is not legal advice, and if you are combining OpenRA with proprietary code or assets, that is a question for a lawyer rather than a wiki page. The README also credits SignPath.io and the SignPath Foundation for free code signing on Windows, which is infrastructure rather than a licensing term.

Editorial conclusion

Adopt OpenRA if you want to play or mod early Westwood RTS games on a cross-platform engine with a documented Lua API and a public trait reference, and if you can accept a GPL-3.0 obligation on anything you distribute. Do not adopt it expecting Red Alert 2 or Tiberian Sun content: the README lists only Red Alert, Tiberian Dawn and Dune 2000 as distributed mods, and the related searches asking about the other two titles have no matching mod in this repository. Before you commit, verify that your target platform builds from INSTALL.md, check the VERSION file and the newest release tag for the branch you intend to ship, and confirm that the mods/ directory contains the game you actually want.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. OpenRA/OpenRA on GitHub
3. Project website
4. README
5. Releases