A multi-platform 3D game engine for indie developers who want out of Unity’s licensing drama. Honestly reviewed.

TL;DR

What it is: A multi-platform 3D game engine written in C++ and C#, with full source code access, targeting indie and mid-size studios [homepage][README].
Who it’s for: Game developers — indie devs, small studios, and technical teams who want an alternative to Unity or Unreal without opaque licensing. Not a tool for non-technical SaaS-replacing founders.
Cost model: Free to develop. 4% royalty on revenue above $250K per quarter after release [features page]. No per-seat license, no subscription.
Key strength: Full source code included. Hot-reload for both C# and C++. DDGI (real-time global illumination) that rivals far more expensive engines. Active development with 929 commits shipped in the 1.11 release alone [homepage].
Key weakness: 6,674 GitHub stars versus Godot’s 100K+ — the community is small, third-party tutorials are sparse, and console platform support (PS4, PS5, Xbox, Switch) requires separate NDA agreements you negotiate directly [README]. No independent third-party benchmark reviews were available in the sources used for this article — findings are based on primary sources only.

What is Flax Engine

Flax Engine is a modern 3D game engine built in C++ with a C# scripting layer on top. The project is developed by a small team and made the full engine source code available on GitHub in 2018. As of this writing it sits at 6,674 stars with an active commit history — not a dormant experiment [merged profile][README].

The pitch is direct: “A true game changer. Full source code. Full power. Fully featured.” [homepage]. Strip the marketing tone and what you get is a competent real-time 3D engine with rendering quality that punches above the community size, targeting developers who are frustrated with Unity’s licensing instability or find Unreal’s C++ surface area too heavy.

The engine targets Windows, Linux, macOS, Android, iOS, and consoles (PS4, PS5, Xbox, Switch). The desktop and mobile targets are in the public repo. Console support requires platform-specific NDA agreements with Sony, Microsoft, and Nintendo — Flax facilitates these but can’t publish the code publicly [README].

It is not a no-code tool. If you can’t write C#, read compiler output, or run a build system, Flax is not for you. The Visual Scripting system exists and lowers the floor somewhat, but this is fundamentally a developer product.

Why people choose it

The primary driver is Unity’s September 2023 runtime fee proposal — which Unity later rolled back under developer pressure — but the damage to trust was done. Tens of thousands of indie developers started auditing their engine choices. Flax’s “pay when you succeed” model and full source code access became immediately more attractive [homepage].

The three honest reasons developers pick Flax over the alternatives:

1. Source code without an enterprise contract. With Unity, you need a Unity Pro or Enterprise subscription to access the engine source. With Unreal, Epic grants source access via GitHub, but the codebase is 10M+ lines. Flax’s source is available to anyone, smaller, and structured around C#/C++ co-development that most indie devs can actually navigate [README].

2. The royalty model kicks in late. Unreal charges 5% above $1M gross lifetime revenue. Flax charges 4% above $250K per quarter — meaning $1M/year before you pay anything. For a studio doing $500K/year, Flax costs zero in royalties. For a studio doing $2M/year, you pay 4% of the revenue above the quarterly threshold. No per-install fees, no subscription seats [features page].

3. Hot-reload for both C++ and C#. Most engines force you to restart the editor to pick up C++ changes. Flax hot-reloads both scripting languages in the editor, which is a genuine workflow accelerator when you’re iterating quickly [features page][README].

Features

Based on the features page and README:

Rendering:

PBR (physically-based rendering) with Vulkan backend [README]
Dynamic Diffuse Global Illumination (DDGI) with custom software raytracing — real-time GI without baking [features page]
GPU Lightmap Baking for scenes where real-time GI is too expensive [features page]
Large Worlds with 64-bit coordinate precision — no floating-point jitter at large distances [features page]
Automatic draw call batching and instancing [features page]

Scripting and editor:

C++, C#, and Visual Scripting — all three coexist in the same project [features page]
Hot-reloading C# and C++ inside the editor without restart [features page]
Extensible editor via plugins and C# editor scripts [features page][merged profile]
Nested prefabs [features page]
Gameplay Globals for technical artists [features page]

Platform support:

Windows, Linux, macOS, Android, iOS — in public repo
PS4, PS5, Xbox, Switch — available via NDA agreement [README]
Online services integration: Steam, Xbox Live, PSN [features page]

Engine systems:

Animation tools and blending [features page]
Behavior Trees [features page]
Cloth simulation [features page]
VFX tools [features page]
Networking for multiplayer [features page]
Open World tools: terrain, foliage, volumetric fog, level streaming [features page]
Localization tools [features page]
Async content streaming for all assets by default [features page]

Version Control and team workflow:

Built-in VCS support — scenes and prefabs are binary-friendly
Scales described as supporting 5 to 50 developers [homepage]

Pricing: the actual math

Flax’s model:

Development: free, no license fee, no subscription [features page]
Post-release: 4% royalty on revenue above $250,000 per quarter [features page]
Source code: included for all users, no enterprise gate

For comparison:

Unity:

Unity Personal: free up to $200K annual revenue (as of current terms — these have changed before)
Unity Pro: $2,040/year per seat
Source access: requires Unity Pro minimum or separate Source Access agreement
Runtime fee: proposed $0.20/install above thresholds in 2023, rolled back after backlash — the instability itself is the risk

Unreal Engine:

Free to develop, 5% royalty above $1,000,000 cumulative gross revenue
Source code: available on GitHub to all registered users
Enterprise agreement: $1,500/seat/year removes royalty, adds support

Godot:

MIT licensed, no royalties ever
No source access gate — it’s just open
Less mature for 3D AAA-quality rendering than Flax or Unreal

Concrete scenario: A two-person indie studio ships a game that earns $400,000 in its first year (strong indie result). On Unity Pro (2 seats): $4,080/year in licensing. On Unreal: $0 royalty (below $1M threshold). On Flax: $0 royalty (below $250K/quarter threshold — $100K/quarter average is under the bar). On Godot: $0.

At $1,200,000/year (breakout hit): Unity Pro costs $4,080/year plus potential per-install fees depending on tier. Unreal costs 5% of $200,000 above threshold = $10,000. Flax costs 4% of the revenue above $250K/quarter × 4 quarters = 4% × $200,000 × 4 = $32,000. Godot costs $0.

Flax is more expensive than Godot and Unreal at scale for successful studios. It is cheaper than Unity at most mid-tier revenue levels, and the model is more predictable than Unity’s recent history.

Deployment reality check

“Deployment” in the game engine context means building the editor from source, setting up a development environment, and getting a project running.

What you need:

Windows: Visual Studio 2022+, Windows 8.1 SDK, .NET 8 or 9 SDK, Git with LFS [README]
Linux: VS Code, .NET 8+, Vulkan SDK, Clang 14+, libx11-dev and related packages [README]
macOS: Xcode, .NET 8+, Vulkan SDK [README]

The build process runs GenerateProjectFiles.bat (Windows) or equivalent, then opens the generated solution. For someone who has built C++ projects before, this is a 30–60 minute setup. For someone who has never touched a C++ build system, this is a multi-hour debugging exercise around PATH configuration, SDK versions, and dependency resolution [README — troubleshooting section].

What can go sideways:

.NET SDK version mismatches. The README lists a specific error: NETSDK1045: The current .NET SDK does not support targeting .NET 8.0 — you must use Visual Studio 2022, older versions fail [README].
Vulkan SDK required even on Windows for the full rendering backend. Building without it produces a warning and falls back to a reduced configuration [README].
Git LFS required. Cloning without LFS results in missing binary assets — a common gotcha for developers unfamiliar with LFS [README].
Console targets require platform NDA agreements, separate SDK installations, and approval from Sony/Microsoft/Nintendo. Flax can help facilitate but cannot shortcut the platform holder process [README].

Community and support:

Forum at forum.flaxengine.com [README]
Discord server [README]
Roadmap on Trello [README]
Dev blog with release notes [homepage — 1.11, 1.10, 1.9 release posts]

With 6,674 GitHub stars versus Godot’s 100,000+, the community is substantially smaller. Expect fewer third-party tutorials, fewer Stack Overflow answers, and more reading documentation and source code when something doesn’t work.

Pros and cons

Pros

Full source code, no enterprise gate. You get the full C++/C# codebase as a regular user. No “Source Access” upsell, no enterprise contract [README].
Royalty threshold is developer-friendly. The 4% kicks in above $250K/quarter — most indie developers will never hit it. The model rewards small developers [features page].
Hot-reload for C++ and C#. Genuine productivity gain versus engines that require restarts for C++ iteration [features page].
DDGI real-time global illumination. Visual quality that justifies the engine for rendering-focused projects [features page].
Active development. The 1.11 release shipped 929 commits. This is not an abandoned project [homepage].
64-bit world coordinates. Open-world and space game developers know why this matters — floating-point precision artifacts are eliminated [features page].
Console support path exists. Most indie-focused engines don’t reach PS5/Xbox/Switch. Flax does, through platform holder agreements [README].

Cons

Small community. 6,674 stars is a fraction of Godot’s audience. Tutorials, asset packs, third-party plugins, and forum answers are proportionally sparse [merged profile].
More expensive at scale than Godot or Unreal. At $1M+ annual revenue, Godot costs nothing and Unreal’s threshold is higher. Flax at 4% above $250K/quarter is the most expensive of the three at high revenue [features page].
Licensing clarity is incomplete. The merged profile shows “NOASSERTION” for the license field — the exact terms require reading the licensing page directly, not a GitHub SPDX identifier [merged profile].
Console support requires NDA bureaucracy. Reaching PS5 or Xbox means paperwork with Sony and Microsoft. This is not a Flax problem specifically, but it’s a real friction point that Unreal’s established relationships smooth over [README].
No pre-built editor binaries in the repo. You build from source, which is not a trivial step for developers new to C++ build systems [README].
No first-party asset store. Unity’s Asset Store and Unreal’s Marketplace are major productivity resources. Flax has no equivalent at scale.

Who should use this / who shouldn’t

Use Flax if:

You’re a game developer (C#/C++ capable) looking for a Unity alternative after the 2023 runtime fee controversy.
You want full engine source code without paying enterprise license fees.
Your projected revenue is under $1M/year and you want a royalty model that doesn’t bite early.
You’re building a rendering-heavy project and want DDGI without an Unreal-scale codebase.
You’re targeting consoles and are prepared to navigate platform NDA processes.

Skip it (use Godot instead) if:

You want zero licensing risk forever, including at high revenue.
You want the largest open-source game engine community for tutorials and assets.
Your project is 2D-primary.
You need MIT licensing for embedding the engine in a non-game product.

Skip it (use Unreal instead) if:

You need the largest professional ecosystem — plugins, marketplace, tech art talent, documentation.
Your revenue will exceed $1M/year (Unreal’s royalty threshold is higher and the 5% is below Flax’s effective rate at high revenue).
You want first-class Nanite or Lumen rendering tech specifically.
Your studio already has Unreal pipeline expertise.

Skip it (stay on Unity) if:

You’re deeply invested in the Unity ecosystem — Asset Store, DOTS, existing codebase.
Your team is Unity-certified and the retraining cost outweighs licensing costs.
You use Unity’s Plastic SCM, Cloud Build, or analytics services that have no Flax equivalents.

Alternatives worth considering

Godot 4 — MIT licensed, zero royalties, 100K+ GitHub stars, strong 2D and capable 3D. The default answer for developers where licensing cost is the primary concern.
Unreal Engine 5 — Industry standard, 5% royalty above $1M gross, massive ecosystem. Higher C++ barrier to entry but more resources.
Unity — Largest indie ecosystem, subscription pricing, source access gated. The incumbent Flax is positioned against.
O3DE (Open 3D Engine) — Apache 2.0 licensed, Amazon-backed, open source. Less mature community than Flax, more enterprise-oriented.
Stride — MIT licensed C# game engine, smaller than Flax, free forever, primarily .NET focused.

Bottom line

Flax Engine is a technically credible Unity alternative for developers who want full source code access and a royalty model that doesn’t penalize small studios. The rendering quality — DDGI, 64-bit worlds, Vulkan — is serious. The development pace is real. The licensing math is favorable for indie developers below $1M/year in revenue.

The honest caveats: the community is small, the royalty becomes expensive relative to Godot or Unreal at scale, and building from source adds friction that pre-built Unity or Unreal installers don’t have. If you’re a non-technical founder looking to cut SaaS costs, this review isn’t for you — Flax Engine is a game developer tool, full stop.

For indie game developers specifically: if Unity’s licensing instability pushed you to audit alternatives, Flax is worth a week’s evaluation. If cost is the only concern, Godot’s MIT license wins by definition. If quality ceiling and ecosystem matter most, Unreal is still the standard. Flax sits in the middle — better licensing terms than Unity, better rendering than Godot, smaller community than both.

Sources

Flax Engine — Official Website (homepage, features page). https://flaxengine.com
Flax Engine Features Page — licensing terms, platform support, feature list. https://flaxengine.com/features/
Flax Engine GitHub Repository — README, build instructions, platform requirements. https://github.com/flaxengine/flaxengine

Note: The third-party review sources provided for this article contained unrelated content and could not be used. All claims in this review are sourced from Flax Engine’s primary sources above. Independent third-party benchmark comparisons are not reflected here.