# Battle for Wesnoth: a GPL-2.0 turn-based strategy game you can build from source

> Battle for Wesnoth is an open source, turn-based tactical strategy game with a high fantasy theme, distributed through Steam, itch.io, the macOS App Store, SourceForge and Flatpak, with the C++ source in the wesnoth/wesnoth repository. The interesting question for an engineer is not whether it is fun but what the codebase and its content pipeline actually require.

**wesnoth/wesnoth** — An open source, turn-based strategy game with a high fantasy theme.

- Repository: https://github.com/wesnoth/wesnoth
- Website: https://www.wesnoth.org/
- Stars: 6,893 · Forks: 1,247
- Language: C++
- License: GPL-2.0
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/wesnoth-wesnoth

## What Battle for Wesnoth solves, and for whom

Battle for Wesnoth is a turn-based tactical strategy game with a high fantasy theme, played either singleplayer or in online and hotseat multiplayer. The README frames the campaigns as tactical problems wrapped in story: reclaim the throne of Wesnoth, search for the key to immortality, or follow other adventures, each with multiple difficulty levels. That combination is the product. It is not a framework and not a game engine you embed elsewhere.

The audience splits in two. Players get a finished game with campaigns, factions, unit traits and skills, a map editor, and community-made map packs, eras and campaigns. Developers get a sizeable C++ codebase with a scripting layer on top. The README says the project is most in need of skilled C++ developers (C++14 and later), but also lists Lua and WML for content scripting, Python for external tools, and play testing as useful contributions. Art is an explicit gap: the README notes Wesnoth lacks art for a variety of unit animations and points to the Art Contributions forum.

If you are evaluating this as an engineering artifact rather than a game, the relevant property is that gameplay content is data-driven. Units, campaigns and maps live outside the compiled binary, which is why community content can exist at all.

## How the game and its content pipeline are put together

The repository layout tells you most of the architecture. The top level holds src/ for C++, data/ for game content, images/, sounds/, fonts/, po/ and translations/ for localization, doc/ for documentation, and packaging/ for distribution. Build systems are present in more than one form: CMakeLists.txt and CMakePresets.json alongside a SConstruct file and an scons/ directory, with cmake/ and source_lists/ supplying generated or enumerated build inputs. vcpkg.json declares the dependency set for a CMake-based build.

Content scripting uses WML, and the repository ships tests for it: run_wml_tests and wml_test_schedule exist at the top level, next to run_boost_tests and boost_test_schedule for the C++ side. That is a meaningful signal about how the project treats content. WML is not free-form configuration; there is a scheduled test suite that exercises it, which is how a project with hundreds of units and many campaigns keeps balance and event logic from silently breaking.

Lua appears as a second scripting layer, and .luacheckrc at the top level indicates Lua linting runs as part of the toolchain. The .clang-tidy file does the same job for C++. So the data flow is: C++ engine, WML and Lua content loaded at runtime, assets from images/, sounds/ and fonts/, translations from po/, all assembled by whichever build system you choose. The README points to the wiki for content creation rather than documenting it in-repo.

## Installing Battle for Wesnoth and playing a first campaign

For most people the README's install list is the whole answer. Windows, macOS and Linux are supported, and the README names Steam for all three, itch.io for Windows and macOS, the macOS App Store, standalone installers on SourceForge for Windows and macOS, and Flatpak for Linux. The Flatpak application ID given in the README is org.wesnoth.Wesnoth.

On Linux, if you prefer Flatpak over a distribution package, the install is a single command against the Flathub remote:

```bash
flatpak install flathub org.wesnoth.Wesnoth
```

After it completes, the game appears in your application menu. Launch it and you land on the main menu, where the campaign list is the first thing worth opening. Pick a campaign, choose a difficulty level, and the first scenario loads with a briefing and objectives.

Building from source is a different path, and the README does not repeat the steps. It says plainly: to build the game from source, see INSTALL.md. That file is at the repository root, so the entry point is:

```bash
git clone https://github.com/wesnoth/wesnoth.git
cd wesnoth
```

What happens after that depends on whether you follow the CMake or the SCons route, and INSTALL.md is where those instructions live. The presence of vcpkg.json and CMakePresets.json suggests the CMake path is the more declarative one for dependencies, but the README does not state a preference, and I would not assume one without reading INSTALL.md.

If you want to make content rather than play it, the map editor is built into the game, and the README says it offers multiple tools, hundreds of terrain types, and the ability to save and share maps. The README directs scenario and campaign authors to the wiki at wiki.wesnoth.org/Create rather than to in-repo documentation.

## Where Battle for Wesnoth is the wrong choice

The mobile story is the clearest limitation. The README states the iOS port is currently unmaintained and is for an older version, 1.14. The Android port is available for 1.19 only, and 1.19 is described as alpha. If your reason for looking at Wesnoth is a mobile deployment, you are looking at an unmaintained client on one platform and an alpha on the other. Neither is a stable target.

Second, the contribution surface is narrower than the feature list suggests. The README asks for C++14 and later for engine work, and WML or Lua for content. Someone who wants to extend the game in a general-purpose language they already know will find the content layer is WML, a format specific to this project and its wiki documentation. That is a real learning cost, offset only by the fact that the format is what makes community campaigns possible.

Third, if you need a game engine to build your own game, this is not it. Wesnoth is the game. The moddability is scoped to maps, eras and campaigns within Wesnoth's rules, not to arbitrary genres.

Finally, the README's own framing of the project's needs is a signal about maintenance load. A project that explicitly asks for art contributions for unit animations is telling you which parts of the asset set are incomplete.

## Alternatives and how their approach differs

The honest comparison is with other open source turn-based strategy games, and the difference that matters here is the content format. Wesnoth puts units, campaigns and scenarios in WML, a declarative markup with an in-repo test schedule (run_wml_tests, wml_test_schedule). A general-purpose engine such as Godot takes the opposite position: you write game logic in a programming language or its own scripting layer, and there is no shipped strategy game to mod. With Godot you build the game; with Wesnoth you extend one that already has campaigns, factions and a multiplayer mode.

A second contrast is distribution. Wesnoth ships through storefronts and package formats (Steam, itch.io, the macOS App Store, SourceForge installers, Flatpak) and also builds from source via INSTALL.md. An engine is typically a library or editor you obtain and then ship your own product with. The maintenance burden lands in different places: with Wesnoth, upstream maintains the game and you maintain your content; with an engine, you maintain everything above the engine.

The trade-off is control. WML constrains what a mod can do to what the engine exposes. A general-purpose engine constrains nothing, which is also why it gives you nothing to start from.

## Maintenance, licence and the upgrade cost you are signing up for

The repository is not archived, and the last push was on 2026-09-21. Development is ongoing on the master branch, and the README's CI table tracks both master and the 1.18 branch, so there are at least two lines to be aware of: a development branch and a stable numbered branch. If you are packaging or building, the branch you track determines how much churn you absorb.

Upgrade cost is concentrated in two places. If you only play, upgrades come through whichever channel you installed from, and that is the storefront's or package manager's problem. If you build from source, your cost is the dependency set declared in vcpkg.json plus whatever INSTALL.md specifies for your platform, and that set can move between releases. If you author content, your cost is WML compatibility across versions, which is exactly the kind of thing the run_wml_tests and wml_test_schedule files exist to catch upstream before it reaches you.

On licensing: the README states all source code is licensed under the GNU GPL v2 or later. Most art and music are also GPL v2 or later, but new contributions are now licensed under Creative Commons BY-SA v4.0. The README points to the wiki page on copyrights for detail. That split matters if you plan to redistribute assets rather than code, because the two categories do not carry the same terms. I am not giving legal advice; read the wiki page and COPYING before you rely on either.

Funding is handled through Software in the Public Interest and Liberapay, and the README says donations pay for project expenses such as server rent and art commissions. That is worth knowing if you depend on the multiplayer servers.

## Conclusion

Adopt it if you want a complete, moddable turn-based strategy game with a readable content format, or if you are a C++ developer looking for a real codebase that still asks for contributors. Do not adopt it expecting a maintained mobile client: the README states the iOS port is unmaintained and stuck on 1.14, and the Android port exists for 1.19 (alpha) only. Before committing to anything, read INSTALL.md for the build path on your platform, and check the 1.18 branch CI badge against master if you need a stable line rather than the development branch.

## FAQ

### What is Battle for Wesnoth?

It is an open source, turn-based tactical strategy game with a high fantasy theme, featuring singleplayer campaigns and online or hotseat multiplayer. The README describes campaigns built around reclaiming the throne of Wesnoth, searching for the key to immortality, and other adventures, each with multiple difficulty levels.

### Is Battle for Wesnoth open source?

Yes. The README states all source code is licensed under the GNU GPL v2 or later. Most art and music are also GPL v2 or later, while new contributions are licensed under Creative Commons BY-SA v4.0.

### Is Battle for Wesnoth free?

The repository is public and the licence is GPL v2 or later, and the README lists installs through Steam, itch.io, the macOS App Store, SourceForge installers and Flatpak. Donations go to Software in the Public Interest and Liberapay to cover project expenses such as server rent and art commissions.

### Is Battle for Wesnoth multiplayer?

Yes. The README lists online and local multiplayer gameplay to play with friends, strangers, or against the AI, alongside the singleplayer campaigns.

### How do I install Battle for Wesnoth on Linux?

The README lists Flatpak for Linux, with the application ID org.wesnoth.Wesnoth, so the install goes through the Flathub remote. Building from source is a separate path and the README points to INSTALL.md for it.

### Is Battle for Wesnoth available on Android and iOS?

Ports exist for both, but the README states the iOS port is currently unmaintained and is for an older version, 1.14, while the Android port is available for 1.19 only, which the README labels alpha.

## Sources

- [Issues](https://github.com/wesnoth/wesnoth/issues)
- [License: GPL-2.0](https://github.com/wesnoth/wesnoth/blob/master/LICENSE)
- [Project website](https://www.wesnoth.org/)
- [README](https://github.com/wesnoth/wesnoth/blob/master/README.md)
- [wesnoth/wesnoth on GitHub](https://github.com/wesnoth/wesnoth)

---

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