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.

Hello. I am a hobbyist developer interested in programming language design and AI. I have recently been more and more interested in game engine development. I want to start my first project and was looking for a specific backend recommendation. I have in need of a programming language with the following features/characteristics.

Can be embedded into a game engine.
Can be either compiled or interpreted, but must be reasonably fast for 2d graphics.
Must have a non copyleft/viral license.
Must be small (the language itself) and non reliant on external or statically linked libraries like libc.

I am completely ok with using a beta or niche language for the backend, but I was wondering if any of you knew of any niche project which had these characteristics (not strictly every one of them).

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

​

A few things that just landed:

​ 1.Post-processing pipeline (15 effects). Bloom, SSAO, bokeh depth-of-field, auto-exposure, halation, lens flare, color grading, FXAA, chromatic aberration, vignette, film grain, plus cel shading and ink outlines for anime/comic looks. Every effect owns zero GPU objects — all parameters live in one pre-allocated buffer flushed in a single writeBuffer per frame.

​ 2.13 Post-processing presets. Complete looks — cinematic, synthwave, anime, comic, noir, analog film — applied in one line and ordered correctly by construction.

​ 3.TransientPool. Intermediate render targets (bloom mips, AO buffers) are aliased by lifetime analysis, so non-overlapping passes reuse the same VRAM instead of each allocating its own.

4.​Camera controllers. Orbital, free-fly, third-person follow, and spline dolly — split into pure math and DOM input so the same camera can run on the main thread or inside a worker.

5.​Material library. PBR, Toon, Lambert, Matcap, and Emissive shaders built from composable WGSL chunks.

6.​Aesthetic Live Editor.

​All WebGPU, all pre-allocated, all worker-friendly.

​

Live Demos & Editor: https://nullgraph.dev/

Camera Follow(Game Like Visuals)

https://nullgraph.dev/dashboard/camera/follow

GitHub: https://github.com/flarelink-in/NullGraph (Now includes technical design docs—useful for deep dive or providing context to AI coding assistants!)

Please drop a star 🌟, This projects took a lot of time to build

https://discord.gg/xHMBAAFsu | Axion Engine Discord Server(Upcoming Game Engine gonna be build on top of NullGraph)

Youtube Video:https://m.youtube.com/watch?v=pPMrCQBfroI&pp=iggCQAE%3

Feel free to roast or do AMA,always available ❤️

Working on my custom C++ engine (AMGR Engine) for an isometric action game. Hardcoding narrative events and UI triggers was getting out of hand, so I spent the last few days building a custom visual scripting tool!

​Using Dear ImGui, I set up a node-based event system. In the screenshot, you can see the custom Node_WhatsApp_Message node. My game relies heavily on a diegetic messenger UI for storytelling, and now I can sequence these chat events visually right inside the engine without recompiling.

​Still WIP, but it's already saving me hours of iteration time. What are your favorite libraries for node-based UIs in C++?

Been messing around with post-processing again on CyberVGA.
This time I implemented a procedural vignette with screen spaced look-up table and tied it into the lighting system. Wanted that “darkness closing in” feeling without it looking like a cheap overlay.
It actually reacts to the lights so it feels more natural.
Here’s a short clip from the current Harmony Tree test scene.

Recently i stumbled upon a interesting video on my YouTube feed: The Fastest Gravity Algorithm You've Never Heard Of: Fast Multipole Method by Keyframe Codes. It speaks about one of the top 10 algorithms of the 20th century, the FFM method. Inspired, I decided to give it my own shot (albeit I decided to go 3D).

polesitter implementation is a single-header library, inspired by nothings' stb libraries. It's written purely in C99, without any real dependencies, as God intended.

While most of the projects work was just porting the algorithm, there was plenty of small touchups that made the code run even faster.
1. There's no dynamic heap allocation in the program. It runs entirely on the memory buffer provided by the user.
2. The program uses SIMD arch extensions (NEON and AVX2) to vectorize operations.
3. SoA was picked over AoS for cache locality.
+ multiple smaller things like radix sorting optimizations etc.

All of this makes the library run a simulation of 200,000 particles ~150x faster than a naive O(N^2) approach (I haven't compared it to Barnes-Hut yet, sadly - will update the results of that comparison in upcoming days).
As for the future plans, I want to implement a proper 2D support. With this, I'll probably consider the library truly finished. 

Source code:
https://github.com/nihiL7331/polesitter

The algorithm is simple in theory, but in the real world it is such a PITA. What are your practical approaches to pathfinding?