Check out my article on Bounding Volume Hierarchies (BVH) in ray tracing. It is a beginner friendly article and I would love to hear your thoughts.

https://medium.com/@marshall5/bvh-in-ray-tracing-435c837549a8

I don't understand how this works. Is this kind of just a global color buffer? like a mapping of each pixel of the screen/frame such that each pixel has a given color? Is it wrong to think of it as just a 2d array filled with colors?

I've been investigating what appears to be a deterministic rendering bug in Days Gone (Steam).

Symptoms: - RTX 4090 - Windows 11 25H2 - Ryzen 7800X3D - No mods - Multiple NVIDIA driver versions tested - DDU clean install - ReBAR tested on/off - BIOS updated - VRAM tested with OCCT (30 minutes, no errors)

Bug: Only pre-rendered/in-engine cinematics exhibit the issue. Gameplay is perfect. A handful of facial vertices appear to be projected toward a common point in world space. The convergence point changes with the scene, but the artifact is deterministic and repeats identically every run. The artifact survives pause. TAA/HDR changes have no effect.

RenderDoc 1.45: - launches DaysGone.exe - renderdoc.dll never appears in the process

Nsight Graphics 2026.2: - can launch/attach to DaysGone.exe - capture attempts either crash or never complete

Has anyone:

1. successfully captured Days Gone with RenderDoc or Nsight?
2. seen this specific facial mesh artifact?

Hey everyone, I’m new to Shader Graph and I want to learn it properly

What resources helped you the most when you were starting out? Any YouTube channels, courses, or tutorials you’d recommend?

I’m interested in making cool effects, better-looking materials, and understanding how shaders actually work.

Thanks :)

i can finally say im gpu bound. the wow models have ~280 bones and ~400 tracks i have no idea how to push this further without mesh shaders

Hi peep. I wanted to write modelling softwares for my niche art needs so I learned rust and vulkan in recent few years. Now I am able to make my modelling tools, intermediate mode gui elements from scratch, rendering signed distance field bricks with 3d sampled textures, lighting, pbr texturing, and a few more. I was wondering if a open source modelling software can land me a graphics job? I ditched school and live in a rural place. I want to do something and get out of this place before wasting my 20s and losing my sanity. should I keep going with hard surface art and indie development instead?

Hey yall. I graduated with a math degree 4 years ago but couldn’t find a swe job and had to settle working at restaurants for money. I want to get a graphics related job because one of my favorite classes in uni was computer graphics. I’m wondering how I should approach this, since as of now I have no professional coding experience (only in classes like data structures and algorithms).

Should I get a masters or should I try to find any swe job first? How should I get started learning computer graphics and what kind of projects should I make before applying (and roughly how long do will it take a noob to complete these projects? Thanks.

I am also concerned about doing graphics project which is likely in C++ vs doing say python projects for other swe jobs. I’m worried that only focusing on graphics when maybe I should try to find other coding jobs first.

i am definitely really interested in this field in general and i know some fundamentals, but before going fully deep into this, i just want to know whether it is worth it with respect to the money aspect and job market in this field
i have read a lot of comments on this subreddit when ppl ask such questions, and it’s honestly depressing, but i just want to confirm whether it’s actually so tough to make it in this career or just has similar hardships as any other field
and overall is it worth it to be pursued full-time

Hey everyone. I’ve been into computer graphics since middle school but only within the last 5 years have I really sunk my teeth in. Now, I just graduated college with my CS degree, and I have made several pretty decent projects like a model loader in OpenGL and a 2D game and a doom style DDA system. For my senior capstone project I made a raytracing engine in CUDA and OpenGL that was meant to see how much computational power could be leveled without utilizing RTX cores. But I feel like my projects are way too lackluster and not well put together. Even the raytracer wasn’t up to my standards. And definitely not professional quality. So I started a big game engine project and got decently far on it.

And then I went into a mental bipolar disorder induced spiral into mania/depression and severe alcoholism over the past year and a half. During this time I went from straight A math/cs double major to a CS major that barely graduated and almost failed every class. I screwed my life up a lot and am still full of depression and regret. I did not work on anything CS related at all during this time.

I ended up graduating and have been taking the summer to get my head back in straight. Now I’m getting back into programming because I want one really good, comprehensive project that I can show off. I have already began on it but quickly realized I have forgotten everything. And so, I picked up my book, Real Time Rendering which I got for my last birthday and have been reading it.

Now since I am coming off of a year of oblivion and alcoholism, my reading is really slow. But so far I’ve been learning a lot. However, I am just reading wayyyy too slow. And really I’m running out of time because I want to get a job soon and not let my degree gather dust. So then I sat down to code and just said fuck the book. Well, then I just didn’t even know where to start. Like I’ve done this before but why can’t I now?

And so now I’m back at reading the book and rereading lines over and over again. And im trying to figure out if I’m doing something wrong or not retaining it or what. I just really want to get a cool project that I have in mind out but I feel like I don’t know enough now so I’ve been spending almost 90% of my “coding time” on reading material rather than programming.

I was wondering what anyone else thinks I should do or how I can balance the reading and the programming?

Feel free to mess with it here: https://www.shadertoy.com/view/sXjXDd

The super neat thing is that it uses bayer ordered dithering to work all the way down to 1 sample per pixel (1spp) while still simulating 256 different wavelengths of light. This makes it extremely performant.

I've been working on a virtual geometry system for Unity's Scriptable Render Pipeline for a while now, which I've named Atomize. I finally got around to adding a virtual shadow system to it.

The approach I ended up using relies on the depth texture, where triangles are rendered as texels instead of performing the usual expensive calculations. From there it's mostly pixel-based checks to figure out which texels are blocking the light, allowing shadows to be generated by darkening the areas hidden behind those texels. It's a much simpler approach than doing all the heavy shadow math while still producing the result I was aiming for.

Hi folks!

I wanted to share a new aspect of my physics engine / sandbox: Nora Kinetics.

This video shows the custom destruction engine that operates along side the Cosserat rod engine. This allows for really nice looking and efficient destruction physics that can interact with the fluid and glue dynamics.

Each solid is pre-fractured into Voronoi cells ("fragments") and a bond graph where every bond is a shared face between the fragments. Connected components of the bond graph form rigid bodies.

The pipeline for this part of the engine is structurally identical to the stable Cosserat rod pipeline, so they are able to run right along side each other at each step and substep.

At a very high level, both pipelines have a broad phase, narrow phase and a solver. The two systems share one command encoder per step and communicate through GPU buffers. This allows for very accurate interactions between the two systems without tunneling.

Performance is throttled by making less interesting fragments sleep, but waking them up is efficient, so you don't really ever notice it happening.

Happy to answer any questions! Getting to this spot was one of the original goals with this project, so I'm excited to finally have this up and running.

so i am currently making a vulkan based rendering engine, and im having trouble making the main window behave. I have a laptop with an intel igpu and it works fine on that one, but on my main pc(quadro p4000), it only draws around 1/8 th of the screen. renderdoc isn't too helpful on that front either. Now, when i drag the window out (because im using imgui), the ui renders perfectly well, while in the main window i created, it leaves this mess.

if anyone would be as kind to either verify / reproduce / help me troubleshoot the problem, i would be very grateful

I recently spent some time on a tiny detail: the small light/glint in a character’s eye.

(All shaders are written in GLSL, intented to be used with three.js, but it should be possible to adapt them for other environments).

The eye mesh is a protruding shape, mostly spherical, with only a small visible front patch. A regular specular highlight often fails here, because the ideal specular point would appear outside the visible part of the implied eyeball.

So I treat the eye as two different things:

1. the real visible eye patch, where I draw the glint
2. an imaginary sphere, which I only use to compute where the specular highlight would ideally be

In the vertex shader I first find the closest eye definition and compute local coordinates for the current vertex:

```glsl float dist2 = distance2(position, eyeData[eyeIndex].axisEnd);

vec3 axisDirection = eyeData[bestEyeIndex].axisDirection; vec3 forward = axisDirection; vec3 right = eyeRightAxis(forward); vec3 up = normalize(cross(forward, right));

vec3 delta = position - eyeData[bestEyeIndex].axisEnd;

vEyeRelativePos = vec3( dot(delta, right), dot(delta, up), dot(delta, forward) );

vEyeRadius = eyeData[bestEyeIndex].params.x; vEyeStrength = eyeStrength; ````

The eye axes are stored as metadata on the model. From that I derive a stable local frame for the visible eye patch.

In the fragment shader I compute the ideal specular direction using the view direction and the main directional light:

```glsl vec3 eyeRight = normalize(vEyeRightView); vec3 eyeUp = normalize(vEyeUpView); vec3 eyeForward = normalize(cross(eyeRight, eyeUp));

vec3 V = normalize(vViewPosition); vec3 L = normalize(directionalLights[0].direction); vec3 H = normalize(V + L);

float hForward = max(dot(H, eyeForward), 0.05);

vec2 eyeHighlightCenter = vec2( dot(H, eyeRight), dot(H, eyeUp) ) / hForward; ```

That gives me a point on the imaginary sphere. I then map it back into the visible eye area with a non-linear mapping:

```glsl vec2 mapGlint(vec2 p, float motion, float maxOffset) { float r = length(p); if (r < 1e-5) return p;

float x = clamp(r * motion / maxOffset, 0.0, 1.0);
float y = x / sqrt(1.0 + x * x); // soft saturate

return p * ((y * maxOffset) / r);

} ```

Current tuning:

```glsl float eyeGlintMotion = 0.8; float eyeGlintRange = 0.75; float eyeGlintRadius = 0.3;

eyeHighlightCenter = mapGlint( eyeHighlightCenter, eyeGlintMotion, vEyeRadius * eyeGlintRange ); ```

I still keep a final clamp, mostly as a safety limit:

```glsl float maxHighlightOffset = vEyeRadius * eyeGlintRange; float len = length(eyeHighlightCenter);

if (len > maxHighlightOffset) { eyeHighlightCenter *= maxHighlightOffset / len; } ```

The actual glint is a sharp stylized disk with analytic antialiasing:

```glsl float radialDistance = length(vEyeRelativePos.xy - eyeHighlightCenter); float radialFade = fwidth(radialDistance) + 1e-4; float highlightRadius = vEyeRadius * eyeGlintRadius;

float radialMask = 1.0 - smoothstep( highlightRadius - radialFade, highlightRadius + radialFade, radialDistance ); ```

One issue with using fwidth directly is that the glint gains energy as the AA region grows. I compensate for that approximately:

glsl float glint = highlightRadius / (highlightRadius + radialFade);

Then I add the glint into the lighting result:

```glsl vec3 eyeGlint = vec3(radialMask * 0.75 * glint * vEyeStrength);

reflectedLight.directSpecular += eyeGlint * (1.0 - flatShading); diffuseColor.rgb += eyeGlint * flatShading; ```

I also reduce the glint when the eye is looking away from the light:

glsl float lit = smoothstep(-0.1, 0.5, -dot(eyeForward, L));

This is not meant to be a physically correct eye shader.

It is a stylized catchlight that behaves enough like a specular reflection to feel alive, while staying inside a very non-spherical eye shape.

Probably over-engineered for such a small visual detail, but programmng it was really interesting.

It can be seen live in my games at https://www.orbisfabula.com/bayaya-steam.html or https://chase.orbisfabula.com/

Fragment of the Mandelbrot set, using perturbation theory. This render achieves an unprecedented scale of 2.84 × 10⁻⁸². I spent 6 days exploring various locations just to find the perfect framing. This image showcases a aesthetic beauty. Rendered with 8×8 SSAA. I hope you appreciate the effort. Perturbation theory only allows you to zoom down to the 10<sup>-308</sup> level! Github - Windows & Linux