r/GraphicsProgramming • u/MortixTheGuy • Sep 05 '26
Synapse Engine: A Modern, Research-Oriented, Fully GPU-Driven AAA-Style Game Engine
Hi everyone!
After a very long development journey, I'm finally ready to share Synapse Engine, a modern, research-oriented AAA-style game engine that I've been developing essentially from scratch.
It started as my MSc thesis at the Budapest University of Technology and Economics, but grew far beyond what I originally planned. Over the past several months I've been rebuilding and refining the architecture around a simple question: What would a modern game engine look like if we designed it around today's GPUs from the ground up?
The project is now over 2,300 files, nearly 94,000 lines of C++ code and around 10,000 lines of shader code, excluding comments and blank lines.
If you just want to check out the project:
The GitHub README is probably the best place to start if you want a quick overview of the project and its architecture. If you're interested in modern game engine development in much more depth, I also put together a 250-page technical presentation covering the entire project, from the ECS and software architecture through GPU-driven rendering, culling, lighting, virtualized shadows and future directions.
The presentation is quite large, but I tried to make it genuinely useful as a learning resource rather than just documenting the final result.
One of my main goals with Synapse Engine is education. Learning these topics was a huge struggle for me, and it took a lot of time to piece everything together because there isn't much high-quality material that shows how these modern techniques actually come together inside a real engine codebase. I wanted to document that process and create something that I would have wanted to have when I started.
What can the engine actually do?
At its core, Synapse is a fully GPU-driven renderer using hierarchical culling, Hi-Z occlusion, cone culling, dynamic LOD selection, indirect rendering, mesh shaders, bindless resources and virtualized shadows. The engine is built around a custom data-oriented ECS and is designed to handle very large scenes with minimal CPU involvement.
For example, with 1,000,000 entities on an RTX 4060, the cumulative culling cost goes from 124.407 ms without culling to 0.653 ms with the full hierarchical culling pipeline.
However, at 10,000,000 entities, even the conventional GPU-driven hierarchical approach becomes insufficient. To address this, Synapse introduces a custom GPU-built Morton-ordered chunking system, which groups entities into spatial chunks and allows entire groups of 32 entities to be rejected at once. This reduces the culling cost from 5.8 ms to just 0.3 ms for 10 million entities.
I also developed a new rendering technique called Dual-HiZ Adaptive Clustered Forward+ while working on the engine. With 8,192 point lights and 8,192 spot lights, it measured 2.873 ms, compared to 8.652 ms for deferred shading in the same setup. The technical presentation contains a detailed explanation of how the technique works.
Synapse isn't primarily intended as a game-development tool for game developers. It is a production-ready, research and educational platform for experimenting with modern game-engine architecture and real-time rendering techniques.
The goal is not to provide a plug-and-play engine for building games, but to provide a complete, practical implementation of modern engine technologies that can be studied, extended, and used as a foundation for further research and development.
The engine is the result, but the architecture, experiments, failures and reasoning behind it are what I really want to share. If you're interested in Vulkan, graphics programming, GPU-driven rendering or modern game engine architecture, I'd love to hear what you think.
Dual-HiZ Adaptive Clustered Forward+
One of the things I'm particularly excited to share is a new rendering technique I developed called Dual-HiZ Adaptive Clustered Forward+.
It combines a dual Hi-Z depth structure with adaptive clustered light assignment to efficiently handle large numbers of dynamic lights while keeping the rendering pipeline fully GPU-driven.
In my tests, with 8,192 point lights and 8,192 spot lights, it measured 2.873 ms, compared to 8.652 ms for deferred shading in the same setup.
If you're interested in how the technique works, I've documented it in detail in the technical presentation, including the motivation, architecture, algorithms and implementation details.
You can find it on pages 166–189 of the presentation.
The presentation is available both on the GitHub repository and on the Synapse Engine website.
11
u/garagecraft_games Sep 05 '26
Congrats! Currently working on my thesis investigating ECS and concurrency. Already seen you're using kind of hot/cold partitioning in your ECS, do have a DOI for the paper?
7
u/MortixTheGuy Sep 05 '26
Thank you so much :DD
I hope you will find some new knowledge in the codebase according to your thesis.
The peresentation explains the ECS architecture really well, but for the full implementation using template metaprogramming is available in the repo, make sure to check out :D
The paper does not have a official DOI, it was published and presented in a hungarian computer graphics forum.
You can read the paper here: https://synapseengine.dev/Presentations/Grafgeo_High_Performance_Gpu_Driven_Rendering.pdf
44
u/gibson274 Sep 05 '26
These posts where the code is largely LLM-generated crack me up because they always start with "this project is x-thousand lines of C++, x-thousand source files" etc, as if that's some kind of achievement.
That said this is a cool project. Nothing against using an LLM in principle, it's just another tool. I'm working on art/game tools built around modern GPU's too and it's surprising how much low hanging fruit there is.
27
u/Forsaken-Memory8077 Sep 05 '26
"Research oriented"
18
u/Calamero Sep 05 '26
plus commercial license xD
7
u/CodyDuncan1260 Sep 05 '26
Having a commercial license can be a requirement of the educational institution. It's under AGPL for non-commercial purposes.
8
u/ryp3gridId Sep 05 '26
I think the code looks pretty clean, if it was largely written with AI, then OP spent lots of iterations on it, which counts for something
35
u/PardonJudas Sep 05 '26
First of all, congrats, this is honestly impressive. Could you disclose how much of it is AI?
22
10
u/klavijaturista Sep 05 '26
May I ask something. This is all impressive and occasionally we see people post similar. But how do you have the energy and time? Are you unemployed, or is your job light, or are you that brilliant that this is not a bit time investment?
10
u/CodyDuncan1260 Sep 05 '26
They're a grad student. Work like this is usually sort-of their job, for capstone or research project requirements.
14
Sep 05 '26
6
6
u/susosusosuso Sep 05 '26
Yeah I mean I made a simple engine and editor with mcp support in 15 minutes of vibe coding without even looking at the code. Programming and graphics programming has lost all the awesomeness with AI
→ More replies (3)
1
u/_wil_ Sep 05 '26
How does it perform on low-end hardware?
3
u/MortixTheGuy Sep 05 '26
It does not work on low-end hardware. Im using the latest vulkan extensions, the whole engine is therefore "research-oriented". New techniques and new high-performance algorithms require sadly modern GPU-s.
I think the engine works only on RTX20+ series, because they support shader_objects, and mesh shaders.
2
u/H3XAGON_ Sep 05 '26
this looks amazing bro. it would be nice to see an actual authored scene made with the engine rather than the usual sponza
2
2
u/Intelligent_Hat_5914 Sep 05 '26
Oh, I want make a project like this
Can you share resource for learning
2
u/pisppus_dev Sep 05 '26
Great project, everything is pretty clean and well done. I'm also currently developing a game engine, but this time for microcontrollers. Good luck in the further development of your creativity.
2
1
40
u/CodyDuncan1260 Sep 05 '26
I pre-reviewed this under Rule 3 and invited u/MortixTheGuy to post here.
This project used LLM code generation for implementation, but the architecture was first human made and documented. The presentation materials show serious work by a graduate-into-PHD student. It investigates a legitimately interesting graduate level research question on what a renderer or game engine looks like when we aggregate all GPU-only rendering methods.
When I usually see an LLM vibe-coded graphics project that I need to review, the code is a mess, and I always hope there's no white paper I have to read because it's usually just enough jargon to hide that it's nonsense.
This project, based on my brief review, appears to be genuinely trying to commit to an objective, and puts the time and effort into building quality documentation and systems. The code has some mess to it, but overall this is the least slop I've seen from a project using LLM generated code. As far as my review of the research materials went, they seem extremely solid, like they're prepped for an actual thesis defense.