Thrive keeps its assets in Git LFS and its history on a second branch
The main repository for the development of the evolution game Thrive.
At a glance
- What is it?
- The main repository of the open evolution game Thrive is written in C# on Godot with native C++ components. Cloning it needs Git LFS, working on the C# means compiling the project yourself, asset contributions go through a developer rather than a pull request, and the pre-LFS history was rewritten onto a branch called original_master.
- Who is it for?
- Thrive suits a contributor who wants to work on a real open source game with a documented style guide, a translation platform and a public planning board. It does not suit someone who wants a quick build: the C# must be compiled, the engine has to be learned, and Git LFS is required before anything large arrives.
- 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 received new commits within the last day.
- 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
- Revolutionary-Games/Thrive3,873 ★ · +157
| Repository | 2026-09-24 | 2026-11-15 |
|---|---|---|
| Revolutionary-Games/Thrive | 3.7k | 3.9k |
157 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Git LFS is a prerequisite, not a convenience
The assets directory holds all the models and other binaries, and the reason it is described first is that it will not arrive in an ordinary clone. The large files in it are stored with Git LFS specifically to stop the repository from bloating, and the instruction is explicit that you need Git LFS installed to get the files. There is a second repository for editable versions of the assets, Thrive-Raw-Assets, which implies the copies inside the main repository are the processed or imported form rather than the source art. Two other folders follow the same split between content and code. simulation_parameters holds JSON files as well as C# constants used for tweaking the game, and scripts holds utility scripts for development. The doc directory is where the style guide and the engine overview live, which is why the README points contributors there rather than repeating the content.
Working on the C# means compiling the game yourself
The programmer section starts with the constraint that defines every other step: Thrive is written in C#, and to work on the C# you need to compile Thrive yourself. The engine is Godot, and two documents are linked for the two halves of the task, a setup instructions page and a learning Godot page for anyone who has not used the engine before. The tree confirms the arrangement at file level. project.godot is the Godot project file, with addons for plugins, shaders for the rendering side and export_presets.cfg for building packaged versions. The .NET side is Thrive.sln as the solution, Thrive.csproj as the project and global.json to pin the SDK version, alongside editor settings in Thrive.sln.DotSettings. src holds the core of the game written in C# as well as Godot scenes, so code and scene files live side by side.
Helper scripts run through dotnet rather than through the engine
The repository also contains helper scripts written in C#, and they are invoked with the .NET tool rather than from inside Godot:
dotnet run --project Scripts -- helpPassing help as the argument is what tells a newcomer the command exists, so this line is effectively the entry point documentation for the script layer. The directory names in the root support that reading: Scripts holds the C# helper layer, ThriveScriptsShared holds shared script code, and a separate common library directory sits beside them. The capitalisation differs from the lowercase scripts and src folders described in the structure section, which is the kind of inconsistency a mixed Godot and .NET project accumulates. Binary files committed anywhere in this tree have to go through Git LFS, and the style guide covers both code formatting and git usage.
Native C++ components bring clang tooling into a .NET solution
Several root entries belong to a second language. CMakeLists.txt sits beside Thrive.sln, and there is a native_libs directory, a lib directory and a third_party directory. Alongside them are .clang-format and .clang-tidy, so C++ formatting and static analysis are configured even though the game logic is C#. merge_drivers is another directory whose purpose is not explained in the README, and it is typical of this repository that several entries carry no description at all. Two build environments are declared: flake.nix with flake.lock for Nix users, and a podman directory for container based work, paired with CIConfiguration.yml at the root as the configuration the continuous integration job reads.
Asset contributions go through a developer, not a pull request
Artists have a separate route, and it is the most unusual rule in the file. The starting point is to install Godot and work on the project files, with the same setup instructions as for programmers, plus the learning Godot page. Some assets can be worked on without a working copy of the Godot project, but then the contributor has to rely on another artist or programmer to put them in the game. The stated process for contributing assets is to contact a developer and hand the files over, and the developer adds them to the official repository. Committing to the Git LFS server directly will be possible later, but is currently limited to Thrive developers. The recommendation for team artists is to modify the project in Godot themselves and commit with Git LFS, and modellers get a separate import tool page for bringing models in.
Tests cover the core, and the Godot version has none
The test folder is described in one sentence that also carries its own limitation: it contains tests to ensure the core parts work correctly, and those tests do not currently exist for the Godot version. That sentence is the most important line in the structure section for anyone deciding what to change. A contributor can assume coverage exists around simulation behaviour, and should assume none exists around the engine layer, which is where a scene file or a shader change would land. The same section notes that some better editable versions of the assets live in a separate repository, so an asset change and its source change are not always in the same place, and both may need Git LFS on the receiving end.
The pre-LFS history was rewritten onto original_master
The Miscellaneous section explains why the commit graph looks unfamiliar. The history of this repository was slightly cleaned up to remove large old binary files that had been added before the project used Git LFS, and the original history is preserved on a branch called original_master. So a blame, a bisect or an archaeology question about an old asset has two answers: the cleaned branch, which is the default master, and the original branch, which is where the pre-LFS commits live. The two branches are different trees of the same project, and the documentation links both. Nothing in the file says how the rewrite was performed or how far back the cleaned history reaches, which means the original branch is the only reliable source for anything older.
Release tags skip versions and planning lives in a GitHub project board
Version signals are irregular. The recent releases are v1.0.1.1 on 2026-03-16, v1.1.0 on 2026-05-23 and v1.6.0 on 2026-08-30, so the fourth component appears on the patch release, the minor line jumps from 1.1 to 1.6, and the releases page is hosted on the studio website rather than on GitHub. Work in progress is tracked elsewhere: the planning board contains all issues and pull requests grouped by priority and status, and it is an organisation level GitHub project rather than a file in the tree. Automation around that flow is configured in the repository too, with .codacy.yml, .coderabbit.yaml and a .pre-commit-config.yaml. Support for contributors runs through the forums and a code of conduct file, bug reports ask for the bug report template, and translations are handled on a separate platform with instructions in the doc folder.
Editorial conclusion
Thrive suits a contributor who wants to work on a real open source game with a documented style guide, a translation platform and a public planning board. It does not suit someone who wants a quick build: the C# must be compiled, the engine has to be learned, and Git LFS is required before anything large arrives. Before opening a pull request, read the contribution guidelines and the code of conduct, use the bug report template for defects, and check whether the area you want to change is covered by tests, since the test folder states that no tests currently exist for the Godot version.
Frequently asked questions
What do I need before I can work on Thrive?
Git LFS installed, because the large files in the assets directory are stored with it and will not arrive otherwise. Programmers must compile Thrive themselves since it is written in C#, and artists install Godot and work on the project files, with setup instructions and a learning Godot page in the doc folder.
How do I contribute an asset to the Thrive project?
Contact a developer and provide the assets, and the developer adds them to the official repository. Committing to the Git LFS server yourself is limited to Thrive developers for now, and team artists are asked to modify the project in Godot themselves and commit with Git LFS.
Are there tests in the Thrive repository?
There is a test directory with tests that ensure the core parts work correctly, and the README states that these tests do not currently exist for the Godot version. Anything in the engine layer is therefore the contributor's own responsibility to verify.
What are the dotnet scripts in the Thrive repository for?
They are helper scripts written in C# that run through the .NET tool rather than inside the engine, and the entry point is `dotnet run --project Scripts -- help`. They sit alongside ThriveScriptsShared and the shared common library, which hold shared script code and the common project library.
Where did the old Thrive commit history go?
The history was slightly cleaned up to remove large old binary files added before the project used Git LFS, and the original history is kept on a branch called original_master. The cleaned default branch is master.
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/revolutionary-games-thrive)Star history chart for your README
[](https://hysenlabs.com/projects/revolutionary-games-thrive)Was this useful?