Stride

Stride (formerly Xenko) is a free, open-source C# game engine backed by the .NET Foundation and designed for developers who want high-fidelity graphics, VR, and cross-platform deployment without leaving the C# ecosystem. It supports Direct3D 11/12, Vulkan, OpenGL, and OpenGL ES rendering backends, enabling realistic visuals on Windows, Linux, iOS, and Android from a single codebase.

At the heart of Stride is Game Studio, a full-featured visual editor for scene composition, asset management, material editing, and script integration. Developers write gameplay logic in C# using .NET 10, with full Visual Studio 2026 support for debugging and profiling. Stride’s modular architecture means rendering pipelines, physics engines, input systems, and asset compilers can all be swapped or extended independently.

Stride ships with two physics backends — the modern Bepu Physics 2.5 library for deterministic rigid-body and soft-body simulation, and legacy Bullet Physics support for projects that depend on it. For VR, the engine provides native OpenXR, OpenVR, and Oculus OVR integration including touch controller input and passthrough support. The custom SDSL shader language (a superset of HLSL) compiles to all supported graphics APIs, and voxel cone tracing is available as an optional rendering module.

An active community of over 140 contributors drives continuous development, with releases averaging monthly and a bug bounty program funded through Open Collective. New projects can be bootstrapped directly from the command line using official .NET templates — no editor required for initial setup.

What You Get

• Game Studio Visual Editor - A full-featured drag-and-drop editor for scene composition, material editing, prefab management, and asset pipeline integration, launching directly from Visual Studio 2026.
• Multi-API Rendering Pipeline - Native support for Direct3D 11, Direct3D 12, Vulkan, OpenGL, and OpenGL ES backends with a custom SDSL shader language that compiles to all targets from a single source.
• Dual Physics Backends - Modern Bepu Physics 2.5 for deterministic rigid-body, soft-body, and constraint simulation alongside legacy Bullet Physics support for backward compatibility.
• Native VR Integration - Built-in support for OpenXR, OpenVR, and Oculus OVR with touch controller input, tracked items, and Facebook passthrough via native device classes.
• Cross-Platform Deployment - Build and deploy to Windows (ARM64 included), Linux (Wayland/X11), iOS, and Android from the same C# codebase with platform-specific CI pipelines.
• CLI Project Templates - Create game projects from the command line using official dotnet new templates including genre-specific starters (FPS, 2D platformer, top-down RPG, VR) without opening the editor.
• Voxel Cone Tracing - An optional real-time global illumination module implementing voxel cone tracing for indirect diffuse and specular lighting, extending the default rendering compositor.
• Community-Funded Development - Bug bounties and paid contribution opportunities funded through Open Collective, with over 140 contributors and active governance through the .NET Foundation.

Common Use Cases

• Indie 3D game development - A solo developer uses Game Studio to build a third-person action game in C#, leveraging Bepu Physics for collision, the SDSL material system for PBR shaders, and the CLI templates to bootstrap the project in minutes.
• VR application development - A studio builds a surgical training simulation using Stride’s OpenXR integration, touch controller tracking, and Direct3D 12 renderer to achieve sub-20ms frame times on HTC Vive and Meta Quest.
• Cross-platform mobile game shipping - An indie team creates a physics-heavy puzzle game targeting iOS and Android simultaneously, using Bepu’s deterministic simulation for consistent cross-platform behavior and shared C# logic.
• Real-time architectural visualization - An architecture firm uses Stride’s Vulkan backend and voxel cone tracing module to render walkthroughs of building designs with dynamic global illumination on high-end workstations.
• Educational game development - A university computer science department uses Stride for an introduction to game dev course, taking advantage of Game Studio’s visual scene editor and C# scripting to minimize toolchain complexity.
• Engine customization and research - A game technology researcher forks Stride to experiment with custom rendering features, using the modular architecture to plug in a new GPU-driven render path without modifying core engine assemblies.

Under The Hood

Architecture Stride follows a layered, modular architecture with a clear division between its runtime core, rendering subsystem, asset pipeline, and editor tooling. The entity system uses an EntityProcessor pattern where components declare their data contracts and processors implement the per-frame logic, enabling data-oriented design patterns without requiring a full ECS rewrite. Rendering is decoupled into a composable RenderFeature and RenderStage graph that game authors configure in Game Studio, allowing complete replacement of the rendering pipeline without touching engine internals. The asset pipeline operates as a separate build-time process (the build engine) that compiles source assets into runtime-optimized binary formats, keeping editor and runtime concerns cleanly separated. A micro-threading system based on cooperative coroutines underpins async scripting, and a custom YAML serialization layer handles all scene and asset persistence.

Tech Stack Stride is implemented almost entirely in C# 14 targeting .NET 10, with performance-critical native layers in C++ and Assembly for platform-specific rendering and audio. The graphics abstraction layer speaks Direct3D 11/12, Vulkan, OpenGL, and OpenGL ES via Vortice.Vulkan and native D3D wrappers, with shaders authored in SDSL (Stride Shading Language), a composition-based superset of HLSL that compiles to DXBC, SPIR-V, and GLSL. Physics is handled by Bepu Physics 2.5 (C# managed) for the primary backend and Bullet Physics (C++ native) for the legacy path. VR support is provided through native OpenXR, OpenVR, and Oculus OVR bindings. The project system is MSBuild/NuGet based with .NET SDK-style projects and uses xUnit for its extensive test suite across 47 GitHub Actions CI workflows covering Windows, Linux, iOS, Android, and GPU test runs.

Code Quality Stride demonstrates strong code quality practices relative to its scale and open-source nature. Unit testing is comprehensive across core modules — the mathematics library has dedicated tests for every primitive type (Vector2-4, Matrix, Quaternion, BoundingBox, etc.), serialization and core infrastructure have xUnit test projects, and the engine ships with graphics regression tests and editor screenshot test suites. XML documentation coverage is extensive across public APIs, enforced through StyleCop configuration. CI is thorough with platform-specific build workflows, test workflows with WARP software rendering for GPU tests, and separate iOS/Android build pipelines. Error handling is explicit with typed exceptions and null-checked parameters. Some inconsistency remains between older Xenko-era code and newer contributions, but modernization refactors (nullable reference types, modern C# idioms) are ongoing.

What Makes It Unique Stride’s most distinctive technical feature is SDSL (Stride Shading Language), a composition-based shader language where shaders inherit from and mixin other shaders rather than being monolithic files — enabling a GPU programming model that mirrors object-oriented design and allows the render pipeline to be extended through composition rather than forking. The voxel cone tracing global illumination module provides real-time indirect lighting without ray tracing hardware, implemented as a first-class optional rendering compositor. The dual physics backend approach (Bepu for new projects, Bullet for legacy) is uncommon among open-source engines and preserves backward compatibility while enabling migration to the more capable managed physics system. Finally, Stride is one of the few C#-native game engines with full .NET Foundation backing, meaning it follows .NET SDK tooling conventions and can bootstrap new game projects via standard dotnet new templates without requiring the visual editor.

Self-Hosting

Stride is released under the MIT License, one of the most permissive open-source licenses available. You can use Stride commercially, modify the source code, distribute it, and sublicense it without any copyleft obligations — meaning your game or application code does not need to be open-sourced. The only requirement is preserving the MIT copyright notice when distributing the engine itself. Third-party components bundled with Stride have their own licenses (documented in THIRD PARTY.md), but the core engine is MIT throughout. The project is overseen by the .NET Foundation, which provides governance and contributor agreements for long-term stewardship.

Running Stride yourself means owning the entire toolchain: the build environment requires Visual Studio 2026 with the .NET desktop development and C++ desktop workloads installed, Git with LFS, and for mobile targets, platform-specific SDKs for iOS (macOS + Xcode) and Android. The engine has no hosted build service — CI is provided via GitHub Actions, and you are responsible for maintaining your own build infrastructure, updating dependencies, and integrating platform SDK updates. The asset pipeline runs as part of Game Studio and the build process; there is no separate asset server or CDN. For large teams, this means coordinating shared asset caches and build configurations manually.

There is no paid cloud tier, managed hosting, or enterprise support contract for Stride — it is entirely community-supported. Bug bounties funded through Open Collective incentivize contributions, and the Discord community provides informal support. What you give up compared to Unity or Unreal is primarily tooling maturity and commercial support: no certified LTS releases, no dedicated support SLAs, no built-in crash reporting service, and no official asset marketplace. Teams with significant C# expertise and the capacity to contribute upstream fixes will find Stride a capable and cost-free alternative; teams needing guaranteed support and faster-moving integrations with platform SDKs may find the community-only model a limiting factor.