Browse by type
A modern, high-performance game engine built with Vulkan
Website • Discord • Documentation • Support
Lumina is a modern C++ game engine built from the ground up with Vulkan. It is designed for learning and experimentation with real-world engine architecture, demonstrating professional design patterns including a reflection system, an ECS-based gameplay layer, and modern rendering techniques.
[!NOTE] For more detailed information, go to: https://luminagameengine.com
It is well suited for:
Contributions are recognized in several ways, including Steam keys for popular games and public acknowledgment in the Discord community. Lumina improves through the work of motivated contributors who help push the engine forward.
[!CAUTION] Lumina is an educational project under active development. APIs may change, and some features are experimental. If you encounter build issues, please reach out on Discord for assistance.
[!NOTE]
AI Usage
AI has been used selectively for tasks such as static analysis, research, build tooling, and scripting assistance.
The engine itself has been hand-crafted over the course of three years as a passion project. AI is treated as a tool where it provides value, nothing more, nothing less.
Registry.View queries,
C# entity systems, and component reads and writesWorld facade: Physics, Navigation,
Input, Messages, and GameplayTags
Show more screenshots
<img width="800" alt="Lumina screenshot" src="https://github.com/user-attachments/assets/086a1e5e-4d8d-4c98-be81-bc77287fba39" />
<img width="800" alt="Lumina screenshot" src="https://github.com/user-attachments/assets/66d739ca-f257-4350-b2f0-2e10d66f5591" />
<img width="800" alt="Lumina screenshot" src="https://github.com/user-attachments/assets/68e86207-20f2-4200-8649-257738b2855f" />
<img width="800" alt="Lumina screenshot" src="https://github.com/user-attachments/assets/a4c7c497-d975-47d2-a695-5342e11e8f44" />
<img width="800" alt="Lumina screenshot" src="https://github.com/user-attachments/assets/5343eff8-545a-47ca-a858-b2aa4f1fef71" />
https://github.com/user-attachments/assets/3d797479-fc47-4b8f-baf4-87315709d0c2
Every platform needs a GPU that supports Vulkan mesh shaders
(VK_EXT_mesh_shader): NVIDIA Turing (GTX 16-series / RTX 20-series) or newer,
AMD RDNA2 (RX 6000) or newer, or Intel Arc. The renderer's geometry pipeline is
built on them, so the editor refuses to start on anything older and says so.
That GPU also needs 4 GB of graphics memory, 6 GB or more recommended. The renderer reserves well over a gigabyte before any content loads (render targets, two 4K shadow atlases, and a 1 GB streaming texture pool by default), and a card under the minimum does not degrade gracefully, it renders corrupt frames and eventually loses the device. The check runs at device selection alongside the mesh-shader one and names the shortfall. A few mesh-capable parts land under the line, mostly 2 GB laptop chips such as the GeForce MX550 and MX570.
-ignoreminspec runs anyway, unsupported. -minvram=N sets a different
threshold, which is how to see the rejection dialog on hardware that passes.
[!IMPORTANT] The engine's C# layer (LuminaSharp) targets
net10.0. Only Visual Studio 18.0+ (2026) can build that target, VS 2022 (17.x) fails witherror NETSDK1209even if you install the standalone .NET 10 SDK, because VS uses its own bundled MSBuild.Setup.batvalidates this for you and stops with a clear message if anything is missing.
Memory/Construct.h uses __is_trivially_destructible,
a builtin GCC only grew in 16, so g++-13 and g++-15 reject the tree outright.
Clang is not usable right now whatever its libstdc++: it rejects the
RUNTIME_API NODISCARD attribute order in Memory/Memory.h, PlatformString.h
and MeshData.h, which GCC accepts.dlopen,
so a machine with no driver builds a working editor it cannot launch.On Debian or Ubuntu:
bash
# build
sudo apt-get install -y g++-16 pkg-config libx11-dev libxrandr-dev \
libxinerama-dev libxcursor-dev libxi-dev libxkbcommon-dev
# run
sudo apt-get install -y libvulkan1 mesa-vulkan-drivers vulkan-tools
# .NET 10 SDK: https://dotnet.microsoft.com/download/dotnet/10.0
Setup.sh checks all of this and tells you what is missing, including
whether any installed GPU actually reports VK_EXT_mesh_shader.
[!NOTE] No IDE is required. On Windows, JetBrains Rider and Visual Studio both open the generated solution. On Linux there is no solution: CLion reads the generated
compile_commands.jsonfor C++, and Rider opens the engine's C# projects.
bash
git clone https://github.com/mrdrelliot/luminaengine
cd LuminaEngine
bash
Setup.bat
It downloads one prebuilt dependency bundle
(External-Win64.zip, ~192 MB), verifies it against a SHA-256 hash pinned in this
repo (once the maintainer records it, see
DEPENDENCIES.md), configures git hooks, registers the
.lproject file type, and generates Lumina.slnx.
The bundle contains the .NET 10 runtime (C# scripting), LLVM/Clang 19
(reflection codegen), the Slang shader compiler, RenderDoc, and Tracy. Each
is open source; DEPENDENCIES.md lists every component
with its version, purpose, upstream source, and license, and explains how to
fetch them yourself instead of using the bundle.
To skip the prompt for unattended/CI runs, pass --yes (or set
LUMINA_SETUP_YES=1). If the download fails, manually download
External-Win64.zip,
extract it into the LuminaEngine/ folder, then run
GenerateProjectFiles.bat.
Open Lumina.slnx in Visual Studio.
Build and run
Set Lumina as the startup project.
Development Editor (default), Debug Editor for
full debugger functionality at the cost of speed, or Development Game for
the runtime without the editor.Press F5, or use Build -> Run.
Start developing
Copy Templates/Blank/ to create a new project, then run its
GenerateProject.bat to produce a solution.
Every script below has a .bat counterpart of the same name on Windows, and
takes the same arguments.
bash
git clone https://github.com/mrdrelliot/luminaengine
cd LuminaEngine
bash
./Setup.sh
It checks the prerequisites above, downloads one prebuilt dependency bundle
(External-Linux64.tar.gz, ~186 MB), verifies it against a SHA-256 hash
pinned in this repo, and configures git hooks.
The bundle contains the .NET 10 runtime (C# scripting), LLVM/Clang 19
(reflection codegen), the Slang shader compiler, RenderDoc, and Tracy. Each
is open source; DEPENDENCIES.md lists every component
with its version, purpose, upstream source, and license, and explains how to
fetch them yourself instead of using the bundle.
To skip the prompts for unattended/CI runs, pass -Yes (or set
LUMINA_SETUP_YES=1); an unattended run never edits your shell profile. If
the download fails, fetch
External-Linux64.tar.gz
by hand and extract it into the LuminaEngine/ folder.
bash
./LuminaBuild.sh Build Lumina -TargetType=Editor
The Reflector is a prerequisite of that target and builds itself first, so
this is the only command you need. Add -Configuration=Debug for full
debugger fidelity at the cost of speed, or -TargetType=Game for the runtime
without the editor.
bash
./LuminaBuild.sh Run Lumina -TargetType=Editor
Run locates the binary through the same rules the build used, so it always
launches the configuration you name rather than whatever was built last. It
takes the same -TargetType and -Configuration flags as Build, and
anything after a bare -- is forwarded to the editor untouched. The
executable itself is at Binaries/Linux64/Lumina-Editor-Development if you would
rather launch it directly; it finds the engine relative to itself, so it does
not care what directory you run it from.
bash
./GenerateProjectFiles.sh
This writes compile_commands.json at the repository root. No solution is
generated on Linux, because nothing here can open one. Point your editor at
the repository root and it will pick the database up:
Rider is the tool for the engine's C# projects (LuminaBuildTool,
LuminaSharp) rather than for the compile database.
Re-run it after adding or removing modules, plugins or sources. Ordinary
source files are discovered at build time, and a build that changes a
Build.cs refreshes the database on its own.
Create a project from the editor, or copy Templates/Blank/ by hand and run
its GenerateProject.sh. Every generated project ships both
GenerateProject.bat and GenerateProject.sh, so a project created on one
platform still works on the other.
browse all types & interfaces →
$ claude mcp add LuminaEngine \
-- python -m otcore.mcp_server <graph>