The Cube engine is small, free and built on an unusual idea. Instead of compiling maps the way Quake-era engines did, it lets players reshape the level while they’re standing in it, even mid-match with other people. That one design choice produced a whole family: the original Cube, its far more capable successor Cube 2: Sauerbraten, and Tesseract, a modern fork with dynamic lighting. Games such as AssaultCube and Red Eclipse came out of it.
This page sorts out which engine is which, what each one does differently, which games run on them, and how active the family still is in 2026. Several unrelated projects also use the name “Cube”, so it also covers what this engine is not.
What Is the Cube Engine?
The Cube engine is an open-source C++ first-person shooter engine written by Wouter van Oortmerssen and first released in 2001 with the game Cube. It is known for real-time, in-game map editing without a compile step. Its successor, Cube 2: Sauerbraten (2004), moved to true 3D geometry, and Tesseract (2014) forked Cube 2 to add modern dynamic lighting.
| Cube | Cube 2: Sauerbraten | Tesseract | |
|---|---|---|---|
| Created by | Wouter van Oortmerssen | Wouter van Oortmerssen, Lee Salzman, Mike Dysart | Lee Salzman |
| First release | 2001 | May 6, 2004 | May 12, 2014 (announced April 2012) |
| Latest release | August 29, 2005 | 2020 Edition (late 2020) | 2014 initial release; no numbered release since |
| World geometry | 2.5D heightmap (no rooms above rooms) | True 3D octree (“6-directional heightfield”) | Cube 2’s octree world |
| Lighting | No precomputed BSP or shadow data | Precomputed lightmaps; optional PVS | Deferred shading, dynamic shadows, real-time GI, HDR |
| Graphics API | OpenGL + SDL | OpenGL + SDL (SDL 2 since 2020) | OpenGL 3.0 core (2.0 legacy path) |
| Engine licence | zlib | zlib (game content under various non-free licences) | zlib |
| Platforms | Windows, Linux, FreeBSD, macOS, plus community ports | Windows, Linux, macOS, BSDs | Desktop; Linux builds on Flathub |
| Best-known game | AssaultCube | Sauerbraten itself; Red Eclipse 1.x | Red Eclipse 2.0 (engine parts) |
Cube (2001): The 2.5D Original
Wouter van Oortmerssen released Cube in 2001, built in C++ on OpenGL and SDL. A version with a single-player mode followed in January 2002, and the last update came on August 29, 2005 (Cube on Wikipedia).
Technically, Cube is a 2.5D engine: the world is a 2D heightmap with height and slope information, much like the approach of the Doom engine. It handles slopes and 3D props well, and it was designed with outdoor maps in mind, but it can’t stack one room above another.
What made Cube stand out was what it left out. It precomputes nothing: no BSP tree, no baked shadow data. Quake-derived engines such as GoldSrc need a separate map-compile step before a level can be played. Cube’s maps are live, so several players can fly around and edit the same map together in real time. Van Oortmerssen described the design as favouring simplicity and brute force over clever complexity.
The engine is open source under the permissive zlib licence. That freedom, plus a code base small enough to read, led to ports well beyond the desktop, including an OpenGL ES demonstration at GDC 2005 and an iPhone technology demo in 2008.
Cube 2: Sauerbraten (2004): Full 3D, Same Editing Idea
Cube 2: Sauerbraten, first released on May 6, 2004, is the official successor. Van Oortmerssen, Lee Salzman and Mike Dysart started from the Cube code, but the engine underneath became very different.
The key change is the world model. Sauerbraten stores the level as an octree, which its authors describe as a “6-directional heightfield”. Each cube in the world can be split into eight smaller cubes, so mappers can build genuinely 3D structures (overhangs, multi-storey buildings, tunnels) while keeping Cube’s live, in-game editing. The world structure itself generates the triangle batches the renderer draws, so there’s still no expensive preprocessing step. Lighting, however, is precomputed into lightmaps. Releases from the “CTF Edition” onward also include a precomputed visibility system for graphics cards without hardware occlusion queries.
Sauerbraten’s engine code is zlib-licensed; much of its game content uses other, non-free licences. The most recent release is the 2020 Edition (sauerbraten.org), the first new release since early 2013. It moved the game to SDL 2, fixed years of accumulated bugs, added optional HUD elements and smarter spawning, and shipped nearly 200 new maps (GamingOnLinux covered the release). It runs on Windows, Linux and macOS, with packages for the BSDs.
Tesseract (2014): The Modern Fork
Tesseract is a fork of the Cube 2 engine led by Lee Salzman, one of Sauerbraten’s own developers (tesseract.gg). Announced in April 2012, it made its first public release on May 12, 2014, after two years of work that left it “much more visually advanced” than Sauerbraten (Phoronix reported the release).
Where Sauerbraten bakes its lighting ahead of time, Tesseract renders it dynamically. Its feature list (documented on Libregamewiki) reads like a mid-2010s AAA renderer:
- Deferred shading
- Omnidirectional point lights with cubemap shadow maps, spotlight shadow maps, and cascaded shadow maps for sunlight
- Real-time diffuse global illumination for sunlight
- HDR rendering with tonemapping and bloom, volumetric lighting and transparent shadows
- Screen-space ambient occlusion, reflections and refractions for water and glass
- MSAA, SMAA, FXAA and temporal anti-aliasing
- An OpenGL 3.0 core renderer, with a legacy OpenGL 2.0 path
The trade-off is hardware: Tesseract needs a noticeably stronger GPU than Sauerbraten. Like its parent, the engine code is zlib-licensed. A community project, Tesseract: Sauerbraten, is porting Sauerbraten’s game to the Tesseract engine while staying compatible with existing Sauerbraten servers.
Games Built on the Cube Engines
- AssaultCube (Cube engine; first official release November 2006, Rabid Viper Productions). The most popular game built on the original Cube engine. Version 1.3.0.2 (April 1, 2022) is the latest, on Windows, Linux, macOS, FreeBSD and Android. The engine code is free software, while the game media use a non-commercial Creative Commons licence.
- AssaultCube Reloaded (Cube engine; December 2010). A community fork of AssaultCube.
- Cube 2: Sauerbraten (Cube 2 engine; 2004). Fast deathmatch, capture-the-flag and co-op map editing; the engine’s own flagship game.
- Red Eclipse (Cube 2 engine, then Tesseract). It grew out of Blood Frontier, a Sauerbraten fork begun in 2007, and released version 1.0 on March 15, 2011. Version 2.0, the “Jupiter Edition”, arrived on Steam in December 2019 and replaced the old renderer with parts of the Tesseract engine (Red Eclipse downloads). Its code is zlib-licensed and its content CC BY-SA.
- Platinum Arts Sandbox (Cube 2 engine). A standalone game-creation system built on the Cube 2 engine.
- Tomatenquark (Cube 2 engine). A Sauerbraten fork released on Steam in 2020.
- BananaBread (Cube 2 engine; 2012). Alon Zakai’s browser demo, which compiled the engine to JavaScript and WebGL with Emscripten as an early showcase of games running on the web.
Is the Cube Engine Still Used in 2026?
Yes, by small, dedicated communities rather than studios. The honest picture:
- Sauerbraten’s latest release is the 2020 Edition. There’s been no newer official release, but the game is still packaged for Linux (Flathub) and the BSDs (OpenBSD ports).
- Tesseract hasn’t had a numbered release since 2014, though it’s still packaged (a community Flathub build was updated in 2024) and the Tesseract: Sauerbraten port is in active development.
- AssaultCube’s latest version is 1.3 (2022), after a long gap, including an Android version.
- Red Eclipse 2.0 remains the most polished modern game in the family, free on Steam.
No commercial game ships on these engines today. Their lasting value is as a readable, permissively licensed C++ codebase for learning how a complete multiplayer FPS engine fits together, and as the home of a still-unusual idea: editing the world together, live.
Is the Cube Engine a Minecraft-Style Voxel Engine?
No. The name causes confusion, because many unrelated hobby projects called “Cube” (often JavaScript or browser block-world engines) use Minecraft-style chunks of blocks, Perlin-noise terrain generation and Minecraft texture packs. Descriptions of those projects regularly get mixed into write-ups of this engine.
Van Oortmerssen’s Cube engines work differently. Cube uses a hand-edited 2.5D heightmap, and Sauerbraten and Tesseract use an editable octree of solid geometry. Levels are designed by mappers, not generated from noise, and the engines don’t load Minecraft resources. If a feature list mentions chunk sizes, noise generators or texture packs, it’s describing a different “Cube”.
Key Takeaways
- Cube (2001) is Wouter van Oortmerssen’s 2.5D heightmap FPS engine, built so maps can be edited live, in multiplayer, with no compile step.
- Cube 2: Sauerbraten (2004) keeps that idea but moves to true 3D octree geometry with precomputed lightmaps. Its latest release is the 2020 Edition.
- Tesseract (2014) is Lee Salzman’s Sauerbraten fork with deferred shading, dynamic shadows and real-time global illumination.
- All three are zlib-licensed open source. Game content licences vary.
- The family is still alive in 2026 through Sauerbraten, AssaultCube 1.3, Red Eclipse 2.0 and the Tesseract: Sauerbraten port, but not in commercial games.
- It is not a Minecraft-style voxel engine. Chunks, Perlin noise and texture packs belong to unrelated projects with the same name.
Conclusion
The Cube engines are a reminder that an engine doesn’t need to be large to be influential. A single developer’s idea, live and shared map editing with no compile step, carried through three generations and into games still played today, and Tesseract shows the same octree world can sit under a genuinely modern renderer.
For anyone studying engine programming, the family is one of the most approachable complete FPS codebases available, and its zlib licence lets you take it anywhere. To see where it sits among the alternatives, browse our directory of open-source and C++ game engines.
