C# game engines compared

The game engines that use C# are Unity, Godot (its .NET version), Stride, Flax Engine and Evergine, which are engines with editors; MonoGame, FNA, KNI and raylib-cs, which are frameworks or bindings where you build the engine yourself; and onegame, an engine with no editor where the whole game is C# and text. In Unity, Godot and Flax, C# is the language for your game code; Stride calls itself a C# game engine, and in onegame the game, its tests and its tooling are all driven from C#. The quickest way to narrow the list is three questions: do you want an editor, which platforms must you ship on, and what license can you accept.

Every fact about an engine below comes from its own website, documentation or NuGet listing, linked in place and read on October 26, 2026. Prices and platform lists change, so check the current page before deciding.

C# game engines at a glance

“Not covered here” and “not documented” mean the pages read for this article don’t say. They are not statements that a feature is missing. Unity’s figures are from its pricing page and Unity Personal FAQ. Unity canceled its Runtime Fee for games on September 12, 2024 (Unity blog).

Engines with an editor

Unity’s manual describes scripts as the way to customize and extend an application with C# code, with MonoBehaviour scripts as custom components on GameObjects (Unity manual). Godot is MIT licensed and editor-first. Read its C# page before choosing it for the browser: “Projects written in C# using Godot 4 currently cannot be exported to the web platform” (Godot C# basics). Stride is a C# engine with physics, particles, navigation and VR (features), and it supports code-only development as well as its Windows editor. Flax mixes C++ and C# and is the one engine here with a royalty. Evergine calls itself “the multiplatform graphics engine designed for industry”.

For a closer look at these for someone leaving Unity, see Unity alternatives for C# programmers.

Frameworks: build your own engine in C#

MonoGame is “a ‘bring your own tools’ framework” that “does not include any pre-built editors or interfaces” (MonoGame docs). FNA reimplements XNA 4.0 “with an incredible focus on accuracy” and focuses on the desktop. KNI derives from MonoGame and adds web browsers and VR. raylib-cs binds a C library and ships a browser runtime. All four leave the engine’s structure to you. MonoGame alternatives compares them in detail.

A C# game engine without an editor

onegame sits between the two groups: it is an engine, with sync, UI, rendering, testing and export built in, but it has no editor. A game is C# plus text assets, driven by the onegame command. This is the whole game that onegame new writes: a ship drawn from a picture, flown with the keyboard or a gamepad.

dotnet tool install -g RecursiveAI.OneGame.Cli --version 1.2.0
onegame new meadow
cd meadow

using System;
using System.Numerics;
using OneGame.Core;
using OneGame.Host;
using OneGame.Platform;
using OneGame.UI;
 
namespace Meadow;
 
/// <summary>A ship. Synced state is fixed-point and changes only through commands; the view draws it from art/ship.png and never writes state.</summary>
[Entity]
public partial class Ship : Entity, IView2D
{
    [Synced] public partial Fixed X { get; private set; }
    [Synced] public partial Fixed Y { get; private set; }
    [Synced] public partial int Dx { get; private set; }
    [Synced] public partial int Dy { get; private set; }
    [Synced] public partial bool Boost { get; private set; }
 
    [Command]
    public void Steer(int dx, int dy, bool boost) => (Dx, Dy, Boost) = (dx, dy, boost);
 
    // Runs once per fixed simulation tick: deterministic code only (no floats, clocks or I/O in synced state).
    protected override void OnTick()
    {
        var speed = Boost ? Fixed.FromInt(3) : Fixed.FromRatio(3, 2);
        X += speed * Dx;
        Y += speed * Dy;
    }
 
    // View code reads state and never writes it. The picture is an asset: edit art/ship.png while the game runs and it changes.
    [View]
    public void Draw(Draw2D d) =>
        d.Sprite("art/ship.png", new Vector2(X.ToSingle(), Y.ToSingle()), scale: 2, tint: Boost ? Color.Rgb(0xFFD080) : Color.White);
 
    [View]
    public string Label() => $"x {X.ToInt()}  y {Y.ToInt()}";
}
 
/// <summary>The game: its entity types, its starting world, its input actions and its screens.</summary>
public sealed class MeadowGame : GameDefinition
{
    public override string Name => "meadow";
 
    public override void RegisterEntities(EntityRegistry registry) => OneGame.Generated.Meadow.EntityTypes.Register(registry);
 
    public override void Setup(World world) => world.Add(new Ship());
 
    // Input is declared as actions with default bindings. One declaration answers the keyboard, a gamepad and the test harness.
    public override void DefineActions(ActionMap actions) =>
        actions.Context("play", c => c
            .Vector("move", Bind.Wasd, Bind.Arrows, Bind.LeftStick)
            .Button("boost", Bind.Key(Key.Space), Bind.Pad(GamepadButton.South)));
 
    // View code reads the actions and sends the ship a command when they change.
    public override void OnEachFrame(GameInstance game)
    {
        var ship = ShipOf(game);
        var move = game.Actions.Vector("move");
        int dx = (int)MathF.Round(move.X), dy = (int)MathF.Round(move.Y);
        var boost = game.Actions.Held("boost");
        if (dx != ship.Dx || dy != ship.Dy || boost != ship.Boost)
        {
            ship.Send.Steer(dx, dy, boost);
        }
    }
 
    public override void DefineScreens(ScreenSet screens) =>
        screens.Add("main", game => Ui.Label(() => ShipOf(game).Label()).Named("pos").Padding(Length.Px(8)).TextColor(Color.White));
 
    // Read the world through the instance: it is replaced when a snapshot or fixture is loaded.
    private static Ship ShipOf(GameInstance game) => (Ship)game.World.Entities[0];
}

The Ship class is an entity: fixed-point [Synced] state, a [Command], a fixed-tick OnTick, and [View] members, one of which draws it with Draw2D. Source generators write its change tracking, codecs, deltas and snapshots, and analyzers make floats, clocks, threads and I/O in its simulation code compile errors. DefineActions declares the controls once, for the keyboard, a gamepad and the tests. Run, test and export it:

onegame run --headless --frames 60 --json
onegame test
onegame export --target linux

{"ok":true,"game":"meadow","headless":true,"frames":60,"tick":60,"hash":"4cae793ac9d6b058","width":1280,"height":720}

PASS ship-looks-right (467 ms, tick 40, hash 1d9032e311c8f909)
PASS steer-ship (4 ms, tick 22, hash 356d3b991d053534)
2 passed, 0 failed

exported meadow 1.0.0 for linux-x64 (nativeaot): 6 files, 7622 KiB
  folder:  /tmp/games/meadow/export/meadow-1.0.0-linux-x64
  archive: /tmp/games/meadow/export/meadow-1.0.0-linux-x64.tar.gz (3689 KiB)
  warning glibc_too_new: Meadow needs glibc 2.38, newer than 2.31 in Steam's Linux runtime (and so on the Steam Deck). Build on an older system, or inside the Steam Linux Runtime SDK: see docs/exporting.md.

What it builds in: 2D sprites, shapes and text drawn from view code, input actions with rebinding, assets that reload while the game runs, client/server sync with client-side prediction and drift hashes, a deterministic simulation enforced at build time, 2D and 3D rendering on Vulkan, Metal and WebGPU with glTF import, a UI system with CSS-model styling and controller navigation, Steam integration, and automated game testing with scenarios, replays and screenshot checks. What it doesn’t have at 1.2.0: a physics engine, an ECS (entities are classes), an editor, and web, Android and iOS exports from the NuGet packages, which need an engine checkout. Its docs don’t cover consoles. To build a small game this way from start to finish, see C# game development without an editor.

How to choose a C# game engine

• You want an editor and Unity’s Asset Store: Unity, after reading its current pricing.
• You want an editor and an MIT license: Godot, if you don’t need C# on the web; Stride, if you want the engine itself in C#.
• You need C++ beside C#: Flax, with its royalty terms.
• You want full control and consoles: MonoGame or FNA.
• The web is a must with an XNA-style API: KNI, or raylib-cs for a C library.
• You want everything in code, multiplayer and tests built in, shipping on desktop and Steam: onegame, if you can write your own movement and collision.

To try onegame, start with Getting started. Coming from another engine, see onegame for Unity developers or onegame for MonoGame developers.