# Stride Game Engine: a C# engine you can drive from the command line

> Stride is a free MIT-licensed C# engine for realistic rendering and VR, shipped with the Game Studio editor and a CLI that installs engine versions and scaffolds projects without opening the editor.

**stride3d/stride** — Stride (formerly Xenko), a free and open-source cross-platform C# game engine.

- Repository: https://github.com/stride3d/stride
- Website: https://stride3d.net
- Stars: 7,835 · Forks: 1,167
- Language: C#
- License: MIT
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/stride3d-stride

## What Stride solves for C# teams

Stride is an open-source C# game engine aimed at realistic rendering and VR, with an editor called Game Studio for building and managing content visually. The audience is narrow and clear: developers who already work in C# and want engine code, gameplay code and tooling in the same language, rather than binding into a C++ or JavaScript engine. The README describes the engine as highly modular, which in practice means you can take the parts you need instead of the whole stack. The repository is not archived and the last push was on 2026-09-21, so the codebase is moving. That movement has a cost: the most recent engine release in the list is 4.4.0-beta8, a beta, so anyone who needs a frozen release line should check which version they are actually pinning before they start. The README also splits its audience explicitly. Users who want to make games are pointed at the Get started guide on doc.stride3d.net; the README itself is written for people building the engine from source or contributing to it. That split matters, because following the README literally leads you into a Visual Studio build of the engine rather than into a game project.

## How the engine, Game Studio and the CLI fit together

Three pieces are visible in the repository. The engine and its editor live in the main source tree, with the editor project in a folder named 60-Editor and the solution file at build/Stride.slnx. Game Studio is the visual surface: the README shows it with a script editor screenshot and describes it as the place where you create and manage game content. The CLI is a separate .NET tool, Stride.Cli, published as its own release stream (cli/1.0.3). It manages installed engine versions, creates projects from templates, and launches Game Studio. Templates are a third surface, available both through the CLI and through standard .NET templating as Stride.Templates.Games; the repository keeps them under sources/templates and ships a catalog that the README says includes genre starters, 18 feature demos and tutorials. Samples are versioned separately too, with samples/4.4.1 listed as a release. The practical consequence is that engine version, CLI version, template package and samples can each move on their own schedule, so a project's real dependency set is wider than the engine alone. The README does not document how the CLI resolves which engine version a given project targets beyond the `stride upgrade` command, so that is worth confirming in sources/launcher/README.md.

## Install Stride CLI and create your first project

The README gives the command-line path first, and it is the shortest route to a running project. Install the CLI as a global .NET tool, then use it to install an engine version. The `stride sdk install` command with no argument installs the latest Stride engine according to the README.

```bash
dotnet tool install -g Stride.Cli

stride sdk install
```

Next, scaffold a project. The README's example uses the fps template and names the project MyShooter. Template names listed in the README include game, fps, platformer2d, topdownrpg and vrsandbox. Running `stride new` with no template prints the available list.

```bash
stride new fps -n MyShooter
cd MyShooter && dotnet run --project MyShooter.Windows
```

That last command builds and runs the Windows target of the generated project, so you should see the sample scene open in a window rather than in the editor. To work visually instead, run `stride studio` from the project directory to open Game Studio. Engine versions are managed with the sdk subcommands the README names: `list`, `install`, `uninstall` and `update`, and `stride upgrade` moves an existing project to a newer engine. If you prefer standard .NET templating, the same templates install as a package and produce a project with `dotnet new stride-game`.

## Where Stride is the wrong tool

The README's build instructions are Windows-centric in a way that is easy to miss. Building from source requires Visual Studio 2026 with the .NET desktop development workload (which bundles the .NET 10 SDK) and the Desktop development with C++ workload, and the steps open build/Stride.slnx in that IDE and build the Stride.GameStudio project. The build status table does list Linux Vulkan/OpenGL and iOS entries, so runtimes for those platforms are built in CI, but the README documents no equivalent editor build path for Linux or macOS. If your workflow depends on running the visual editor on a non-Windows desktop, the README does not support that claim, and docs/build/README.md is where the README says the detailed prerequisites live. The second boundary is release stability. The newest engine release in the list is a beta, and the README does not describe a long-term support line, so teams that need a fixed engine version for a multi-year project should verify the release cadence themselves. Third, the engine's stated focus is realistic rendering and VR. If your project is a 2D puzzle game or a lightweight tool, the rendering and VR emphasis is weight you are carrying without using, and the 2D template named in the README is the only 2D entry point it mentions.

## Stride compared with Godot and Unity on the C# path

The closest comparison for a C# team is Godot, and the difference is structural rather than cosmetic. Godot is built around its own scene and node model with GDScript as the first-class language and C# as a supported binding; Stride is a C# engine where the engine, the editor and your gameplay code share one language and one runtime. In Stride the project you scaffold is an ordinary .NET project that you run with `dotnet run --project MyShooter.Windows`, which means your existing .NET tooling, package references and CI habits carry over. Unity is the other reference point, and the difference there is licensing and source access: Stride is MIT-licensed with the full engine source in the repository, so you can read and modify the renderer rather than working against a closed binary. That access is also the cost. An MIT engine with the source in front of you means upgrade work is yours to schedule, and the CLI's `stride upgrade` command moves a project forward but the README does not describe an automatic rollback if a newer engine breaks your project. The README is silent on rollback, so treat an upgrade as a one-way operation until you have verified otherwise.

## Licence, maintenance and the real upgrade cost

Stride is MIT-licensed, and the README links the licence badge to LICENSE.md in the repository. MIT is permissive: it allows commercial use and modification, and it does not impose copyleft obligations on your game code. This is not legal advice, and the repository also carries a THIRD PARTY.md file, which is where the licences of bundled dependencies would be listed; anyone shipping a commercial title should read that file rather than assume the MIT badge covers everything in the tree. On maintenance, the last push was on 2026-09-21, so the project is being worked on now, but the release list shows the engine at 4.4.0-beta8 while the CLI sits at 1.0.3 and samples at 4.4.1. Those version numbers are independent, which is the concrete upgrade cost: bumping the engine does not automatically bump the CLI or the templates, and the README's `stride sdk` subcommands (list, install, uninstall, update) are the documented way to see and change what is installed. The README does not state a support window for any release line, so pinning a version and testing an upgrade on a branch is the only path the documentation supports.

## Conclusion

Adopt Stride if your team already writes C# and wants an MIT-licensed engine with a visual editor plus a scriptable CLI; the documented path is `dotnet tool install -g Stride.Cli`, then `stride sdk install` and `stride new fps -n MyShooter`. Do not adopt it if you need an engine whose editor runs natively on Linux or macOS, since the README only documents building Game Studio from source in Visual Studio 2026 on Windows, and do not adopt it if you need a stable release line rather than a beta, because the newest engine release listed is 4.4.0-beta8. Before committing, verify that `stride new` with no template lists a genre starter that matches your project, and confirm the target platform appears in the build status table.

## FAQ

### How do I install Stride?

The README's command-line path is to install the CLI as a global .NET tool with dotnet tool install -g Stride.Cli, then run stride sdk install to install the latest engine. The README also points users who want to make games at the Get started guide on doc.stride3d.net rather than at the source build instructions.

### How do I use Stride to create a new project?

Run stride new with a template name, for example stride new fps -n MyShooter, then run the generated Windows project with dotnet run --project MyShooter.Windows. Running stride new with no template lists the available templates, which the README says include game, fps, platformer2d, topdownrpg and vrsandbox.

### What is the Stride game engine?

Stride, formerly Xenko, is a free and open-source cross-platform C# game engine designed for realistic rendering and VR, licensed under MIT. It ships with an editor called Game Studio for creating and managing game content visually, and the README describes the engine as highly modular.

## Sources

- [License: MIT](https://github.com/stride3d/stride/blob/master/LICENSE)
- [Project website](https://stride3d.net)
- [README](https://github.com/stride3d/stride/blob/master/README.md)
- [Releases](https://github.com/stride3d/stride/releases)
- [stride3d/stride on GitHub](https://github.com/stride3d/stride)

---

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