Lumina Game Engine

A modern, high-performance game engine built with Vulkan

"Everything around you that you call life, was made up by people that were no smarter than you" - Steve Jobs

Blog • Discord • Documentation

---

Show more images

---

2026-01-28.22-17-28.mp4

About

Lumina is a modern C++ game engine designed for learning and experimentation with real-world engine architecture. Built from the ground up with Vulkan, it demonstrates professional engine design patterns including reflection systems, ECS architecture, and advanced rendering techniques.

Perfect for:

• Learning modern game engine architecture
• Experimenting with Vulkan rendering techniques
• Building prototypes with a clean, modular codebase
• Understanding how engines like Unreal and Godot work under the hood

Contributions to Lumina are recognized in several ways, including Steam keys for popular games and public acknowledgment in our Discord community. Lumina improves through the work of motivated, like-minded contributors who help push the engine forward.

Caution

Lumina is an educational project in active development. APIs may change, and some features are experimental. If you encounter build issues, please reach out on Discord for assistance.

---

Key Features

Advanced Rendering

• Vulkan-powered renderer with automatic resource tracking and barrier placement
• Forward+ rendering pipeline with clustered lighting for efficient multi-light scenes
• PBR materials using a material graph compiled into GLSL.

Modern Architecture

• Entity Component System (ECS) using EnTT for high-performance gameplay code
• Reflection system for automatic serialization and editor integration
• Modular design with clean separation of concerns

Professional Editor

• ImGui-based editor with real-time scene manipulation
• Visual hierarchy for easy entity management
• Component inspector with automatic UI generation via reflection

Performance First

• Multi-threaded task system with EnkiTS
• Custom memory allocators using RPMalloc for optimal performance
• Built-in profiling with Tracy integration

Lua Scripting

• Full ECS access from Lua - Create systems, query entities, modify components
• Hot-reloadable scripts - Iterate on gameplay without recompiling
• Automatic binding generation - C++ components instantly available in Lua through reflection
• Performance profiling - Built-in Lua script profiling with Tracy

---

Gallery

New Images Coming Soon

---

Quick Start

What You Need

• Windows 10/11 (64-bit)
• Visual Studio 2022 or 2019 with MSVC v143 toolset (17.8+)
• Python 3.8+ added to your system PATH

Note

Jetbrains Rider is the recommended IDE for Lumina development (but it is not required)

Installation Steps

1. Clone the repository

   git clone https://github.com/mrdrelliot/luminaengine
   cd LuminaEngine

2. Run the setup script

   python Setup.py

   • This downloads and extracts all dependencies automatically
   • If the download fails, manually download External.7z and extract it to the LuminaEngine folder

3. Open the solution

   • Open Lumina.sln in Visual Studio

4. Build and run Lumina

   • Select "Lumina" in the list of runnable configurations
   • Select Development or Debug configuration (Debug will be vastly slower, but with debugger functionality)
   • Note You will see two different platforms, Game and Editor, by default this will be set to Editor. Selecting game will launch without any tooling.
   • Press F5 or click Build -> Run

5. Start developing

   • Open the Sandbox project to experiment
   • (TEMPORARILY NOT-WORKING) Or run Tools/ProjectConfigurator.py to create a new project

Tip

Missing v143 toolset? Install it via Visual Studio Installer -> Individual Components -> MSVC v143 Build Tools "Cannot find .generated.h" error? Build again - Visual Studio sometimes needs a second pass to detect new files Python not found? Ensure Python is added to PATH during installation (check "Add Python to PATH" when installing) Error C1076 compiler limit: internal heap limit reached - Try again, this is currently an issue with a font file. Build fails? Submit an issue or contact me on Discord An application control policy has blocked this file - Garbage Windows 11 feature, disable "Smart App Control" **After every pull/merge, delete all Binaires, Intermediates, and "Clean" the build.

Note

The LUMINA_DIR environment variable is set automatically during build. If needed, set it manually:

setx LUMINA_DIR "C:\path\to\lumina"

Caution

Everytime you sync to the engine, you must delete your Intermediates and Binaries directories, and rerun Scripts/GenerateProjectFiles.py

---

Supported Asset Formats

• GLTF
• FBX
• GLB
• OBJ
• PNG
• JPG

Free Asset Resources

• Khronos GLTF Samples
• Kenney 3D Assets
• Flightradar24 Models

---

Third Party Dependencies (Alphabetical)

• ConcurrentQueue - Industrial-strength lock-free queue supporting multiple producers and consumers
• EASTL - Electronic Arts Standard Template Library optimized for game development with custom allocators
• EnkiTS - Lightweight task scheduler for creating parallel-for, task sets, and dependency graphs across multiple threads
• EnTT - Fast and reliable entity component system with sparse set implementation and signal/delegate support
• FastGLTF - High-performance GLTF 2.0 parser with complete specification support and efficient memory handling
• GLFW - A multi-platform library for OpenGL, OpenGL ES, Vulkan, window and input
• GLM - Header-only C++ mathematics library designed for graphics programming with GLSL-compatible syntax
• GTest - C++ testing framework providing assertions, fixtures, and test discovery for unit testing
• ImGui - Immediate mode graphical interface for rapid tool development with minimal dependencies
• JoltPhysics - High-performance multi-threaded physics engine with continuous collision detection and ragdoll support
• Luau - An efficient, optionally typed scripting language built from Lua
• MeshOptimizer - Mesh optimization library providing vertex cache optimization, overdraw reduction, and vertex/index buffer compression
• Miniaudio - Audio playback and capture library in a single file
• NlohmannJson - Modern JSON library with intuitive syntax and full STL compatibility
• RPMalloc - Lock-free thread-caching memory allocator with high scalability and low overhead
• RenderDoc - Graphics debugging tool integration for frame capture and analysis
• SLang - GLSL to SPIR-V compiler with optimization passes and shader reflection capabilities
• SPDLog - Fast C++ logging library with async mode, custom formatting, and multiple sink support
• STBImage - Single-header image loading library supporting multiple common formats
• TinyObjLoader - Lightweight OBJ file parser with MTL material support
• Vulkan - Low-level graphics API providing explicit GPU control and high-performance rendering
• VKBootstrap - Simplifies Vulkan initialization with reduced boilerplate
• Volk - Vulkan meta-loader for runtime function loading without linker dependency issues
• VulkanMemoryAllocator - Memory management library for Vulkan with defragmentation and optimal allocation strategies

---

Documentation

Coding Standards

Lumina follows a consistent naming convention:

Prefix	Usage	Example
F	Internal engine types (non-reflected)	FRenderer, FTexture
C	Reflected classes	CTransform, CMeshRenderer
S	Reflected structs	SVertex, SMaterial

General Rules:

• PascalCase for all identifiers
• Tabs for indentation
• Braces on new lines
• Descriptive variable names

See CONTRIBUTING.md for complete guidelines.

---

Contributing

Contributions are welcome! Whether it's bug fixes, features, or documentation improvements.

How to Contribute

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Make your changes following the coding standards
4. Add tests if applicable
5. Commit with clear messages (git commit -m 'Add amazing feature')
6. Push to your branch (git push origin feature/amazing-feature)
7. Open a Pull Request

Requirements:

• Clean, well-documented code
• Follow existing architecture patterns
• Include tests where appropriate
• Update documentation as needed

---

Acknowledgments

Lumina is inspired by and learns from these excellent open-source engines:

• Spartan Engine - Feature-rich Vulkan engine
• Kohi Game Engine - Educational engine series
• Lumix Game Engine - Fully working indie engine.
• ezEngine - Professional open-source engine
• GoDot - AAA quality open source C++ game engine.
• Unreal Engine - Does it need an introduction?

Special thanks to the entire game engine development community for sharing knowledge and resources.

---

License

Lumina is licensed under the Apache 2.0 License.

Copyright 2024 Dr. Elliot

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

---

Connect

• Blog: dr-elliot.com
• Discord: Join our community
• GitHub: mrdrelliot/lumina

---

Made with ❤️ for the game development community

⭐ Star this repo if you find it useful!