Irrlicht Engine: The Open-Source C++ 3D Engine, Its Forks, and Its Status in 2026

Irrlicht is a free, open-source 3D engine written in C++. Started by Nikolaus Gebhardt in 2003, it became a common choice for hobbyist and indie 3D projects in the 2000s, because it was small, fast and easy to learn. Its name is German for “will-o’-the-wisp”. Irrlicht’s code still runs inside two well-known open-source games in 2026: Luanti (formerly Minetest) and SuperTuxKart. Both maintain their own heavily modified copies.

This profile covers what Irrlicht is, what it includes, a minimal working example, the games built on it, whether it’s still maintained, and which engines to consider instead. Versions and dates were checked against the project’s site and the forks’ repositories in October 2026, and the code example was compiled and run against Irrlicht 1.8.5.

What Is the Irrlicht Engine?

Irrlicht is an open-source, cross-platform 3D rendering engine written in C++ and released under the zlib/libpng licence. It supports Direct3D 9, OpenGL and built-in software renderers on Windows, Linux and macOS. The latest stable release is 1.8.5 (November 2021); version 1.9 remains unreleased in development, and its best-known forks power Luanti and SuperTuxKart.

A Short History of Irrlicht

Nikolaus Gebhardt began Irrlicht as a one-person project in 2003, and version 1.0 arrived in 2006. The engine gathered a team of about ten developers and a large forum community, and it went through regular releases up to the 1.8 series in November 2012. Since then the project has issued bug-fix releases only: 1.8.1 to 1.8.4 between 2013 and 2016, and 1.8.5 on November 1, 2021, which mainly fixed compile errors on newer Linux systems (Irrlicht 1.8.5 release notes).

Maintainer Michael Zeilfelder, known on the forums as CuteAlien, has kept working on the next version, 1.9, in the project’s Subversion trunk for years, but it hasn’t had an official release. The project’s official website and forum are still online, and the forum was still answering questions in 2026.

What’s in the Irrlicht Engine

Irrlicht is best understood as a 3D rendering and scene engine, not a complete game engine. It gives you the graphics, scene and input layers, and leaves gameplay, physics and sound to other libraries:

• Several renderers behind one API. Direct3D 9 and OpenGL drivers, plus two software renderers (including “Burning’s Video”) that run without a graphics card. Switching renderers means changing one parameter.
• A scene graph with cameras, lights, meshes, billboards, particle systems, terrain, skyboxes and water surfaces, plus indoor rendering for Quake 3-style BSP maps.
• Many built-in file loaders, including 3DS, OBJ, B3D, X, MD2, MD3 and Collada models, and common image formats.
• Skeletal and morph-target animation, stencil shadows and per-pixel effects such as normal and parallax mapping, with HLSL and GLSL shaders.
• A skinnable 2D GUI, simple collision detection, and input handling for keyboard, mouse and joysticks.

What it doesn’t include: physics, sound, networking or an editor. Projects typically add a physics library such as Bullet, and for sound, Gebhardt’s company Ambiera offered a separate proprietary library, irrKlang. Community bindings exist for Java, .NET, Python, Lua and others, but most haven’t been maintained for years (Wikipedia’s Irrlicht article lists them).

Hello, Irrlicht: A Minimal Example

The program below opens a window, adds a lit, spinning cube, a camera and a text label, and renders until the window closes. It uses Burning’s Video, Irrlicht’s software renderer, so it runs even without GPU drivers. Change video::EDT_BURNINGSVIDEO to video::EDT_OPENGL to use the graphics card.

// hello_irrlicht.cpp - a spinning cube with Irrlicht 1.8
#include <irrlicht.h>
using namespace irr;

int main()
{
    // Burning's Video is Irrlicht's built-in software renderer, so this
    // runs anywhere; switch to video::EDT_OPENGL for hardware rendering.
    IrrlichtDevice* device = createDevice(video::EDT_BURNINGSVIDEO,
        core::dimension2d<u32>(640, 480));
    if (!device)
        return 1;

    device->setWindowCaption(L"Hello, Irrlicht");
    video::IVideoDriver* driver = device->getVideoDriver();
    scene::ISceneManager* smgr = device->getSceneManager();

    // A cube that spins on its own thanks to a rotation animator
    scene::ISceneNode* cube = smgr->addCubeSceneNode(10.0f);
    scene::ISceneNodeAnimator* spin =
        smgr->createRotationAnimator(core::vector3df(0.3f, 0.5f, 0.0f));
    cube->addAnimator(spin);
    spin->drop();

    // One point light plus a little ambient light, so the faces shade
    smgr->addLightSceneNode(0, core::vector3df(-20, 30, -30),
                            video::SColorf(1.0f, 1.0f, 1.0f), 100.0f);
    smgr->setAmbientLight(video::SColorf(0.25f, 0.25f, 0.25f));

    smgr->addCameraSceneNode(0, core::vector3df(0, 10, -25),
                             core::vector3df(0, 0, 0));
    gui::IGUIStaticText* label = device->getGUIEnvironment()->addStaticText(
        L"Hello, Irrlicht!", core::rect<s32>(10, 10, 200, 30));
    label->setOverrideColor(video::SColor(255, 255, 255, 255));

    while (device->run())
    {
        driver->beginScene(true, true, video::SColor(255, 26, 111, 212));
        smgr->drawAll();
        device->getGUIEnvironment()->drawAll();
        driver->endScene();
    }

    device->drop();
    return 0;
}

On Ubuntu or Debian, install the library and compile:

sudo apt install libirrlicht-dev
g++ -std=c++11 -Wall hello_irrlicht.cpp -o hello_irrlicht -I/usr/include/irrlicht -lIrrlicht
./hello_irrlicht

We compiled and ran this example with Irrlicht 1.8.5 and GCC 13 on Ubuntu 24.04. It built without warnings from the example code, and rendered the window shown below.

Games and Projects Built with Irrlicht

Luanti’s fork is the clearest example of where Irrlicht stands today: the IrrlichtMt README says it’s “based on the Irrlicht Engine but is now developed independently”, is intentionally incompatible with upstream, and can’t be built separately from Luanti (IrrlichtMt in the Luanti repository).

Is Irrlicht Still Maintained in 2026?

Partly. The upstream project is alive but slow:

• No new stable release since 1.8.5 in November 2021, and the last feature release, 1.8, dates from 2012.
• Version 1.9 is still in development in the Subversion trunk, with no announced release date. If you want the newest fixes, you build from trunk yourself.
• The maintainer is still active. CuteAlien continued to answer questions on the official forum through 2026.

Meanwhile, the most active Irrlicht code is in the forks. Luanti and SuperTuxKart both ship regular releases on their modified copies, but those forks are tailored to their games, not packaged as general-purpose engines.

Should you start a new project on Irrlicht? For learning how a classic scene-graph engine works, or for a small Windows/Linux tool or visualisation, it’s still a reasonable, lightweight choice, and the zlib licence lets you do almost anything with it. For a commercial game that needs modern graphics APIs, mobile or console support, or an editor, choose an actively developed engine.

Irrlicht Alternatives

If you like Irrlicht’s small, code-first approach, these are actively maintained options:

• raylib: a simple C library for games and graphics, zlib-licensed like Irrlicht, with bindings for dozens of languages and builds for desktop, web and mobile (raylib’s website).
• Ogre: an open-source C++ 3D rendering engine with a scene graph, the closest match to Irrlicht’s design, but with modern renderers (Ogre’s website).
• Panda3D: an open-source C++ engine driven from Python, with physics, audio and deployment tools included. See our Panda3D profile.
• Godot: a full open-source engine with an editor, if you want everything Irrlicht leaves out. See our Godot engine profile.

For more open-source engines, see our directory of open-source C++ game engines.

Key Takeaways

• Irrlicht is an open-source C++ 3D engine under the zlib/libpng licence, started by Nikolaus Gebhardt in 2003.
• It’s a rendering and scene engine, with Direct3D 9, OpenGL and software renderers, but no built-in physics, sound or editor.
• The latest stable release is 1.8.5 (November 2021). Version 1.9 is still unreleased in the development trunk.
• Its biggest users run their own forks: IrrlichtMt in Luanti and a modified Irrlicht 1.8 in SuperTuxKart. Octodad: Dadliest Catch was also built on it.
• It’s still easy to try: a lit, spinning cube takes under 50 lines of C++ and builds with one command on Linux.
• For a new project, consider raylib, Ogre, Panda3D or Godot.

Conclusion

Irrlicht helped many hobbyists learn how a 3D engine fits together, and its code outlived its own release schedule. Upstream development has slowed to bug fixes and a long-awaited 1.9, but Luanti and SuperTuxKart carry modified versions of it into 2026, which makes Irrlicht which keeps its code running in active games more than 20 years after it began.

For more engines across every genre, browse our game development hub.