Ritchie’s Toolbox (sometimes just “Toolbox”) is an open-source game engine written almost entirely in C#. Its codebase is a fork of and based off of MonoGame. It adds support for SPIR-V shaders, upgrades MonoGame to SDL 3, tries to generally improver the game framework’s API, and adds creature comforts such as a powerful user interface toolkit and a familiar scene system. Toolbox is the game engine that powers Socially Distant.
Why Toolbox instead of other engines?
I’m blind. Writing my own game engine puts me in complete control of its user and developer experience, allowing me to add blind-friendly functionality to it. For example, the in-game screen reader of Socially Distant leverages the text-to-speech API built into the engine, and the engine’s support for accessible descriptions in the UI system.
It may not be the game engine for you, and it definitely won’t run your favourite AAA experiences. Toolbox is built for the way I work.
Why use MonoGame as a base?
I think MonoGame is a (mostly) great abstraction layer over the GPU, your sound card, and your favourite windowing system. While I could spend months writing my own abstraction layer, MonoGame is battle-tested. That being said, it does have its papercuts, and Toolbox mends them.
MonoGame’s papercuts
Note: Toolbox spun off of MonoGame 3.8, these papercuts were true at the time. They may not be now, and that’s great.
Poor shader tooling
While MonoGame has a nice runtime shader API in the form of its Effect system, the compile-time tooling is quite poor. If you use Windows, it’ll be fine. On other platforms, however, due to the use of MojoShader and HLSL effects shaders, MonoGame can not build shaders without the use of Wine.
Toolbox solves this problem by exposing low-level APIs for creating Effect instances at runtime using platform-specific shader code. It also introduces its own shader processor that uses DXC and SPIR-V Cross to process development shaders into their shipped SPIR-V form, and to further emit platform-specific shader code and reflection data. This enables future support for Vulkan, Metal, and DirectX 12, weather-permitting. For now, it remains primarily targeted to OpenGL.
Along with this, support for geometry and tesselation shaders has been added.
SpriteFonts
SpriteFonts are a GPU-efficient way of rendering text on the screen. At compile time, MonoGame will render a range of characters to a texture atlas using FreeType. This atlas, along with character metrics, gets wrapped up into a binary asset that you use as a SpriteFont at runtime. The problem is you must create a SpriteFont for each font weight, variant, or font size. All ranges must be known at compile time as well. This makes support for emoji prohibitively expensive since you physically can’t fit the sheer amount of emoji in a single GPU’s memory at a reasonable size for quality.
Furthermore, dynamically sized/weighted fonts are not feasible. This lead to the creation of projects like FontStashSharp, which do the font rasterization on-the-fly at runtime.
Instead of relying on these third-party libraries, Toolbox renders text directly using FreeType at runtime. It also exposes DPI scaling settings, and important font metrics such as underline offsets. Toolbox also provides a high-level typeface API, allowing for dynamic font weights, font sixes, italics, and even emoji.
Useful, but hidden, APIs
There are lots of parts of MonoGame that would be really nice to use for performance reasons, or to better-integrate with other libraries and tools. For example, one cannot access the clipboard whatsoever. Furthermore, although you can retrieve the native handle of the game window, you can do nothing with it in practice as the low-level SDL bindings are hidden from you.
If Toolbox has a useful API, and there is no genuine reason to hide it from you, it is public.
A user interface system you actually want to use.
MonoGame itself is a low-level framework with some high-level niceities like SpriteBatch, but does not have any advanced systems a mid-to-large-scale game actually needs. You are expected to roll your own, or use a community-maintained library. Rolling your own UI system is not something you want to do, as it is an incredibly complicated and disciplined endeavour, particularly when keeping accessibility in mind. Luckily, there are Ritchies masochistic enough to try.
Toolbox provides an advanced, general-purpose, accessible UI toolkit to build games and applications with. It makes no visual assumptions about your UI or how you choose to render it, unlike most MonoGame-compatible UI toolkits. Rather, it gives you a set of common interface elements such as buttons, inputs and text, a robust layout system, and advanced functionality such as list adapters.
Furthermore, it provides a TextMeshPro-like markup system for rich text, a theme system for consistent styling, support for widget shaders (background blurs!), animations, signals, focus tracking, text-to-speech support, clipboard support, layout scaling, and pretty much everything you would need to write an actual operating system’s desktop shell with.
You can even render Markdown with it.