s&box: A Game Engine on Source 2 and .NET Open to Community Contribution

What s&box Is and Who This Repository Is For

s&box is a modern game engine built by Facepunch on Valve's Source 2 and .NET technology. The engine is available on Steam at https://store.steampowered.com/app/590830/sbox/ and provides a game editor for creating and publishing games.

This repository is specifically for contributors to the engine itself. The README states this directly: if the goal is to create games using s&box, start with the getting-started guide at sbox.game/learn/getting-started. The repository contains the C# engine, editor, tooling, and game content. Developers building games on s&box do not need to compile from source; they install the engine from Steam.

For contributors, the repository gives access to the C# layer: the engine runtime, the editor, and the tooling. The native Source 2 core, which is written in C++, is distributed as prebuilt binaries that the setup scripts download automatically. No C++ toolchain is required to build from source, which reduces the contribution barrier to writing and building C# code.

Full documentation, tutorials, and API references are available at sbox.game/dev/, separate from this repository.

Platform Support and the Native Binary Split

The README lists three supported platforms for building from source: Windows 10 or 11 (x64), Linux (x64), and macOS with Apple Silicon. Intel Macs are explicitly not supported. The Linux binaries target the Steam Linux Runtime, and the README notes that most distributions should work with that target.

The architecture reflects a deliberate split. The C# engine, editor, tooling, and game content live in this repository under the MIT license. The native Source 2 core, which provides the rendering, physics, and low-level platform services, is distributed as prebuilt binaries. Those binaries are not covered by the MIT license; they are under the s&box EULA, which applies to anyone who uses them.

The third-party components bundled in `game/thirdpartylegalnotices` carry their own original licenses, also not covered by the MIT license in the README.

This means the repository is effectively a hybrid: the C# code is fully open and modifiable, but the capabilities it can access at runtime are bounded by what the prebuilt native binaries expose. A contributor modifying the rendering pipeline, for example, works within the API surface that the native Source 2 binaries provide.

Building s&box from Source

The setup process uses a platform-specific script that clones the repository, then downloads the required native binaries and generates interop bindings:

git clone https://github.com/Facepunch/sbox-public.git
cd sbox-public

On Windows:

Setup.bat

On Linux and macOS:

./Setup.sh

After setup completes, the game executable (`sbox`) and the editor (`sbox-dev.exe`) run from the `game` folder. Building the C# code itself is done from an IDE: Visual Studio 2026 or Rider on Windows, and Rider or VS Code on Linux and macOS. The required tooling is .NET 10 SDK and Git.

The README describes how to stay current: pulling on Git triggers a hook that fetches new native binaries or content that changed, and regenerates the interop bindings. Rerunning `Setup.bat` or `Setup.sh` performs a full incremental rebuild including shaders and content. This means updates involve both a Git pull for the C# code and a hook-driven download for any changed native components.

The .NET Layer and What Contributors Can Modify

The C# layer is where contributors to s&box do their work. The engine runtime, the editor UI, and the tooling are all C# code in this repository. The README points to the contributing guide at CONTRIBUTING.md for the specifics of how to submit changes.

The .NET 10 requirement is notable: .NET 10 is a long-term support release at the time the README was written, and the engine's scripting model for game developers also runs on .NET. This gives contributors a consistent development environment across both engine development and game scripting.

The editor (`sbox-dev.exe`) runs from the `game` folder after setup. Contributors working on editor features or tooling can iterate there directly. Changes to the C# code are built from the IDE as usual, and rerunning the setup script handles shader compilation and content regeneration for deeper changes.

Bug reports and feature requests go to the `sbox-issues` repository on GitHub, separate from this source repository. The contributing guide at CONTRIBUTING.md is the starting point for understanding which changes are welcome and the expected process for submitting a pull request.

s&box Compared to Unity and Other Game Engines

Unity is the most common point of comparison for a .NET-based game engine with an integrated editor. The practical difference is the underlying renderer and physics layer. s&box uses Source 2, which is the engine behind Valve's own games, as its native core. Unity uses its own proprietary renderer. A developer choosing between them is choosing between Source 2's specific rendering capabilities and Valve's tooling ecosystem on one side, and Unity's broader third-party asset and plugin ecosystem on the other.

Another relevant comparison is Unreal Engine, which uses C++ as its primary scripting language rather than C#. s&box's .NET 10 foundation means game code is written in C#, which has a different performance and tooling profile from C++. The README makes no claims about performance relative to other engines.

For developers already familiar with Source 2 from Valve's games or with Garry's Mod, which was also built by Facepunch, s&box will have familiar tooling patterns. The README does not describe the relationship between s&box and Garry's Mod.

License, EULA Boundary, and Maintenance

The C# source code in this repository is MIT-licensed. The MIT license permits unrestricted use, modification, and redistribution of that code. However, the native Source 2 binaries in `game/bin` are distributed under the s&box EULA, not the MIT license, and the third-party legal notices in `game/thirdpartylegalnotices` cover additional components with their own terms.

For a developer building from source, this means the act of running the engine involves accepting the s&box EULA for the native components, even though the C# code they are modifying is MIT-licensed. Anyone evaluating the repository for use in a downstream project should read both the MIT license and the s&box EULA before distributing any build.

The last push to the repository was on 2026-09-27. The repository is not archived. Full documentation and API references are maintained at sbox.game/dev/. Security issues have a designated reporting channel described in SECURITY.md in the repository root.

Editorial conclusion

Developers who want to create games with s&box should start with the getting-started guide at sbox.game rather than this repository, which exists for contributors to the engine itself. Developers who want to contribute to the engine's C# layer can compile from source on Windows, Linux, or Apple Silicon using the provided setup scripts. Be aware that the native Source 2 binaries in game/bin are not covered by the MIT license and are distributed under the s&box EULA; verify that the EULA terms are acceptable before building from source.

Frequently asked questions

Official sources

1. Facepunch/sbox-public on GitHub
2. Issues
3. Project website
4. README