Introducing Assiduous Engine: A C++23 game engine I've been working on since January 1st
7 November 2026

Let’s get the potentially controversial part out of the way first.
Was AI used in creating this engine?
Yes, extensively. AI has been a major part of my development workflow, and the engine also has first-class tooling for AI agents.
That said, AI is entirely optional. Everything in the engine works without it, and developers can use it just like any other game engine.
If AI-assisted development isn’t your thing, that’s perfectly fine. I just want to be upfront about how this project was built.
So, about the engine…
Assiduous Engine is a complete game development solution (at least for my needs), written in C++23 and making extensive use of C++ modules.
Some of its features include:
Editor
A complete editor, developed as a separate application but built on the engine and its asset pipeline.
It allows you to create and manage projects, author or import assets, write scripts, play-test your games, and deploy them to your target platforms.
Rendering
A physically based (PBR) forward renderer built on a render graph, featuring:
- Depth prepass and clustered lighting.
- Cascaded sun shadows and shadowed point and spot lights.
- Image-based lighting and reflection probes.
- Decals, sprites, particles, skinned and instanced meshes.
- Render textures for in-game cameras.
Post-processing: Ambient occlusion, SSR, screen-space GI, bloom, TAA, MSAA, FXAA, auto exposure, and colour grading.


Engine modules
- Audio (miniaudio)
- Skeletal animation and property animation
- Inverse kinematics (two-bone, aim and foot placement) and root motion
- Physics (Jolt)
- Navigation and pathfinding (Recast + Detour)
- Particles
- Terrain and vegetation
- P2P networking with replication
- GUI (XML + CSS)
- Scripting (AngelScript + Luau)
Asset pipeline
An asset processing pipeline that allows you to import assets and cook them for your target platform.
Command-line tools
Tools for managing projects, invoking the asset pipeline, exporting games, and performing other development tasks.
Agent tooling
This is something I’ve put considerable effort into.
The engine provides tooling for working with AI agents to create games. Agents can create projects, create and modify scenes, write scripts, import or create and configure engine assets, play-test games, and export them for target platforms.
The agentic workflow was designed as a first-class citizen of the engine. The goal is for agents to be able to perform the same development tasks as a human, using the actual engine tooling rather than relying on a collection of disconnected integrations.
All of the sample games included with the engine were created entirely by agents from specifications.
Other features
There are plenty of other features worth mentioning:
- Custom shaders.
- Resource hot-reloading.
- Native plugins.
- Running multiple game instances side-by-side in the editor (useful for testing multiplayer).
- Editing multiple scenes side-by-side.
- Flexible editor docking, with panels that can be undocked into separate OS windows (useful for multi-monitor workflows).
And more…

A little about the architecture
The engine is written in C++23, making extensive use of C++ modules.
It’s split into five layers, each with its own responsibilities and concerns. Dependencies flow upward through these layers.
Foundation
The lowest-level libraries. These depend only on external libraries or other Foundation libraries.
Some examples:
- Core: Containers, mathematics, system utilities, etc.
- RHI: DirectX 12, Vulkan, WebGPU, and a Null backend for unit tests and headless applications.
- Shell: Windowing and input abstraction, backed by SDL3 on desktop and Steam Deck, and Emscripten on the web.
There are many more Foundation libraries providing the base functionality used by the layers above.
Engine
Implements the opinionated engine layer, providing the gameplay systems and functionality.
The scene system follows a hybrid ECS model. Entities are identities, components are value types, and component managers (the equivalent of systems in ECS) own the logic and lifecycle of their respective components.
The goal is to provide the benefits of a data-oriented architecture while offering a friendlier interface than your typical ECS.
Pipeline
Defines the engine’s authorable and importable asset types, including textures, models, particle effects, scenes, prefabs, GUI screens and stylesheets, fonts, etc.
The pipeline also defines builders for each asset type, which cook assets into the engine’s resource format.
Editor
Contains all editor functionality, organized and separated by concern.
Tools
Command-line tools for cooking shaders and assets, exporting games, and working with the engine headlessly. This also includes the tooling that allows AI agents to interact with the engine over MCP.
Inspirations
The engine was inspired by:
If you like what they’re doing, please check them out!
Want to give it a try?
You can compile it from source: Git Repository
Or grab the latest download for your platform, or see everything in the 0.1.0-beta release on GitHub. Currently, the editor and development tooling run on Linux and Windows.
The engine comes with a few sample projects to get you started, giving you a feel for how it works and showcasing various features. You can grab them from the project manager when you launch the editor.
I’m currently working on a more ambitious game using the engine, which I hope will help me iron out some of the remaining issues.
So, why create another game engine?
After writing all of that, I realized there was one more point worth covering.
The simple answer: Why not? Because I wanted to.
The more nuanced answer is that other engines just didn’t suit me.
Unreal: I never owned hardware that could run Unreal reliably, and I prefer a lighter engine. The kinds of games I want to make don’t require the power of Unreal.
Unity: It’s just too closed for me. I’m a tinkerer, and I want to get under the hood of the engine, fix issues, or modify things to suit my needs.
Godot: You’d think that, given my attitude towards the two above, Godot would be ideal for me. Well, I absolutely hate its architecture. I think there are some positive things about it, but the negatives outweigh them for me.
I’ve tried a bunch of open-source engines, and even contributed to some of them. Most had various issues and didn’t quite satisfy the way I wanted to work on games.
The three that came closest were Lumix, Traktor, and ezEngine, which ultimately became the main inspirations for my own engine. However, each had some shortcomings that prevented me from simply adopting it and getting on with making games.
My engine has its issues too, but at least it covers all the bases I consider important for my game development work.
I think it’s reached a point where I can just use it to make games and let that drive any future improvements and evolution of the engine.
Website: https://assiduousengine.com
Note that the website and documentation are still works in progress and will be completed for the final 0.1 release.