# Magnum: a C++ graphics engine that keeps its promises small

> A lightweight, modular C++11 wrapper over OpenGL, OpenGL ES and WebGL with a hard rule that dependencies stay optional. Good for engines and tools, heavier than you need for a single triangle.

**mosra/magnum** — Lightweight and modular C++11 graphics middleware for games and data visualization

- Repository: https://github.com/mosra/magnum
- Website: https://magnum.graphics/
- Stars: 5,218 · Forks: 467
- Language: C++
- License: NOASSERTION
- Published: 2026-10-07 · Updated: 2026-10-07 · Language: en
- Canonical page: https://hysenlabs.com/projects/mosra-magnum

## The three promises the README makes about size

The repository description calls Magnum a lightweight and modular C++11 graphics middleware for games and data visualization. The README makes three separate claims and they are worth separating, because they pull in different directions.

The first is simplicity. Among the essentials the README lists a UTF-8-aware operating system, filesystem and console abstraction, a feature-packed vector math library, and a slim C++11 wrapper of the OpenGL and WebGL family of APIs. Build on top of that or opt in for more.

The second is completeness around the edges: shaders and primitives for prototyping and debugging, algorithms, asset management, integration with popular windowing toolkits, and a UI library. The README calls this batteries included.

The third is the one that actually differentiates it from a typical engine: screws are not glued in. The README says there is always more than one way to do things, and invites you to integrate your own asset loader, texture compressor, font format or math library, or use its plugins.

Those three are in mild tension, and the resolution is the module layout at the top of the tree:

```text
CMakeLists.txt
src/
modules/
package/
toolchains/
doc/
```

Whatever you need from the extras list lives outside the core repository.

## Platform coverage stated as API versions, not marketing

The README lists supported platforms as Linux and embedded Linux, Windows with MSVC, clang-cl and MinGW, Windows RT, macOS, iOS, Android, and the web through Emscripten using either asm.js or WebAssembly. Graphics API coverage is given as OpenGL 2.1 through 4.6 including core profile functionality and modern extensions, OpenGL ES 2.0 and 3.0 through 3.2 plus extensions to match desktop functionality, and WebGL 1.0 and 2.0 with matching extensions.

That phrasing, API versions rather than device lists, is the sort of precision that makes a library README usable. It also tells you what is not here: no Vulkan target appears in the supported list, even though vulkan is among the repository topics. Topics are user-applied tags and are looser evidence than the README, so if Vulkan support is what you are shopping for, the README is the place to look and it does not make that claim.

Per-platform build status is delegated to a separate page on the project site, which is the right call for a library with this many toolchain combinations and also means the README alone cannot tell you whether your exact configuration is green.

## Calendar version tags and a six-year gap in releases

The releases are named by year and month: v2020.06, v2019.10, v2019.01, with the newest published on 2020-07-02. Each release body is three lines long and points at an announcement post on blog.magnum.graphics and a detailed changelog page in the documentation.

That is a versioning scheme and not a maintenance signal, which is the single most important thing to understand here. GitHub reports the last push on 2026-08-23, so work continues years after the newest tag. Calendar versioning has an obvious reason: a library that supports many platforms and extension combinations wants to say which combination it was tested against, and a date encodes that better than a sequence number.

The practical consequence for anyone tracking the project is that the GitHub releases list is not a useful changelog. The README says as much, pointing at the changelog page for what was added or improved recently. If you are pinning a version, pin by whatever the documentation calls current, and read the changelog rather than inferring currency from the tag list.

## The dependency split, and where the rest of Magnum lives

The README states the design rule outright: the engine itself is kept as small as possible with only a few dependencies, and additional functionality that depends on external libraries is provided in separate repositories. Then it lists them.

Corrade is the main Magnum dependency, a multiplatform utility library. Magnum Bootstrap provides ready made project skeletons. Magnum Plugins holds importer plugins for image, font, audio and 3D model formats. Magnum Integration covers external math and physics libraries. Magnum Examples ranges from hello world to a viewer for complex 3D models. Magnum Extras is described as a playground for testing new APIs and mutually exclusive functionality. Magnum Bindings exposes the API to other languages such as Python. Magnum Singles republishes functionality as single-header libraries.

Seven sibling repositories is a real operational fact. It also means the phrase lightweight is doing more work than it appears to: you can start with a very small core, and then spend your afternoon deciding which of seven trees you need. Cmake is the build system, with a `CMakeLists.txt` at the root and per-platform toolchain directories, and the README notes the project also ships packaged builds for Windows, Linux and macOS.

The single-header path is the fastest way to evaluate it. The README describes downloading a file, including it in your project, and being ready to go, with no buildsystem wrangling needed.

## Case studies and an MIT badge with no license field

The README links a set of case studies with the framing question written into the link text: wondering if Magnum is a good fit for your project. For a library that asks you to assemble your own pipeline, a page that walks through real projects is more informative than another feature list, and the project has clearly decided that is where the persuasion belongs.

On licensing there is a small gap worth naming. The README carries a badge reading MIT License and links to the OSI page for it, and a `COPYING` file is present at the root of the tree. GitHub, however, shows no license value for the repository. Both statements are true at once: the project asserts MIT in its own documentation, and the metadata field is empty. A `CONTRIBUTING.md` and a `CREDITS.md` also sit at the root, along with an `.editorconfig` and CI configuration under `.circleci/`.

The absence of a license field is not usually a sign of a problem, but if you are integrating Magnum into a product, read `COPYING` rather than relying on a badge. Nobody needs a lawyer to check that a text file says what you need it to say.

## When Magnum is the wrong choice

Two situations stand out. The first is a small internal tool that needs to show a chart or a model once. Wiring up a graphics backend, a windowing toolkit and an asset pipeline for that is a lot of assembly for a job that a higher-level library does in a day. The README itself acknowledges this gap: it lists a UI library among the extras and offers case studies for readers deciding, which is a polite way of saying the engine does not make those choices for you.

The second is a team that wants one vendor to be responsible for the whole stack. Magnum's dependency philosophy is excellent for a developer who wants control and actively unhelpful for a team that wants a support contract covering windowing, input, physics, assets and UI.

There is a third, smaller consideration. Magnum targets C++11 and describes itself as slim. If your project is already built around a much newer standard, the value of a small, stable API surface is lower than it would be for an older codebase, and the Corrade dependency is one more library to keep in step with your own build.

If you want the same abstraction with less assembly, a full engine gives you the missing pieces at the cost of the freedom the README spends three sections selling.

## Conclusion

Magnum is a good fit when you are writing the rendering layer yourself and want an API you can read in an afternoon, with the platform, math and asset pieces separated instead of bundled. It is a poor fit for a small tool or a team that wants batteries included without wiring, because the plugins, asset pipelines and UI are separate repositories. Start with the single-header distribution to feel the API without setting up a build, then read the building guide before committing, and treat the 2020.06 tag as a version scheme rather than as evidence of a six-year-old codebase.

## FAQ

### Is Magnum still maintained?

GitHub reports the last push on 2026-08-23, while the newest published tag is v2020.06 from 2020-07-02. Magnum versions by year and month rather than by sequence, and the README directs readers to the changelog page in the documentation for what changed recently.

### What license is Magnum released under?

The README carries an MIT License badge and links to the OSI text, and a COPYING file is present in the repository root. GitHub shows no value in the repository license field, so the COPYING file is the authoritative source.

### Does Magnum support Vulkan?

The README lists graphics API coverage as OpenGL 2.1 through 4.6, OpenGL ES 2.0 and 3.0 through 3.2, and WebGL 1.0 and 2.0. Vulkan appears among the repository topics, which are user-applied tags rather than a support statement.

### What is Corrade and why does Magnum need it?

Corrade is described in the README as the main Magnum dependency, a multiplatform utility library. It is a separate project by the same author, hosted at its own repository.

## Sources

- [Issues](https://github.com/mosra/magnum/issues)
- [mosra/magnum on GitHub](https://github.com/mosra/magnum)
- [Project website](https://magnum.graphics/)
- [README](https://github.com/mosra/magnum/blob/master/README.md)
- [Releases](https://github.com/mosra/magnum/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/mosra-magnum