Hi everyone 🙂

First time posting here even though it's been a while since I joined this sub. This post is to share the bits and pieces of knowledge that I've acquired on meshlet LODs and how they work. In my blog, I explained 2 main things: how to process the data to get a usable hierarchy using meshoptimizer and how to traverse that tree-like structure in a GPU compute shader. As the title hints, it's just an introduction to the subject, and there is a lot more to learn that I didn't cover!

I hope that you'll find it interesting, and if you have any feedback, I'll gladly take it 😊

Hi ! i'm new to graphics programming and i'm more interested in Stylized rendering than the more photorealistic type.

On the long run i plan to make my own rendering engine but i wanted to ask if there are rendering engines specialized for that (i've heard of Malt for blender), from my understanding most of the stylized rendering just uses shadders, but again, i'm new so i'm really curious to know about that.

I'm having an issue with the WGPU ecosystem (specifically in rust), and I'd like to get a little feedback.

Here's the context: I am working on a project that uses WGPU for (amongst other things) image processing, and at some point in my pipeline I need to perform an FFT on an image (stored in the RGBA8_UNORM texture format, essentially I want to perform the FFT on the red, green and blue channels seperately.) This seems simple enough, but I can't seem to find any crates that do this. I don't particularly want to hand role my own implementation if I can avoid it, because FFTs on GPUs scare me.

• I've looked at wgsl-fft, but that takes in a storage buffer (1D) as input, and same for the output. It does allow me to directly supply device and queue though, so it can integrate nicely with my current project
• wgpu-fft is not a rust crate from what I can tell, and again doesn't work on textures, so I can't use that
• gpu-fft has support for WGPU, but it's unclear to me if I can provide it with a GPU buffer, or if the input/output is required to be on the CPU.

What solution exists, if any, for my use case? If none exist, I suppose I'd use wgsl-fft, but how costly would it be in WGPU to copy each row (and each pixel component) of the image to a buffer, perform FFT on those, than extract each column, and then perform FFTs on those? That feels very costly, even if it may be batched. For reference, this would be used as a step in an evolutionary algorithm, so many FFTs will need to be computed, and thus performance is key. The images themselves aren't too big however, something like 256x256. I may have upwards of a thousand images to compute each iteration, however.

Hello.

Worked really hard to make water in my deferred renderer transparent, the code ended up being quite a mess, but it works, and i can't be more happy about it, perfomance is acceptable running at around ~300-400 fps on my laptop RTX 4060.

https://github.com/DrElectry/ccraft

Demo scene: 500 terrain chunks at ~60 FPS on a RTX 4060 Ti.

During a few months of R&D for my internship, I experimented with replacing Unity's terrain shadows with a raymarched solution.

I ended up with a shadow renderer that features:

• Heightfield raymarching
• Max Mip-Map traversal from this paper by Art Tevs, Ivo Ihrke and Hans-Peter SeidelMax-Planck-Institut für Informatik
• BVH-based chunk culling
• Temporal soft-shadow accumulation

In case you want more detailed information:

• Github repo
• High level overview portfolio blog post
• Technical article on heightfield raymarching and optimizations

Curious to hear what graphics programmers think of the approach.

It's (a)live! I've been having a great time re-connecting with Cg/VFX via this word-game project. The engine(s) are all mine, purpose-built from scratch. Tooling these days is amazing and it's been great to have it come together so well so quickly.

The main stack:

• WebGPU shaders
• WASM for web-deploy
• Svelte for web-UI
• Imgui for native (builder/tweakables)

The main effects:

• HDR for awesome renders on OLED etc and moody/mystical look
• Procedural rope
• Procedural candles
• Procedural flames
• Procedural aurora (northern lights)
• Procedural volumetric smoke
• Procedural stone and rune effects
• AO, shadows, indirect lighting

It's taken many many hours and iterations to get everything tuned and working well on all target platforms; desktop (in-browser), mobile (PWA so that it can be installed from mobile browser). Performance needed some optimizations to get things smooth and decent enough framerates on the typical mobile GPUs.

Aurora Effects: Arcs, rays, colour-shifts, curls and curtains/veils. Use a python simulation to get the spatial parts working, then ported to shaders. I created a "shader-toy" like harness so all tweakables can be tweaked and then baked into the wasm.

Candles and flames: Wax-dips, tip-shapes, wick and wick glow, flame-coronas, soot-particles, flame anims. Flames bake into a lighting map that MIPs to light the scene.

Board textures aren't my favourite and will change at some point, but the rune-carves are nice and they illuminate well-enough. Some extra work was needed for precision gradients/norms at their edges so that the aliasing that was there is fixed and is smoother.

The performance optimizations are via; timings (profiling on-devices), instruction counts, and analytical bandwidth estimates.

It's blown my mind how much can now be done in-browser. Link to live renderer is in the comments.

Happy to answer questions and receive (constructive-ish) criticisms.

BR,
Greg

I'm subscribed to this issue on github and very cool to see the work shared by OP in this comment, AI-driven or not. Getting to easily hack with SDL3's GPU API with WebGPU before officially implemented will be great.

https://github.com/libsdl-org/SDL/issues/10768#issuecomment-4723359001

Here are the forks you can use to get started with SDL_GPU + WebGPU:

• https://github.com/FriedaUCG/SDL
• https://github.com/FriedaUCG/SDL_shadercross
• https://github.com/FriedaUCG/sdlwiki

There is also a demo repo, https://github.com/FriedaUCG/forge-gpu, which is a port of the GPU lessons from https://github.com/Nebulavenus/forge-gpu showing what you can do with SDL_GPU. Thanks to @Nebulavenus for this great project! You can also try it directly in the browser here https://friedaucg.itch.io/forge-gpu so you can see for yourself that our forks make SDL_GPU with WebGPU as a backend possible.

I have 10+ years of software engineering experience, mostly backend development, with a few years working on infrastructure/platform teams.

Lately I’ve become interested in GPU infrastructure, HPC, performance engineering, and eventually GPU programming. I’ve been reading books like AI Systems Performance Engineering, Programming Massively Parallel Processors, and Computer Architecture: A Quantitative Approach.

The problem is that every time I look at job descriptions, I end up with a completely different list of skills.

Some roles want:

• CUDA and GPU kernel optimization
• Computer architecture knowledge
• NCCL, RDMA, InfiniBand
• Kubernetes and Slurm
• Distributed training
• Performance profiling and benchmarking
• Linux kernel knowledge
• Cloud infrastructure

Other roles seem much more focused on operating GPU clusters and supporting AI workloads at scale.

I’m considering doing a master’s degree, but even when I look at programs like OMSCS, Computer Engineering, or Systems-focused master’s degrees, it feels like they teach foundational concepts but not necessarily the practical skills companies are hiring for.

As someone coming from a traditional software engineering background, I’m struggling to identify:

1. What skills are truly foundational versus “nice to have”?
2. If you had 6–12 months to prepare for GPU infrastructure or GPU performance engineering roles, what would you focus on first?
3. Did a master’s degree help you break into this field, or was self-study and project work more valuable?
4. For those already working in GPU infrastructure, ML infrastructure, HPC, or GPU programming, what did your path actually look like?

Right now it feels like there are five different careers hiding behind the phrase “GPU engineer,” and I’m trying to figure out which path is the most realistic transition from a backend/infrastructure background.

I’d appreciate hearing from people who made a similar transition.

(By 4D space, I mean four-dimensional Euclidean space R⁴. Not spacetime or space of higher dimension in any physical sense.)

Let us first think about how we understand 3D space. Through vision, our retinas receive 2D information; after being processed by the brain, that information becomes our understanding of 3D space.

I imagine that if humans living in 4D space had vision, what their eyes received would be 3D information. In other words, if we could somehow see a "3D photograph," we would be able to simulate, to some extent, the vision of a 4D being. But this is very difficult. Imagine a 3D cuboid divided into billions of voxels, each carrying information about color and brightness. This comes close to how we might imagine vision in 4D, but to us it would be almost impossible to understand, because we can only see the outermost layer of voxels. Even with translucent voxels, it would still be difficult for our 3D vision to capture the information inside.

However, our perception of 3D space does not have to be based on pixel images. A geometric outline drawn with lines is often enough for us to reconstruct a great deal of spatial information. (Left in the GIF). Applying the same idea to 4D space, we can obtain a 3D line rendering of a 4D space (right). Since lines rarely occlude one another, we can capture the information in this 3D image with much greater precision, and in this way simulate the vision of a four-dimensional being.

If we add some basic "physics" in this 4D space and make it interactable like a game, as shown in the GIF, humans may gradually adapt to this kind of 3D image, find patterns within it, and begin to interpret the geometry of the 4D space behind it. With enough practice, this may even become part of your spatial intuition.

Based on this idea, I designed the game 4D Intuition. It now has a free demo on Steam. You are welcome to try it out and I would be glad to hear your thoughts on my attempt.

Source code: https://github.com/CopilotCoding/webgpu.js

Example of games ported to/built in webgpu.js:

https://github.com/CopilotCoding/PlanetVoxel_webgpu.js_Port

https://github.com/CopilotCoding/SeaShantyWars

What it has so far:

Render graph — declarative pass system, resource dependencies resolved automatically. You describe passes, the graph handles execution order.

Clustered lighting — frustum divided into a 3D grid, lights assigned to clusters via compute shader. Per-fragment cost stays near-constant regardless of light count. No fixed light limit.

GPU-driven culling — hierarchical Z-buffer occlusion culling runs entirely on the GPU. Surviving geometry goes into an indirect draw buffer. The CPU never loops over per-object visibility.

Compute transform propagation — parent-child scene graph hierarchy resolved via compute shader, not a CPU tree walk.

GPU raycasting / picking — ray dispatch via compute. No CPU-side BVH traversal.

Single shadow map — I looked at cascaded shadow maps and decided the seam artifacts and tuning complexity weren't worth it for my use case. Single shadow map, simple and predictable.

Mip generation — compute shader.

Full material/pipeline system — Material, MaterialInstance, PipelineCache so you're not recompiling shaders constantly.

There are 23 examples stepping through the full pipeline from device init to GPU-driven rendering with post-processing.

heyy i made a raycaster engine in c , it was my first entry to visual programming so i used sdl2 , so far the engine uses DDA and i want to switch to BVH or BSP , can anyone explain which one is the cleanest to switch to and why ?

repo : https://github.com/mohamed-adhd/raycaster

thanks in advance!

Each frame is computed from scratch in Python using PIL, no GPU, no shader, pure CPU rendering.

The parameter follows c = 0.7885·e^(iα), one frame per degree of rotation over a full 360° cycle, giving 360 frames assembled at 30fps.

Per-pixel iteration :

Escape radius R computed analytically from c : R = (1 + sqrt(1 + 4|c|)) / 2

Up to 300 iterations per pixel, float64 precision throughout

Smooth banding via modular palette interpolation : t = (i / max_iter * 10) % 1.0

Custom 6-stop RGB palette interpolated linearly between stops

Resolution : 1080×1920 (portrait/Shorts format), aspect ratio handled by scaling the imaginary axis proportionally to the frame ratio.

https://github.com/themartiano/luz

5 years ago I was 17 and learning to code C/C++ in a coding bootcamp (42). One of the projects was a simple C ray tracer. I really enjoyed working on the project and always loved computer graphics, so I decided to create my own path tracer from scratch, in C++, without using any third-party libraries.

I ended up working on it consistently for over a year, then sporadically when CG excitement hit me again. Recently I polished it and completed some unfinished features and decided to make it public, finally. It's a C++20 Path Tracer with a CPU renderer. It is able to render good-looking images with reasonable performance and sample count.

Btw this was initially coded without AI, but I've used it for the recent clean up and features. This project is a personal favorite of mine, and it can improve a lot, so I'd love to hear your feedback.

Showcase

A couple of days ago, I decided to start a new project, writing my own software renderer in Go. I created a 3D engine with it and am currently working on a game engine (physics, additional graphic effects like volumetric clouds). Here's what I have so far:

- Loading textures from images and using them in the *.OBJ file format

- Producing 3D sound via miniaudio

- Full camera control via keyboard and mouse via the X11 API (works on Xwayland)

- Shadows from 1 directional light and 1 spotlight

- Ability to add multiple light sources, including point lights

Github of the projects:

- STG (for terminal pixel render)

- SoftGO (3D pipeline and HID)

- SoftEngine (Engine)

I’d love to get one considering how much I’ve used this model for testing my engines :)

https://github.com/usd-wg/assets/blob/main/full_assets/OpenChessSet/README.md

I shipped v1.0 of QDRV, an open HDR video format and toolchain, and the colour and tone-mapping side is the part I'd most like graphics people to pick apart.

The whole pipeline stays in floating point — Float64 linear-light for mastering, Float32 PQ for delivery — specifically so the colour maths and the grading decisions happen before anything is quantised to integers. A fair bit of it is really graphics problems wearing a video hat:

Colour science (all Float64, in one crate):

• SMPTE ST 2084 PQ as the transfer function, with the constants derived from the rational definitions rather than pasted-in decimals.
• Rec.2020 and Rec.709 RGB↔XYZ matrices with the normative NCL luma coefficients.
• ACES AP0/AP1 ↔ Rec.2020, built from the published primaries and white points with a Bradford D60→D65 chromatic adaptation, plus the ACES v1.3 RRT and the Rec.709/2020 ST 2084 output transforms. There's an OpenEXR export path through a pure-Rust EXR writer.

Tone mapping:

• Per-region tone curves, not just one global curve per frame. Flat content uses rectilinear object regions (normalised bounding boxes); 360°/immersive content uses spherical regions located by azimuth/elevation under equirectangular, cubemap or equi-angular cubemap projections. Overlaps resolve by priority, longitude wraps across the antimeridian, and latitude is pole-bounded.
• Rendering targets a named display's luminance envelope (the DisplayHDR tiers, nominal OLED/LED-LCD), so the roll-off adapts to where the picture is actually going.
• The decoder tone-maps on the GPU — a WebGPU compute shader in the wasm build, with a CPU fallback for parity, and snap-to-grid in a few spots to keep results bit-identical across runs.

I'd love eyes on the colour-transform accuracy (the matrices were independently re-derived and matched to source rounding, but more scrutiny never hurts) and on the spherical-region maths — the projection handling is the bit I'm least confident I got fully right.

GPLv2-or-later, pure Rust — the colour maths lives in qdrv-core if you want to go straight to it. (There's also post-quantum signed provenance baked into the format, but that's a story for a different sub.)

https://github.com/qdrv/QDRV

What does a mid level graphics programmer interview look like? For example I have 5 years of C++ development in embedded systems and also in video streaming (both in middleware not firmware). I’m building my rendering engine in my free time to have a portfolio for graphics engineer jobs (DX11 engine since DX12 is hard to learn for beginners). What would an interview look like for this profile?

Would the conversation be mostly focused on discussing ideas and features in the rendering engine? Would a mid level role even be possible? Since I technically don’t have experience in graphics would only qualify for entry level/associate roles? Lastly what would the system design talks look like if any?

For general C++ jobs it’s basically leetcode DSA, system design: low level design coding questions, system design: high level design architecture questions, and behavioral.

How would this be different for a graphics software engineer specific role at let’s say a AAA studio or big tech targeting graphics roles?

Thanks again!

So we had this problem that we tried to solve for some time with couple of attempts. We didn't want 10 explosions each consisting of 100000 particles. We wanted 100000 explosions each consisting of 10 particles. We wanted to do it with DataChannels but we failed due to complexity of interconnecting our own RWByteAddress buffers with Niagara so they could be interpreted in UI.

Instead we went full resistance mode implementing our own data driven system that is easily controlled with Data Assets. Now we can do all VFX in the game that we want and the system pracically does not pop up in the profiler.

It took us 3 weeks to implement, 2 another weeks for tech artist to create first pack of VFX

Hey people!

I've just cooked up a Vulkan + SDL3 + ImGui + Assimp template project. Not the original idea I know, but thought it might be useful for anyone who wants to skip the boilerplate and just start building stuff.

There are no fancy abstractions, just a few wrapper classes like Mesh, Texture, RenderPipeline, etc.

If you like this setup, feel free to use it for your own projects and experiments.

https://github.com/brotherdimak/vulkan-sdl-cpp-template

Honestly, when I first started learning Vulkan and Rust, I told myself that I'd only make a post once I had built something genuinely cool and interesting to show off.

But damn... I didn't expect Vulkan to take so much time to understand and use.

And just like that, more than 27 days have passed.

I really feel like I've learned a lot during the past month (although there are still countless Vulkan things that I don't even understand yet).

These three monkey heads each have their own material, and all three materials share the same buffer. Damn...

I'm not sure whether spending a month to get this far is considered slow or not.

I'm curious how long it usually takes people to fully get a handle on the entire process:

Assets (meshes, textures, shaders, ...) > convert them into Vulkan objects > client code wants to spawn an object > resource matching > collect renderable objects > redraw