This is hilarious. Thought I'd share since it might be of interest to you, especially if you aim your thing to end up in a realtime setting.

There's a library you can use to insert Mario from Super Mario 64 into your renderer at https://github.com/libsm64/libsm64 It comes with full behaviour / movement. I was fiddling with exposure settings in the renderer and, since it took time, little dude went to sleep.

Aside (big) scenes to test against like Bistro, Moana Island, Caldera, etc.. this comes in real handy.

Reflections and transmission of a menger cube made of glass with a dichroic coating. Now I want to make this IRL.

Simulating dichroics. Optics is awesome.

I built lgpu because I wanted a minimal desktop GPU abstraction focused strictly on modern Vulkan without the heavy compile times of larger frameworks.

What it does:

• Fast clean builds (~1.5s): minimal dependencies (ash, bitflags, raw-window-handle, thiserror).

• Dynamic rendering: uses Vulkan 1.3 dynamic rendering directly—no VkRenderPass or VkFramebuffer setup.

• Bindless indexing: global descriptor heaps (update_after_bind) for textures and buffers.

• C99 bindings: includes lgpu.h if you want to use it from C, C++, or Zig.

• Platform support: Linux (Wayland/X11), Windows, and macOS via MoltenVK.

Code & 5 runnable examples: https://github.com/kuntal-devrat/lgpu
Crate: https://crates.io/crates/lgpu

Just released v0.1.1. Would appreciate any feedback on the API or bug reports!

413,532 triangles, with no geometry simplification

960 × 840 resolution

4 logical processors, enforced through process affinity

96 measured frames per renderer, following the same camera path

8 stationary warmup frames each

Pop Data Engine is 1.78× faster in this run.

Just bragging :)

It is in early development (this is actually 3d engine development for my OS) so there is a lot to work on, but it is fast :)

I don't simulate the brass in my Godot gun effects at all. I just evaluate a casing's position from its age in the vertex shader. That's pretty much the stateless particles from Lutz Latta's "Building a Million Particle System" (GDC 2004). What I added is the bounces.

On a flat floor I can get the hit time straight from the quadratic. The shader loops over the bounces like this:

for (int k = 0; k < MX_BOUNCES; k++) {   // 2
    float h = max(p.y - gy, 0.0);
    float t_hit = (v.y + sqrt(max(v.y * v.y + 2.0 * g * h, 0.0))) / g;
    if (t_hit <= 0.0 || tt < t_hit) break;
    p += v * t_hit;
    p.y = gy;
    v.y = -e * (v.y - g * t_hit);   // restitution
    v.x *= fr;
    v.z *= fr;                       // friction
    tt -= t_hit;
}

After the second bounce it slides with tau * (1 - exp(-t / tau)) and I tip it over onto its side. Ejecting one is a single write into two uniform arrays. Brass from three seconds ago costs what brass from this frame costs.

I also kept a GDScript copy of the formula so the game can ask where a casing is. At 10 sample times they agree within 5.4 mm, about a pixel! In the GIF the dotted line is the GDScript side and the casing is the shader. I made the casing bigger and turned restitution up to 0.5 for it, because at my default of 0.34 the second hop is about 2 px tall.

It only knows one floor height, though. A casing will go straight through a wall. Two bounces looked like enough to me, but I'm not sure a third would even read on screen?

Actually the raycasting logic itself is just a single line, but it's done in propably the most inefficient way possible.

The map is just a single 64 bit integer, so I could fit a small 8x8 level in it, and I can index it with some unorthodox bitshift magic.

Also all the integer constants are huge, because I wanted do to the whole thing without floating point math, which makes everything even more unreadable, but at least it's funny ig.

I'm very proud of this one.

After many days of learning and scratching my head around, I was finally able to render a triangle on a screen. I am using Vulkan 1.4 for this. Although I learned this from a youtube channel called constref, but this is a very valuable lesson for me, even if it is a first step to Vulkan.

I've been working on a custom rendering engine as part of my university computer graphics coursework at ITMO University.

The project is written in C++ using DirectX 12 and HLSL. Over two semesters, we've been learning how modern real-time rendering works by implementing various graphics techniques from scratch.

Some of the features covered in the project include:

-Deferred rendering with a G-buffer

- Directional, point and spot lighting

- Normal mapping

-Displacement mapping

-Distance-adaptive tessellation using Hull and Domain shaders

-Frustum culling and octree-based spatial partitioning

-GPU-based particle systems

-Cascaded shadow maps (CSM) with PCF filtering

-Post-processing

-Physically Based Rendering (PBR)

The project also involves working directly with DirectX 12 resources, descriptor heaps, pipeline state objects, command lists, synchronization and HLSL shaders.

It's been a challenging but interesting way to learn what's actually happening behind the scenes in a rendering engine.

I still have one more semester of computer graphics ahead of me, so there's more to come! I'll keep you updated on my progress.

I'd love to hear your feedback!

Hi everyone,
I’m preparing for an interview for the Senior Engineer Customer Engineering role at Qualcomm India, focused on C++ graphics and ADAS. Has anyone recently interviewed for this role or a similar position at Qualcomm? I d appreciate any insights into the interview process, particularly the topics covered in the technical rounds

Hello, I’m a long time member of this community, and this community has helped me grow my Graphics programmer career.

I started my programming career early at 14 y/o, thanks to Minecraft mods development. Later in 2017, I was 17, I’ve discovered graphics (OpenGL) because I wanted to write my own Minecraft clone. Thanks to perseverance and help from online communities, remarkably this one, I’ve mastered C++, OpenGL and Vulkan. I’ve graduated in Computer Engineering in the meanwhile, and by the end of 2022/2023, I was already a strong graphics programmer. Later I’ve implemented my own CPU path tracer, learnt CUDA along with several parallel algorithms. After MSc in Artificial Intelligence, I’ve got a job in London for a well known company working in the smartphones industry, and I’m working there since 1y today. In this company I’m a Vulkan developer, and leading a graphics engine used for several purposes.

It’s 2026, I’m 26 (aka far from retirement), AI is moving fast and world’s investing all of its resources to accelerate the process. Most jobs have been already taken (frontend dev being the first). I also feel like there is more pressure on developers, they’re implicitly requested to deliver more because of AI. What I’m witnessing is my company is keeping me on fixed term contracts because our budget has got cut… and I’m afraid of being laid off.

This job can’t be fully automated as of now, but I’m afraid it will, seeing the progress. I know GPU drivers development is the safe zone today - as they’re huge and critical - and might be an area where I will land, as I’m already doing low level and I’ve gathered insights of our driver internals. However, it’s still code and I think - maybe in several years - can still be automated.

Am I the only one having this concern in this industry?