the thin c++ game engine
Switch branches/tags
Nothing to show
Clone or download
Latest commit ca46b3e Nov 15, 2018
Failed to load latest commit information.
3rdparty ECS + boid example Sep 30, 2018
bin Update GENie binaries Oct 1, 2018
data Fix model Nov 14, 2018
editor Initial commit Aug 1, 2018
example Cleanup Sep 23, 2018
jams Fix Nov 15, 2018
media Initial commit Aug 1, 2018
mud @ 2019254 Update mud Nov 16, 2018
scripts Fixes Nov 8, 2018
src Fixes Nov 15, 2018
.appveyor.yml Fix Appveyor Nov 15, 2018
.gitattributes Initial commit Aug 1, 2018
.gitignore Initial commit Aug 1, 2018
.gitmodules ECS + boid example Sep 30, 2018
.travis.yml Revert last Oct 3, 2018
3rdparty.txt Initial commit Aug 1, 2018
LICENSE.txt Initial commit Aug 1, 2018 Refactor + Fix x64 warnings Sep 30, 2018 Update Aug 24, 2018 Initial commit Aug 1, 2018

CI Community Support
Build Status Build status Community Gitter Patreon

toy is a thin and modular c++ game engine. it aims to provide the thinnest and simplest stack of technology for making games directly from c++. toy offers simple expressive c++ idioms for user interface, rendering, audio, and the seamless extension of your game code with zero-cost tools, editors and scripting, to design full featured 2d or 3d games in fast iterations. toy is built on top of the underlying mud library, which provides most functionality.

toy is under heavy development, not yet stable, fully documented or production ready. this mean we can't guarantee any kind of stability yet (including the git history too)

toy simplicity and modularity makes it deeply hackable, extensible and versatile. toy is perfect to build games with atypical constraint: complex user interface and rendering schemes, procedural generation, etc. it provides a fully programmable 3d renderer, with full control over shaders, materials and render paths, as well as higher level primitives and systems such as entities, physics, navmesh generation and navigation, and procedural generation helpers.

As a collection of game programming building blocks, toy aims to foster an ecosystem of simple minimal reusable components suited for building your own game technology.

Note: I've released toy, for the time being, under the GPL v3.0 license, hoping for it to evolve into a truly free and open-source technology, by releasing under a more permissive license: however this can only happen if it secures a regular financial support, to ensure it's funded as an open-source project: this is where your help comes into play :)


  • simple and lightweight, simplicity is the core aim and philosophy behind toy. the codebase is about one-tenth the size of competing engines, and toy is so light, the whole editor runs in your browser !
  • modular, each functionality is enclosed in a small, simple, easy to understand code building block. most of these blocks lie in the underlying mud library.
  • extensible, as a collection of modules, toy is a perfect fit to build your own game technology, keeping full control over the components you use, the application design and the control flow.
  • game code first, toy is first and foremost meant to build games in native c++ code, in direct contact with the core systems. this allows for much greater control than typical scripting in-engine.
  • versatile, toy is designed from the start with complex games in mind, such as strategy or role playing games, by giving full control over its powerful user interface and rendering systems.
  • zero-cost tools, reflection automatically extends your game core code for seamless scripting, editing, inspection of your game objects, types and procedures in the built-in tools/editor.
  • educative, toy aims to provide simplest technical solutions to typical game programming problems, easily studied and understood, hoping to be a driver of education on game development topics.
  • fast iteration, coupling seamless bindings of both built-in systems and game code to various scripting languages, hot-reload of native code, and immediate UI and rendering, toy provides fast iteration speeds.


  • mud is the low-level library providing most of the base features behind toy, in separate modules
    • reflection
    • scripting: Reflection automatically extends your game core code for seamless scripting via text-based languages (lua, Wren), and a node visual-scripting language, including interfaces for editing these. toy scripting component is so lean, it can be added to the game itself, for live scripting or for an in-game console.
    • rendering
    • user interface: A simple expressive user interface API is the fundamental block for writing any robust game or application. toy offers the best-in-class : immediate-mode widget declarations, fully automatic layout, css-like skinning, image-based skinning, style sheets, various input widgets, docking windows and tabs.
  • entity
  • physics
  • navigation


toy is mostly feature complete in terms of the basic features we wanted for a minimal viable engine. this mean it could finally be open-sourced. but toy is still a bit unstable and undocumented: that means it is in a transitory phase, where the pace can settle down for a while, allowing to:

  • iron out all the bugs, crashes, instabilities
  • thoroughly document all the classes and functionalities which will remain stable

this is the step that toy will be during the next month or so.

after that, when toy is a robust, stable and fully documented game engine foundation, there are many features which will bring toy in a more cutting-edge category: this is what I will be working on next, and by supporting mud you will help us implement the following features:

  • tool applications: implement minimal tooling apps, including: a model painter, an animation editor, a particle editor, a prefab/scene editor. most of these features are partly implemented, but a set of standalone apps would be a great addition.
  • scripting languages: implement support for Wren, Javascript, and C# scripting.
  • clustered rendering: implement state-of-the-art clustered rendering techniques, along with a deferred rendering pipeline.
  • real-time global illumnation: investigate state-of-the-art global illumination techniques and implement the best real-time compromise currently feasible.
  • node-based shader language: the mud node editor is a perfect tool to start playing with node-based shader and render pipeline definitions.
  • multi-threading: implement efficient job/fibers system and parallelize everything that can be.
  • performance-focused ECS: implement an ECS skeleton focused towards heavily parallelized performance, to implement typical scenarios such as the boid example.
  • networking: investigate how a networking solution can be integrated with reflection, how to automatically expose objects procedures and fields through a networking API, to provide seamless basic multiplayer support, then implement it.

get started


Platform Example RTS Example
Editor Example Space Example

how to build

  • git clone --recursive
  • cd toy
  • generate the project files for your target
    • bin/linux/genie --gcc=linux-gcc gmake for gmake/linux
    • bin/windows/genie vs2015 for Visual Studio 2015
    • bin/windows/genie vs2017 for Visual Studio 2017
  • go to the generated folder
    • cd build/projects/gmake-linux for gmake/linux
    • cd build/projects/vs2015 for Visual Studio 2015
    • cd build/projects/vs2017 for Visual Studio 2017
  • build
    • make config=debug64 -j8 for gmake/linux 64bit
    • open toy.sln and build for Visual Studio
  • run the examples: ex_platform, ex_space, ex_blocks


toy couldn't exist without:


Creating toy has been a huge time investment over the course of a few years: the only way I can pursue that effort and make it thrive into the game programming ecosystem of our dreams, is through funding and sponsorship: you are welcome to have a look at our patreon.

Iron supports:

  • Mike King

Stone supports:

  • Etienne Balit, Le Bach, Manos Agelidis, Nebo Milic, Omar Cornut, Stefan Hagen, Sunder Iyer


mud is licensed under the GPLv3 license