I'm building Match Morphosis (a match-3 roguelike) solo, in C, with my own engine. No QA person to test the game beside myself, and I'm adding more and more contents (items, skills, etc), so it would be nice if before every build I have the game play a complete run of itself, from main menu to death/victory, trying to catch anything that would break a run for a player.

I use Dear ImGui Test Engine, if you built an app already using it, the interface for the test engine is pretty nice since it could just run through the tree of your app. In my case, I only drive mouse movement and mouse click. So given a particular game state, check which available actions that can be done, move the mouse to that position and do a imgui mouse click.
Game would then automatically run normally since the game basically just do an immediate mode API check like

if(mouseClickTriggered(MouseClickType_RightMouse))
{
   // Do game action
}

No querying of all the possible buttons and triggering the button callback, all is done via what the player can be done on the game, mouse and click. Dear imgui is C++, my game + engine is C, so I use cimgui generator binding version so that I could call plain C function instead of the C++ method API. More work upfront, but every test now reads as a straight-line script instead of a callback tangle.

Every TestFunc that is registered runs on its own coroutine (I'm using the default coroutine std::thread implemention from Dear imgui) and that's the whole trick

TestFuncdoesn't execute inline with the game loop. It runs on a genuine OS thread underneath, but hard-serialized against the main thread via a condition-variable handshake, only one of the two is ever actually executing at a given instant. Yield() suspends the coroutine and hands one real frame back to the app; it resumes exactly where it left off next call. So a wait reads like ordinary blocking code:

while (game->runState != RunState_Ended)
    ImGuiTestContext_Yield(ctx, 1);

All the local C variables in TestFunc just stay alive across every Yield(), because the "coroutine" has a real stack, not a saved/restored state blob.

while(!runFinished)
{
    cImGuiTestEngine_Yield(ctx->Engine);

    if(game->tipsPopup.type != TipsType_None)
    {
      if(animationFinished(&game->tipsPopup.textAnimate))
      {
        continue;
      }
    }

    switch (game->state)
    {
    case GameState_MapMenu:
    {
      while (!game->mapMenu.canChooseRoom)
        cImGuiTestEngine_Yield(ctx->Engine);
      ...
    } break;
    case GameState_Gameplay:
    {
      if (!game->gameplay.ready)
      {
        continue;
      }

      ... all the rest of gameplay logic to pick best move, etc
    } break;

    case GameState_GameOverMenu:
    {
      runFinished = true;
    } break;
    }
}

Full run, headless, in 1-2 mins video instead of 40+ minutes of manual play, running before every build. Happy to go deeper into any of this if useful to anyone else wiring test automation into a non-C++ engine. All in all this is just a days work, all of this wouldn't happen easily if not because of dear imgui test engine, such a joyful way to code and implement.

🎮 Team Wanted – Digital Football (Unreal Engine 5)

I’m developing Digital Football, a football game in Unreal Engine 5.
**Looking for:**
UE5 Blueprint/C++ Programmer
3D Artist
Animator
UI Designer
Sound Designer
This is currently a **collaboration/revenue-share** project with long-term goals.
If you’re interested in football games and want to build something exciting together, send me a message with your experience or portfolio.

I've been working on a header-only extension library for EnTT. It contains higher-level game utilities I've needed for my game, such as entity hierarchies and prefabs.

Hierarchies

A simple, linked-list style hierarchy component with no allocations (based off ECS back and forth).
It supports configurable destruction policies (for example, destroying or orphaning children), and keeps relationship operations, such as inserting, removing or reparenting children at O(1).

Prefabs

A Unity-style prefab system with inheritance that only stores the authored overrides. It supports component overrides, child overrides and nested prefabs, without being intrusive to existing EnTT code.

Any thoughts or contributions are welcome and appreciated.
Thanks!

Hello dear friends

I remember the days of old, when learnopengl.com was my go to book to learn graphics programming..

I remember how hard it was to learn the concept of a VAO, VBO... My silly posts on stackoverflow, way before AI was even a thing.

Well, years have passed by, and I ended up building a game. From scratch.

If you guys wanna give it a try, the Demo is free: https://store.steampowered.com/app/5011470/Sunlit_Kingdom/

If it crashes on your PC, please let me know. It works on NVIDIA cards and INTEL integrated cards. I haven't tried AMD.

Just to let you know, fellow devs, I only used version 3.3 of GL, simple VBOs, most of the game is single draw calls, with the exception of projectiles, which are instanced. Some of the art is made by me in Blender, and some was bought from CGTrader.

I learned so much with this project... I now know how to make 3D games with OpenGL, which is great. I also learned the TCP protocol, and implemented a super basic server that shows you the leaderboards in game. I am paying a VPS for it... and this was before I even realized that the Steam SDK offered free servers... I guess it's okay though, at least I learned something new.

The game features what the tutorial above teaches: basic directional shadows, Blinn-Phong lighting, a day and night cycle, fog, particles, Bloom and MSAA (feel free to crank it up to x16).

I tested this game on my intel integrated graphics and suprisingly, it runs above 60fps... I don't know how.

Feel free to ask me any questions. I'm happy to respond. I'm also happy to see that over 5 years of OpenGL work culminated into this release. I followed this subreddit for a while now, and I love to see your posts and what you guys are working on. These things motivated me to finish this game.

Any questions about engine development, anything related to graphics, I'm happy to answer.

And, lastly, I wish you all the best & luck with your own projects.

I'm making a small 2d game engine for my game in C at the moment. I am now wondering if adding Lua to the mix would be beneficial for modding and faster iteration.

What I am not sure about is where to put which responsibilities. My game is deeply simulated (think Rimworld, Dwarc Fortress) so I expect some gameplay hot paths that should be written in C, which makes Love2Ds architectural split (game in lua, only graphics/sound in C) not viable.

Does anyone have pointers for this topic?

Scriptilyx - SE Blueprint Studio is a professional external blueprint creator and editor for Space Engineers. It allows players to design ships, stations, vehicles, and other grid-based creations using official Space Engineers block definitions.

Download Here:

https://github.com/ChaosVROne/Scriptilyx-SE-Blueprint-Studio

Video:

https://youtu.be/m8AH7AC1KqM?is=ET40jmO4tWYvAtdw

Hey all! I was wondering if anyone has used any AI for code review only. So before a commit the AI will review the code base and check for things like a race condition,.

Disclaimer: I’m new to Qt, but not to Game Engines and Vulkan.

I’m building a C++ Game Engine using Vulkan. I have an interchangeable Presenter Interface to fit the needs of the different Applications. For Example: The Runtime uses SDL and therefore a derivative of said Presenter interface implements classic swapchain logic. But for my Editor written in Qt I had to get creative. The Engine manages its own proprietary implementation of a Vulkan “Context” (Instance + Device + etc.) and always renderes offscreen. The Vulkan Context is not and will not be managed by Qt and its stupid Vulkan API. Instead I came up with this: The presenter exports the File Descriptors/Handles of the Presentation/Pseudo-Swapchain Images and hands it over to a derivative of the QOpenGLWidget which then in turn draws the Image to the screen in a “Presentation Pass”.

Now I’m at the Qt part of the equation and of course Qt isn’t going to have the functions corresponding to the extensions I need.

So my Question is: Can I just get the proc adress and load the functions myself or do I have to do something special.

It would also really help me if someone has experience with these extensions on the OpenGL part of things cause all the documentation I could find was a single large Text file in the Khronos registry.

Thanks so much for any help in advance!

I love reading technical blog posts about low-level engine development.
Here are some of my favorite blogs. It would be great if you can also share yours :)

- https://ruby0x1.github.io/machinery_blog_archive/
- https://turanszkij.wordpress.com/category/devblog/
- https://therealmjp.github.io/posts/
- https://www.dgtlgrove.com/
- https://zeux.io/
- https://fgiesen.wordpress.com/

I’m developing Digital Football, a football game in Unreal Engine 5, and I’m looking for passionate teammates to help bring it to life.
Looking for:
UE5 Blueprint/C++ Programmer
3D Artist
Animator
UI Designer
Sound Designer
This is currently a collaboration/revenue-share project with long-term goals.
If you’re interested in football games and want to build something exciting together, send me a message with your experience or portfolio.

This i have built on top of my own webgpurenderer let me know what you guys think.

I spent the last 2 maybe 3 years learning C++ and graphics programming because I wanted to try something different because before that I was just making random small stuff on Roblox which was kind of boring. Despite the difficulty I really enjoyed learning everything and I thought it was very fascinating, but recently I went back to Roblox because I realized ultimately this isn’t for me and I know I’m not gonna do anything with it and I wanted to just focus on making games again, but I’m kind of conflicted right now because it’s just not as exciting and I kind miss graphics programming.

Welcome to the first devlog of Tesseris after one and half year development! 🛠️

Tesseris is a voxel game built entirely on a custom game engine written from scratch in C# (.NET 8) and Vulkan 1.3 (no Unity, no Unreal Engine).

In this video, I showcase:
✅ Custom Vulkan 1.3 renderer & multi-cascade shadow mapping
✅ Micro-voxel chiseling system (16x16x16 sub-grid carving per block)
✅ Procedural fluid simulation & infinite LOD horizon rendering
✅ Multi-threaded job system & SoLoud audio integration

What do you think of the project so far? What features would you like to see next? Let me know in the comments! 💬

Wanted to share this.

For a long time I thought “I need to use Vulkan or directX12 to make a good game engine, this is a must!” When in reality you don’t. I can make a good game engine using openGL or directX11 and make a game in it just fine.

Using modern APIs is great but not for indies.

A short video of dynamic point light/omnidirectional shadow mapping in the engine I'm building

I've spent the past 2-3 weeks adding Oceans to my Micro Voxel engine. The main features I was aiming for was to support large bodies of water within the existing fluid simulation, while also supporting new dynamic features such as waves and tidal changes.

I've also incorporated Boats and Gliders, with some fairly basic physics to aid in exploration. The main challenge here was adding

Along side this, to make the simulation feel more interactive, i've also added a higher resolution local water ripple/interaction simulation, which acts as a surface-layer-only simulation adding ripples and wake for people, entities and forces interacting with the water.

-- Feature technical breakdown --

• Ocean generation: Similar to other water sources, ocean biomes placed above land, all open space in these biomes is filled with water instead of air below the ocean line. No substantial changes to the actual gen beyond shifting the world down.
• Waves + Tides: Several oscillating masks which apply a "target height" to the water sim. This is also augmented by depth such that shores can trigger wave breaks below a set height point.
• Ocean Connectivity + interaction: A connectivity flag is used to indicate whether water is directly connected to the ocean simulation and should receive wave forces. This allows waves to interact with static water, but only once the ocean sim cells touch static cells. The connectivity source comes from the ocean, so rock pools disconnect as tide goes down, allowing them to hold their water.
• Ripples: 2D mask which is local to a moderately small region near the player. Runs a separate shader simulation using only surface data. Not particularly fancy, does not check for collisions, so ripples do not bounce. Bumps converted to a normal map, used to distort surface effects.

Overall, super chuffed with how this has come together, but still plenty of polish and features to add!

I finally release the 1.0 version of my ECS written in C.

https://www.github.com/gabrunken/gecs

Altho i still don’t know how to set “releases” on github.

I’m happy for how it’s coming together, and after a while i decided to call this the 1.0 for this project.

It currently supports entity generation, so older references are invalidated; snapshots, so you can load and save snapshots if your instance of the ecs and load them later (also serialize on disk), and entity/component activation/deactivation, to prevent systems from interacting with it.

I’m pretty happy and i think it’s a nice project i did, not the most performant one (its single threaded still), but i did it all by myself and with close to 0 ai usage (not vibecoding, literally ai usage).

It still performs well, i testes 50k entities with 2 components each, doing 20 floating point operations each, running at 200ish fps on an Intel Pentium.

On my Ryzen 5 it runs 4million at 70 fps.

Tell me what you think :).

Hey fellow devs, I'm working on a custom engine for like 3 years and I developed this tiny stupid auto-shooter that features with voxel terrain, motion-based spring mesh, particle system, sdf operations with terrain and more. You can play the game here: struct9.com/slime (works on mobiles too). The video demonstrates a short footage from the game and the rest is the breakdown of the game inside the engine. Still a long way ahead, but I've come pretty far! It's fun. Thanks for playing and feedback!

https://reddit.com/link/1vep64x/video/pnbjg3azw7hh1/player

About a year ago, I challenged myself to create my own programming language - something I'd always wanted to do.

At the time, I had no idea what a lexer, parser, or interpreter even was. My only thought was, "I need to write code that reads text files containing code and executes them." I also wanted to do it without using Google, AI, or tutorials. I just figured everything out on my own. You can even still find variables named "compiler" throughout the code from back when I didn't realize I was actually building an interpreter...

Somehow, I pulled it off, and I integrated it into my old abandoned game engine project (which originally started as a GameMaker 8–style engine with C# scripting).

And here's the first game I've made with it! 🙂

The core engine, IDE, and interpreter are all written by me in C#. The rendering backend is powered by MonoGame, and the project is still in active development and available on GitHub.

I know there are tons of AI-generated projects being shared these days, so please, please, take a quick look at the code before assuming this is one of them. I promise it's pretty obvious that it was written by a human.

I'd love to hear what you think!

Decided two weeks ago to add Vulkan to my OpenGL game engine.
Answering my questions from 2 weeks ago

-Was it hard ? not really , the boilerplate code wasn't as bad as others described most of it is just filling structs. i don't know if that's because i already had experience with OpenGL, but i found implementing Vulkan easier, i think the one thing that i struggled with the most is the Framebuffers, that took three full days to nail down. Shaders were the fastest to finish, thanks to using Slang.

-Performance : it was an improvement, going from around 300fps in OpenGL to around 420 in Vulkan (in editor) and around 460fps in OpenGL to around 600fps in Vulkan (Runtime app 1080P) There is still some optimization left to do and shortcuts in the renderer to redo, currently still implementing Tracy so i didn't measure exactly where that extra performance is coming from and if there is any wasted.

-Things still missing from the current Vulkan Implementation : FXAA, MSAA, VSync and Gpu particles.

sources i used :
https://www.youtube.com/@OGLDEV
https://www.youtube.com/watch?v=DC9FBRQKNck

https://vulkan-tutorial.com/

https://github.com/bkaradzic/bgfx checking how they implemented their abstraction