Overgrowth Game Source Code: Modding, Building, and Studying WolfireGames' C++ Engine

What the Repository Offers and Who Should Clone It

The WolfireGames/overgrowth repository is the official open-source code for Overgrowth, the third-person action game developed by Wolfire Games LLC. It targets several distinct audiences. Developers who own a licensed copy of the game and want to compile and run modified builds are one group. Contributors who want to submit patches directly to the commercial codebase are another. Researchers and students who want to study a production C++ game engine make up a third.

The README is explicit about what is and is not permitted. Specifically, it lists running experiments for educational purposes, proposing changes to be merged back into the commercial game, creating modifications that would otherwise be impossible, reusing helpful code snippets in other projects, and creating commercial total conversions with entirely new assets. What the repository does not provide is a self-contained, playable game. The art assets, level files, and all other game data must come from a separate purchase of Overgrowth from Wolfire Games. Anyone expecting to run the game without purchasing it will find only a C++ compiler target and nothing to render.

Repository Layout and Key Directories

The top-level directory reveals how the project is organized. The Source/ directory holds the C++ engine code. The Projects/ directory contains the CMake configuration that drives the build. Libraries/ holds external dependencies, and Frameworks/ contains platform-specific framework files. The Data/ directory is present but does not include actual game content; it serves as a mount point for the commercial data the user must supply. ArtSource/ is listed at the root but its contents belong to the commercial asset set.

Additional directories include Docs/ for supplementary documentation, Tools/ for build and utility scripts, and Deploy/ for deployment-related assets. The .github/ directory contains CI workflow definitions. The sonar-project.properties file at the root connects the project to a static analysis pipeline. The Makefile at the root wraps CMake with named targets, making it practical to build without memorizing CMake invocations directly. CONTRIBUTING.md documents how to propose changes, and COMPILING.md is the primary reference for platform-specific build instructions.

Building the Engine from Source with CMake

The build system is CMake, wrapped by the Makefile at the repository root. The process is two steps: a setup step that initializes the build directory, and a build step that compiles the engine.

For a debug build with telemetry disabled:

mkdir -p Build
cd Build; cmake -DCMAKE_BUILD_TYPE=Debug -DNO_TELEMETRY=On -DBUILD_OGDA=Off ../Projects

For a release build:

mkdir -p Build
cd Build; cmake -DCMAKE_BUILD_TYPE=Release -DNO_TELEMETRY=On -DBUILD_OGDA=Off ../Projects

After configuration, compile with:

make

The Makefile uses the nproc value to set parallel jobs by default. The resulting binary is named Overgrowth.bin.x86_64. The Makefile provides a run target that executes it from inside the Build directory. A debug target launches the binary under cgdb. The OGDA flag controls an optional telemetry component and is off by default in non-telemetry builds. COMPILING.md contains the full set of platform-specific prerequisites; the Makefile is a shortcut for the common Linux workflow.

Modding, Total Conversions, and What Apache-2.0 Permits

The Apache-2.0 license gives modders and total conversion developers clear freedom to use the code commercially. You can ship a product that incorporates Overgrowth's engine code and charge money for it, as long as you satisfy three obligations: include the entire contents of the LICENSE file in your distribution, mark each source file you have modified with a notice indicating you changed it, and preserve all existing copyright notices. The README suggests adding a modification note alongside the existing boilerplate comment at the top of each file.

The README explicitly permits creating commercial total conversions that use an entirely new set of assets, which is a meaningful allowance. Many game studios that open-source their engine code restrict it to non-commercial use. Here, the restriction is on the original Wolfire Games assets, not on the code itself.

The asset restriction is absolute: redistributing any of the original Overgrowth art assets, levels, or data requires explicit written permission from Wolfire Games, regardless of what the code license says. A total conversion project sidesteps this by replacing every asset, but that means the conversion team must produce or license every texture, mesh, animation, and audio file themselves. There is no middle ground where a partial set of the original assets can be bundled.

The Asset Dependency: The Central Constraint

Overgrowth's architecture divides the game into code and data. The code is open source. The data is not. Without the commercial game data, the compiled engine will start but have no levels to load and no characters to render. This separation is intentional: it allows Wolfire Games to make the engine technology available for study and modification while keeping the content that has commercial value protected.

For a modder, the workflow always begins with a licensed installation of Overgrowth on the machine. The README notes that the game data can only be legally obtained through a purchase from Wolfire Games. Running the open-source code without that data produces a functional engine with no content. The practical implication for someone evaluating whether to fork this repository is that they need a retail copy of the game first, and then they can overlay their changes on top of the commercial data for testing. Total conversion developers, by contrast, can eventually work without the original data once their own asset pipeline is in place, but bootstrapping the build and testing the engine still typically requires the commercial installation.

How This Differs from Self-Contained Open-Source Game Projects

Godot Engine is a widely used open-source game engine that ships as a complete, self-contained tool: download it, and everything needed to create and ship a new game is present from day one, including the editor, renderer, and scripting environment. No purchase is required and no external asset set is necessary to start building. Overgrowth takes a fundamentally different approach: it opens the code for a specific existing commercial game while keeping the content separate and purchased.

This distinction matters for evaluating what you can do with the repository. Godot users start from a blank project with all tools available. An Overgrowth developer starts with a codebase that is only meaningful when paired with content from a retail purchase. The two serve different purposes: Godot is a platform for building new games, while the Overgrowth repository is a platform for modifying and studying one existing commercial game. For researchers interested in a production C++ game codebase as a learning reference, Overgrowth's open-source release is unusual and genuinely valuable. For developers who want a free game engine to build entirely new games, a project like Godot is the appropriate comparison.

Maintenance Status and the Community-Operated Model

The repository is not archived and received a push on 2026-09-24, which places it within days of being current. The README states explicitly that the repository is entirely community-operated, with no indication of a dedicated Wolfire Games engineering team actively reviewing pull requests. Maintenance relies on community contributions: bug reports, code reviews, and submitted patches.

A CONTRIBUTING.md file documents the process for submitting changes. The CI infrastructure in .github/ and the sonar-project.properties file at the root indicate some automated checks are in place to catch regressions. A TODO file exists at the root, though the README does not describe its contents.

For anyone considering submitting a patch to be merged back into the commercial game, the community-operated model means review timelines are likely variable. There is no formal SLA. Contributors who want their changes adopted into the shipping game need to account for the possibility that the community review process may take time, and that Wolfire Games' editorial direction for the commercial product may not align with every community submission.

Editorial conclusion

Developers who own a licensed copy of Overgrowth and want to study the C++ engine, contribute patches, or build a total conversion using entirely original assets are the intended audience. Those expecting a complete, free, playable game will find only source files; the commercial data is required to render any content at runtime. Before starting, confirm that COMPILING.md covers your target platform, verify that you have legally obtained the game data, and check Apache-2.0's attribution and file-marking requirements for any project you plan to redistribute.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. README
4. WolfireGames/overgrowth on GitHub