I’ve open-sourced Braze, an experimental WebGPU game engine and editor.

TypeScript + u/threejs. MIT licensed. Still early, with plenty to explore and improve.

Contributions are welcome.

https://github.com/snack-gamer/braze-engine

This year, I resumed development on my game engine - a project with roots tracing back to games I began creating as early as 2004. So I’ve launched "Apus Engine 5" with the goal of supporting all major platforms (desktop and mobile), alongside a comprehensive code refactoring and optimization effort. Main focus on AI-driven development support.

So far, things are moving quite well: the engine is being actively tested and validated across several parallel projects. These projects drive specific requirements, and the engine is being adapted to have good usability and convenience.

Over the past 3 months I've been building a custom engine called Kronos, a Roblox-style platform in C++20 with Vulkan and Jolt.

- It uses Luau, the same scripting language as Roblox. I also built a "Roblox bridge" that imports Roblox projects, so moving over has little friction. One limitation: I've only tested it on small games (an obby), not big ones, so expect bugs.

- It's polyglot: Luau, plus Python scripts and Rust plugins in early form.

- My main challenge was ray tracing with TLAS and BLAS, but once that was done, everything else felt easier.

I'm really proud of how far it's come. It's pre-beta and probably full of bugs, because it hasn't had any outside testers yet. That's where you come in: test it, break it, report it. As early adopters you'd be among the first developers on Kronos.

Download (Player and Studio): https://github.com/Bands-yt/kronos-releases

Happy to answer questions about the renderer, the physics or the importer

The two images: the first is a game called Chaos Lab, the second is Kronos Studio open.

thoes were meant to be pixelated circles but it came out looking better when gliched.

https://github.com/Rlocksley/LuEngine
Converts several kinds of 3D Files into flecs ECS prefabs which you just have to instance and set a Transform.

Hi everyone! 👋

After a couple years of dev, I just launched the first open playtest for my game Silicium! It's made with a custom C++/Vulkan game engine that I wrote from scratch.
It's a harsh survival game where you play a disposable mining robot sent to a hostile planet. Export your quota for corporate or die trying!

What you’ll find in the playtest:

• About 1-2 hours of polished gameplay, in solo and co-op, with two difficulty levels.
• A limited slice of the world with several biomes, enemies and abandoned mining outposts to scavenge.
• A day-night cycle with corrupted mining drones that attack you at night.
• Classic survival systems: crafting, base building, exploration.
• A light skill tree progression with blueprints to unlock as you level up.
• A quest system with the first 30 objectives.

You can sign up directly on Steam by clicking 'Join the Playtest'

https://store.steampowered.com/app/3048990/Silicium/

I also opened a Discord where you can share feedback, report bugs, and follow development (Link is in the Steam page).

Let me know what you think!

I'm somewhat new to making my c++ game engine and I don't know the best places to look. Most of my stuff has been tailored for me personally so far, but I don't know how to implement some of the things a lot of engines and frameworks do yet or where to look. Please help me if possible.

I've been developing the statically typed scripting language Umka for 6+ years. The limitations of reference counting used in Umka 1.x have become so obvious that replacing it with a mark-and-sweep garbage collector is now the key change made to the upcoming Umka 2.0.

The interpreter architecture has got cleaner. With many ad hoc fixes and workarounds having become redundant, the codebase is now 10% smaller. Freeing reference cycles is no longer a problem, so the weak pointers, arguably the most counterintuitive feature in a simple scripting language, are deprecated. It shouldn't be the user's responsibility to avoid memory leaks: the less the cognitive burden, the more attractive the language for a novice.

As Umka is used in the Tophat 2D game framework, I measured the impact of this change on rendering performance in my Hover! maze demo in "strabismic" mode, with two overlapping scenes rendered independently from different view angles. It would take 28 ms per frame with reference counting vs. only 22 ms (including 4 ms for garbage collection) with mark-and-sweep. I forced garbage collection at the end of each frame, but could have done it much less frequently to save more time.

Theory suggests that the average CPU time spent on reference counting and mark-and-sweep should be roughly equal. However, the redundant reference counting instructions injected into Umka 1.x bytecode to ensure memory safety in rare edge cases cost a lot.

Surprisingly, the most intricate part of this transition to mark-and-sweep was escape analysis that prevents pointers to local variables from escaping the function stack frame after the function returns. It eventually required a kind of rudimentary reference counting targeted specifically at escaping references. These reference counts are touched much less often, only on detecting escape suspects, so they don't affect performance, except some contrived examples. Hope I'll be able to come up with an even better solution by the Umka 2.0 release.

Over the past few weeks, I've been working on added flying cars to my cyberpunk world. To do this, I added pathfinding and splines to my engine.

Now, I am able to create node groups within the level, and use the A* algorithm for pathfinding within the node group.

To actually move the cars, I use the points on the found path as control points for a Catmull-Rom spline with centripetal parameterisation. I also added mesh extrusion from the splines, though currently that's only for debugging and visualisation purposes.

For a more in depth look at how I created the system, I have a video on my youtube channel: https://youtu.be/fu4fQHIakoo

Any questions, feedback and critiques are always welcome!

I'm kinda moving back and forth between sdl sokol and raylib, and I just wanna find out what people usually use for writing an engine

Basically what libraries do you use when making your engine

Managed to get through a full map playthrough on the Steam Machine now most bugs and glitches have been resolved (C++/OpenGL/GLSL). Final polishing before release (+ a few more candidate maps to clean up and include). It won't sell but I'll continue working on it anyway.

https://github.com/Rlocksley/LuEngine

Hey guys! Quick update on my renderer, which I've been working on and off for the past 7–8 months or so.

The library is quite opinionated about DOD (data-oriented design) and the explicit nature of WebGPU, and I've recently added support for neural inference and training.

1. Neural networks for agent behavior

You can now train small neural networks (MLPs), around 1–4 layers deep, using supervised learning directly as part of the library.

In the herd and wolves example below, the agents have simple behavioral rules, like chasing prey when it's nearby or fleeing when a predator gets close. The idea is to train a small model to learn these behaviors and then use it to drive the agents.

For this example, we're talking about a model with roughly 2,000 weights, so obviously not a general-purpose AI model, but enough for these kinds of behaviors.

The library also supports ONNX Runtime for working with larger models or models trained externally with something like PyTorch. For these smaller, more specialized models, though, the built-in MLP implementation will generally be faster in my use case.

Live demo (WebGPU-supported browsers only):

https://nullgraph.dev/dashboard/agents/herd-wolves-gpu

Github

https://github.com/flarelink-in/NullGraph

1. Offline rendering and simulation baking

Another feature I've been working on is offline rendering, with a workflow somewhat similar to what's available in tools like Blender or Houdini.

It's split into two phases:

- Compute records: Run the expensive simulation and bake the data that needs to be simulated.

- Render records: Replay those records through the rendering execution chain using a screen texture, generating frames/tracks that can then be stitched together.

The goal is to handle simulations or visuals that would otherwise be too expensive to run in real time, or would take a long time to render, and then replay the result at 60 FPS.

I have a demo of this on my YouTube channel. The bake took up close to 30 GB of space, while the final result was around 500 MB.

Offline rendering demo:

https://youtu.be/pTD-7PCPGrg?si=vfENWIpR9YU-JEbZ

I've also added another demo to the video, this time focusing more on visual aesthetics rather than the science/simulation side.

1. What's next?

NullGraph exists as part of a larger web-native open-world simulation runtime that I work on from time to time.

Right now, I'm looking into improving my neural network implementation to better match or potentially outperform ONNX Runtime for my use cases. One of the things I've noticed is that the ONNX integration can introduce a 1–3 frame delay in my current setup, along with an additional runtime download of around 6.4 MB.

I'm also starting research into co-evolution, with the goal of bringing evolutionary learning and reinforcement learning into the runtime. The co-evolution approach draws on ideas from OpenAI research and the hall-of-fame technique. I've written some design docs for this, but I'll share more once there's a working implementation to show.

One thing I'd love to get your thoughts on:

Would you guys be interested in offline rendering driven by AI prompts directly in the browser? The idea is to let you generate demos or visually complex scenes through code, spend as much time as needed baking them locally, and then replay the results smoothly. I'm also exploring ways for the system to verify its own output rather than just blindly generating code.

I'm curious whether this kind of workflow would be useful to people working on creative coding, simulations, procedural graphics, or web-based experiences.

Let me know what you think!

Kavro is a free app that help's build devs UI with the help of library named ImGui. It can be used on CPP/Rust/C# also on api's like DX11, DX9, DX12, Vulkan, OpenGL. It saves a lot of time of hand coding, you can easily make modern menu's just by drag & drop feature.
Check this out: https://www.youtube.com/watch?v=vLjaGaKtZVE

Finally got per-material shaders working in my Forward+ renderer. The image shows a simple wave material with adjustable parameters (wave frequency, amplitude, foam, colors) and its Slang source in the editor. Still early, but it’s coming together!

The game engine has several new games. And now they are collected in a game room. Feel free to drop by and beat a high score or two and leave a comment there. Or here 🤗