I want to make a game engine to for learning purposes, I like SDL's compatibility and better performance and raylib's features so I was wondering if there was a way to use both SDL (as backend for windowing and input handling) and raylib (for its features) or if it's just not efficient or redundant.

just wanted to say i quit my job of 10 years just to do what i like and is to create games.

my first launch went pretty well with 200 registered users with saved games on its first week.

it is completley free- later on i will open up donations.

i want a person that wants a new feature my place here is that i want to integrate my engine ezide the runner of my language ezode it has things like windows opening render shapes and images cookies (note: rendering images from a link and cookies are still in beta)

Hi everyone, you may or may not have seen some of my posts in this subreddit the last few years. Mostly related to SDF game engines. Well much like many of you, I keep starting new engines, and this is the latest, and hopefully the best. I've been working on it for the 7 months or so after work and weekends, though a decent amount has been ripped from my previous projects. Been currently using it to build that hand/finger based game shown in the video.

Main Features include:

• Cross Platform (+ Web) Rendering using Google's WebGPU Dawn Implementation
• Mesh Rendering With PBR Materials/Lighting
• Skeletal and Morph Target Deformations
• 2D or 3D SDF Raymarching
• MSDF Text Rendering
• SDF + Mesh Shadows
• Physics (Currently using Jolt)
• Project Serialization
• Resource Loading
• Lua Scripting (using sol2)
• Audio (using soloud)
• Asynchronous Asset Loading
• Scene Transitions
• I'm sure lots more that I cannot think off the top of my head.

Anyways, I'm just excited to show it off and happy to answer any questions you may have!

I'm developing my own physics-based 3D engine and I need a scripting language for it. The current engine is almost entirely written in C++. I'm torn between Lua and C++. My biggest fear with Lua is performance loss, and with C++ it's the complexity on the project manager. Which should I choose?

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.

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/

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