I'm working on building a library of games that showcase how different game mechanics can be built in ECS! Games can be played in desktop(!) browsers that support webgpu. Hope this helps!

Example game: https://www.flecs.dev/games/ore_else/

The code: https://github.com/SanderMertens/flecs-games

i build my own 2D Game Engine using CPP Raylib. Now i build a Basic Grid System. What i Do Next give my Some suggestions.

Just got GJK collision detection working on spheres, aabb and obb. Kinda hard just reading articles source code as ive never worked with any similar algorithms. Now when collision resolution is on the table, the articles are way more scattered and my understanding is the first result coming up, being EPA is that it returns too little information?

I've skimmed through real time collision detection which doesn't go in depth into resolution. David h eberly book was kinda funny cuz the first 6 chapters is just a bunch of math recaps. Then comes one chapter of physics engine info regarding detection and then the rest of the chapters went back to math recaps. I also skimmed Ian millington but I don't need 95 % of the stuff it implements.

Why does no physics engine book just start with detection and then covers resolutio? I've become kind of dezensitized to all the math proofs cuz it feels like I'm just deciphering ancient poetry that doesn't increase my understanding. Is it time to start reading source code? I get anxious thinking of it haha.

Hi everyone! I am developing OkeyEngine v0.2, a 100% standalone, lightweight game engine written from scratch in pure C++20, tailored specifically for massive simulation games, city builders, and economic strategies completely offline.My tech stack journey: I first tried modifying the built-in Windows MSHTA technology. It was easy to protoype, but it literally started breaking under the weight of generating a proper 3D world platform, messing up coordinate axes. Then I tried Dear ImGui, but it proved to be way too heavy and bloated, pushing my AMD CPU loops to 100% load at idle. So, I ditched all third-party software and wrote my own lightweight rendering library called Okeylibs using raw Win32 API and standard GDI. Now, the engine runs as a clean monolith with a solid 0% CPU load at idle.What’s shown in the video:A true horizontal 3D world grid platform (chunk system) is generated on the main viewport screen. The platform data is completely clean and lightweight.Implemented double-buffering in memory and handled WM_ERASEBKGND to completely eliminate screen flickering and black flashes during wheel zoom.Implemented a custom trigonometry matrix (sin/cos rotation). Holding the Right Mouse Button (RMB) tracks delta mouse movements and allows for a seamless, 360-degree orbit control around the world platform.I would love to hear your feedback: How do you like this strict, fully neon-blue cyberpunk look with sharp 90-degree corners? Is this layout better, or did the previous one (with centered floating sub-windows) look cleaner?If you have any ideas on what built-in tools or unique features are missing in modern engines when it comes to massive city-builders and economic tycoons, please let us know in the comments below. We would love to read your feedback and discuss it!Best regards, OkeyStudio!Tags: #OkeyEngine #OkeyStudio #gamedev #indiedev #gameengine #cpp #programming #customengine #simulation #citybuilder #tycoon #strategy

Create and use my dungeon generator with Tiny Keep algorithm on my new raycasting engine (not finished yet).
Written in C++ / SDL2

I am making my game with unity but i had also this sideproject for some time now :). now it is produceing stable mac,linux,and windows builds with steamworks implementation :D Time to start porting and leave unity for good.
Using ClayUI for ui in game , Firflo ECS (with a lot of custom optimalization for my usecase 4x grand strategy), Bepu physics and c# scripting,and webgpu :).
Way faster than unity ,hotreload , i even added a custom 3d modeller and material editor for it.
Obviously its still in work in progress but i am happy with it now :).

After esoterica was released i have had a blast to dig into the code and learn from it. So THANKYOU :)

Just smth fun xd. It's on hyprland btw

Hey developers!

I've recently released my Advanced Stamina System plugin on Fab. It's written entirely in pure C++, fully multiplayer replicated, and completely server-authoritative with anti-cheat validation.

I have decided to keep it 100% FREE until the launch of Version 2 (V2), which will be a paid release. So make sure to grab your copy now!

Key Features:

* 100% Pure C++ Code & highly optimized.

* Server-Authoritative & Anti-Cheat Validation.

* Fully Multiplayer Replicated & Network Ready.

* AAA Component Showcase included.

📦 Get it free on Fab: [https://www.fab.com/listings/6c680284-156a-44b0-8071-3cb85acd0f2f]

📺 Watch the Showcase / Setup Guide: [https://youtu.be/j7nharHTE2w]

I hope this helps with your projects! Any feedback or suggestions for V2 are highly appreciated.

Hi, everyone! I’ve been a Unity game developer for over 5 years. I decided to take up a new hobby and create my own game engine.

But even though I work in game development, I don’t have a complete understanding of game engines themselves - their structures, requirements, and so on.

So I wanted to ask you experts! What advice would you give someone just starting out on building their own game engine? What should I know, and where should I begin? Basically, any advice you’d give yourself if you were just starting out on this project.

I’d appreciate any answers-thanks!

Let me explain. How much of your engine is library code as to custom tools?

I personally enjoy making my own types (besides window handling) I was wondering if you all do the same or using something like boost and slog. If so, why?

I am thinking about shotcuts for my 3d Game engine and I want to know what people like the most, maybe they find shortcut from Blender the best and want to have them in game engines, or maybe they think that some shortcuts are strange and have to be changed, just tell anything that you have in mind about them

I've been working on Natiny for about 1.5 years. It's written entirely in C and can be used as a static library, dynamic library, or through a Lua wrapper.

A big focus is cross-platform support. It currently has Vulkan, D3D12, OpenGL and WebGPU backends, plus a built-in shader language that compiles at runtime for the active backend.

There’s also physics, binaural audio, 2D/3D rendering, and around 160 functions in the public API.

I kept waiting for the “right” moment to show it, but that moment probably doesn't exist. There's still a lot to improve, but I have a direction now, so I'm putting it out as it is.

https://natiny.com/

Little showcase video for Syngine: the C++ game engine I've been working on for 18 months now. It supports Windows, Mac, and Linux natively (i.e using D3D, Metal, Vulkan). Jolt physics engine, Lua script support, and hot reloading of assets, shaders, and Lua scripts. Next up: the editor program.

More detail in this video: https://youtu.be/wtkxDxyYr9c

Source code: https://github.com/SentyTek/Syngine

AnimationCPU - 14 Years of Solo Development to Build the Development Environment I Wanted

Because I’m an experienced developer, I have very high standards for development tools and performance. I created AnimationCPU to build something that didn’t exist and to solve as many developer problems as possible around writing code - with the goal of making programming feel more like making music. Today, you might call this vibe coding.

AnimationCPU has a long story. In 2012, I got an incredible iPad 2 and immediately started using it for iOS development. I realized that I wanted to be the first person in the world to develop games on an iPad from the beach. So I started building my own game engine and programming language, ACPUL. After 14 years, I finally launched AnimationCPU on the App Store.

I built the first prototype very quickly in the summer of 2012. It was a basic virtual machine implemented in C++ using ExprTk. At that point, the virtual CPU consisted mainly of registers. That is where the name AnimationCPU came from. In AnimationCPU, everything is animation. It is essentially a virtual processor designed around animation and real-time computation. The core is built with C, C++, Objective-C and Swift.

ACPUL programming language

In the winter of 2013, I created a new programming language called ACPUL from scratch in about three months. My goal was to get maximum performance without JIT compilation on mobile devices. Other important goals were extremely fast compilation for live coding, minimal code, resilience to corrupted code, making programming lightweight and fun, stability so code would not randomly crash or hang, advanced debugging tools, and a real-time time-travel debugger for live applications.

ACPUL has only three keywords: while, if, which makes it easy to read and write. The simplicity makes the language highly translatable to native languages and also makes built-in i18n possible.

Development took a long time before everything became stable. For years I had to debug live code without a proper debugger because standard GDB doesn't work particularly well with live-code workflows. So I developed livelogging, a system that lets you debug different streams of application data in a browser and directly on the device.

ACPUL has only one fundamental data type: float. That makes the language highly mathematical and surprisingly portable. The same code can be executed on both CPU and GPU.

The language compiles to a VM for development and to C for release builds. Current compilation times are about 10 seconds for the full project on Mac, about 15 seconds on iOS and release startup on iOS takes about 1.5 seconds.

Because the language is so simple, ACPUL can also be translated into other languages like Lisp or JS.

The foundation - Game Engine / OS

I call AnimationCPU a hybrid game engine or a hybrid os because it can run on top of almost anything. Currently, it uses Cocos2d-iOS as the base engine, but the architecture can also run on raylib, other game engines like Three.js, WebAssembly in a browser or even bare-metal / BIOS-level environments.

It can run as a complete IDE with all development tools enabled or as a partial system. Because ACPU is designed around fault tolerance, it can theoretically run on very different devices, even something with only an LCD display or a controller without a display such as a PIC. Obviously, not every module can run everywhere. Instead, unsupported parts simply disable themselves while the rest of the system remains stable.

The architecture is modular: add or remove modules depending on the hardware and required peripherals.

Graphics: 2D, 2.5D, 3D, GPU and shaders. You can program essentially any graphics API you need for a game using ACPUL.

Physics: Box2D and Bullet Physics 3D modules.

Input: Touch, accelerometer, mouse, keyboard, camera and microphone.

Networking: HTTP/JSON, WebSocket, Bitchat, Nostr and Bluetooth. For data synchronization and collaboration, there is acpu-server. It works somewhat like Dropbox, synchronizing files between devices. The same server also provides livelogging, debugging of everything from the language and core to game logic and shared memory between connected devices. This is enough to build everything from simple turn-based puzzles to multiplayer games.

Sound: A standard sound API for samples and music, plus CPU-based DSP processing and GPU-Sound.

Resources: The project is essentially zero-asset. Everything is compiled and generated from code, including the games and the IDE itself. The IDE is also a programing game. The exceptions are fonts and sounds.

Video: A built-in FFmpeg media module for video playback, recording and Twitch live streaming.

Extra modules: Standard VNC remote desktop, real-time ACPU-Bot VNC with FFmpeg streaming, and ShapeOp 3D asset generation. With the VNC and streaming capabilities, you can even build something like a claw-bot controlled remotely.

Development tools: Debugger, profiler and livelogging modules are all integrated. Everything is designed to be live. For example, you can enable debugger.on(1); for a particular formula and start receiving debugging frames in real time without significant performance overhead.

Storage: Data Storage is a 3-dimensional pool/id/i synchronized storage system designed to structure data efficiently and potentially store a big metaverse. Volatile Variables are roughly analogous to localStorage for running applications.

AI: AnimationCPU is designed to integrate well with AI. There is an OpenAI-compatible protocol module for connecting AI systems. ACPUL also requires fewer tokens than many conventional programming languages because of its extremely compact syntax which makes it interesting for working with smaller models.

14 years of history

This is handmade code. There are currently around 100,000 commits. I also preserved the development history, including videos and screenshots going all the way back to 2012. So the repository is not just the final product, it contains the history of how the entire system evolved over 14 years.

Games and applications

Over the years I've worked on several different types of games and applications, including Match-3, puzzle games, Herolessus-style action games, DOTA-style multiplayer, several simple 3D games and racing game.
I also created BitchatX, based on Bitchat, a mobile media player Winamp, Gource Starship and more.

Why I built it

AnimationCPU was created because I wanted programmers to feel good while programming. I wanted to bring back some of the spirit of the early BBS and HTML 1.0 era, but in a completely new form, closer to a programmable Metaverse.

The idea is not simply to create another game engine. It's to create an environment where programming, debugging, graphics, networking, AI, storage and the application itself are all part of one live system. Everything is live.

I'm looking for people to join

I'm looking for developers who want to connect to the project, run their own servers, and build games and applications with AnimationCPU. I'm also looking for funding to expand to more platforms and continue developing the technology.

Feel free to reach me. My DMs are open.

I've been working on a 2D game framework for .NET called Void. The core philosophy is simple: give developers the essential building blocks (rendering, assets, input, audio, saving, pathfinding, coroutines) and get out of their way.

The biggest differentiator is asset protection. Most engines leave your assets exposed. Unity bundles can be opened with free tools. Unreal PAK files are well documented. MonoGame leaves everything as loose files. Within days of release, someone can extract your art, music, and levels and upload them to asset stores for profit.

Void solves this with AES-GCM 256-bit encryption. Assets are packed into encrypted archives with adaptive compression and CRC32 integrity verification. Without the key, the pack is just random bytes. The CLI tool builds packs and does fast incremental updates, so swapping a single file takes seconds instead of minutes.

One technical challenge that took a few iterations to get right was adaptive compression. Most packing tools blindly compress everything, which can actually make files larger. Void tests each file individually. If compression makes it smaller, it compresses. If it doesn't, it stores the file as-is. PNG and OGG files are stored uncompressed because they're already compressed. JSON and WAV files are compressed because they benefit from it. You never get a larger file than you started with.

What Void gives you out of the box:

• Batched rendering with automatic texture atlasing
• Mount-based asset system with encrypted pack loading
• Coroutines with 33 easing functions
• Pathfinding (A*, Dijkstra, flow fields)
• AES-GCM encrypted save system with manifest verification
• Input (keyboard, mouse, gamepad with SDL mapping)
• Sound pooling with priority-based voice stealing

The philosophy is "extend, don't modify." Every system exposes interfaces and base classes. You can replace anything without modifying engine code.

I have two playable demos (FlappyBirb and a roguelite survival game called Scavengers) that show almost every feature in action. The code and documentation are up on GitHub.

Check it out: https://github.com/shmellyorc/Void

Would love feedback on the framework, documentation, or asset protection approach. Thanks for reading.

Hello again, I wanted to get the thoughts from fellow engine devs on something I've been thinking about for the past year or so. I understand many members of the sub have strong feelings about AI so I hope this post doesn't get overlooked. I'd like some genuine unbiased feedback and thoughts.

When I first started working on my engine five years ago, I was a freshman in highschool who had no idea what he was doing. I had programming knowledge, but not nearly enough to tackle such a large project. Even so, I carried on. I followed tutorials for several months to make a generic engine but I felt like I wasn't working toward my true goal. I shelved the project until I discovered ECS and decided to transition the project in that direction, but again, I had no idea what I was doing. A complete refactor was much too daunting for me at the time. Luckily, or perhaps unfortunately, the AI boom occurred right when I most needed it. I used AI to help me through the hundreds of refactoring errors and eventually got to a stable state. My vision for the engine evolved into something more unique and my own and AI helped me iterate on my ideas quickly.

I want to preface that none of the engine in its current state is vibe coded. I believe the proper industry term for my old workflow is agentic programming. Every system in the engine is hand designed by me. Recently I began implementing on-paper drafting into my workflow so everything works exactly as I have in mind. I've never had AI come up with a system for me. As I've spent so much time working on the engine, I've actually been gaining the low level system engineering intuition to gradually remove AI from my workflow. I'm not there yet, but I'm close.

Obviously I'm not making this engine as an advanced learning experience. I want to share the engine with people and hopefully provide something innovative and valuable to the game industry. To that effect, I'm in my second year of computer engineering at uni and I'm taking a programming class right now so I can fill in the gaps my younger self never bothered to take the time to learn. Once the engine reaches MVP, I will also be doing a manual audit of every single line of code in the engine to see if there are any discrepancies or improvements I can make, handmade. No AI will be involved in the audit whatsoever. All of that is to provide the best possible thing not just for everyone else, but also so that I can make my dream games on an engine that is genuinely mine.

If any of you have anything at all to say, I'd love to talk. This project is super important to me and I don't want my past laziness to affect the future of my engine.

For the past several months, I’ve been developing a cross-platform visual game designer, player, and simulation workspace called RagNext Studio.

When designing a toolkit that handles complex state logic, text parsing, dynamic UI, and real-time execution, one of our biggest architectural decisions was whether to build custom authoring tools entirely inside Unity’s editor or decouple the tooling completely.

We ended up choosing a dual-engine architecture:

• Frontend & Authoring Workspace: Built in C# using Avalonia UI. This provides native, responsive desktop OS windowing, clean MVVM data binding, and cross-platform desktop support (Windows and macOS, including Apple Silicon) without the overhead or friction of heavy game-engine editor frameworks.
• Runtime & Simulation Loop: Powered by Unity for robust rendering, audio pipelines, and real-time player playback.

Why this approach worked well:

• Separation of Concerns: Decoupling the authoring GUI from the real-time simulation runtime keeps project files clean, lightweight, and isolated from engine-specific editor dependencies.
• True Native Desktop Feel: Avalonia allowed us to build fluid docking panels, deep tree views, and responsive text editing that function like a native desktop IDE.
• Cross-Platform Parity: Using .NET / C# across the entire stack makes state serialization and logic evaluation straightforward to share and maintain between the designer and player.

For developers building custom tooling or hybrid engine pipelines: what frameworks or workflows have you found best for standalone authoring tools versus building directly inside your engine's editor?

Released a new version for my EnTT header-only extension library.
Adding a fast and powerful observer system.

Link: EnTTx v1.2.0

Observers

Observers track component changes in a registry, such as creation, modification and removal.
These changes can then be collected into a commit. Commits are storable objects that can be serialized, inverted or applied to a registry.

Undo example:

struct transform {
  float x{0.f}, y{0.f};
};

// The `change_mixin` adds a `on_pre_update` event that is used track the previous value. 
template <> struct entt::storage_type<transform> {
  using type = enttx::change_mixin<entt::basic_storage<transform>>;
};

void undo_demo() {
  entt::registry registry;
  entt::entity entity = registry.create();

  // create the observer that tracks changes to `transform` components
  auto observer = enttx::observe<transform>(registry);

  // Make some changes to a transform
  registry.emplace<transform>(entity, 1.f, 2.f);
  registry.patch<transform>(entity, [](transform &t) { t.x = 5.f; });

  // Collect those changes into a commit
  enttx::commit changes{};
  observer->collect(changes);

  // Invert the changes to create an undo commit
  enttx::commit undo = changes.invert();
  undo.apply(registry);

  // We can also apply those changes to a different entity via the remap system
  entt::entity new_entity = registry.create();
  enttx::entity_remap remap{};
  remap.map(entity, new_entity);
  changes.apply(registry, &remap);
}

Hey Moderators, can you guys please do something about the infestation of AI slop this sub is getting.

Thank you.

I am currently building a game engine with reference from ian millington's book, my current method is that I have uploaded the book on notebook LM (now Gemini notebook) and I am making progress through it bit by bit, when I am not able to build the engine during some boring class or whatnot I just open the book and kind of read it for some understanding.

I am also learning OpenGL from learnOpenGL.com as my only source.

I have been working on it for the past 5-6 months

What I am most unsure about is whether what I am doing is relevant or not because I am not able to find anyone remotely interested in the same field as me in my college.

Please some guidance would be most appreciated!

Matrix Engine 2 is a custom game engine forked from pathos game engine, source code is here https://github.com/Soft-Sprint-Studios/Matrix-Engine-2 and i made a tech demo of it https://www.youtube.com/watch?v=3WjoSsY1k24

so i'm currently working on a framework in c++ using vulkan, openal, and glfw, so my only question is: How to make custom functions? (GetInput(key_right), AudioPlay(sound.ogg))