Recently, I made a post about adding non-uniform volumes into my C++/Vulkan path tracer. But I didn't really like how the clouds turned out, so I've made some improvements in that aspect and just wanted to share the progress because I think it looks a lot nicer now. I've also added atmospheric scattering, because getting the right lighting setup was really hard with just environment maps. So the background and the lighting in general look much better now. The project is fully opensource if you want to check it out: https://github.com/Zydak/Vulkan-Path-Tracer . You'll also find uncompressed images there.

Also, here's the number of samples per pixel and render times in case you're curious. I've made a lot of optimizations since the last time, so the scenes can be way more detailed and it generally just runs a lot faster, but it still chokes with multiple high density clouds.

From left to right:

- 1600 spp - 2201s
- 1600 spp - 1987s
- 1200 spp - 4139s
- 10000 spp - 1578s
- 5000 spp - 1344s
- 6500 spp - 1003s
- 5000 spp - 281s

Today i finished my thesis and decided to share the results with you. Implemented physically-based atmosphere renderer made from scratch in Vulkan supports multipple scattering, soft shadows, aerial perspective, dynamic time of day, volumetric clouds and godrays running under 1.5 ms on RTX 4080.

My collegue Konrad Reczko recently shared a weekend project he made using TypeGPU, and it's now open-source and ready to play with in the browser: https://typegpu.com/examples/#example=image-processing--monocular-light-injection

It estimates the depth of a scene by inferring the DepthArt model with custom TypeGPU kernels, then reconstructs normals based on that depth information, and uses both to relight the scene, all in the same command encoder. For more information, check out the original series of Tweets:

https://x.com/reczko_konrad/status/2089670934009413751?s=20
https://x.com/reczko_konrad/status/2090472091149648121?s=20

Made with C++ and Vulkan. The project is fully open source if you want to take a look: https://github.com/Zydak/Vulkan-Path-Tracer you'll also find uncompressed images there.

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.

Hey folks!I’m a software engineer with a background in computer graphics, and we recently launched Shader Academy — a platform to learn shader programming by solving bite-sized, hands-on challenges.

🧠 What it offers:

• ~50 exercises covering 2D, 3D, animation, and more

• Live GLSL editor with real-time preview

• Visual feedback & similarity score to guide you

• Hints, solutions, and learning material per exercise

• Free to use — no signup required

Think of it like Leetcode for shaders — but much more visual and fun.

If you're into graphics, WebGL, or just want to get better at writing shaders, I'd love for you to give it a try and let me know what you think!

👉 https://shaderacademy.com

Thank you for your support! I hope you enjoy rasterization!

Previously, "From Zero to Understanding Ray Tracing":

Part 1: https://www.reddit.com/r/GraphicsProgramming/comments/1uxpi1o/from_zero_to_understanding_ray_tracing/

Part 2: https://www.reddit.com/r/GraphicsProgramming/comments/1wsr77r/from_zero_to_understanding_ray_tracing_part_2/

Part 3: https://www.reddit.com/r/GraphicsProgramming/comments/1wurqmt/from_zero_to_understanding_ray_tracing_part_3/

Let me know what you think!

original by Toni Macaroni here

He said he gets a average of 130 FPS , aerial views = 200 fps, dense forest = 80 fps

he has been working on this engine for 8 months (pretty much all of it is handwritten)

Architecture:

• CLODs (virtual geometry) with voxels for far representations (no impostors are used here).

• Screenspace + Voxel hybrid GI (no raytracing).

• Proxies without instance data for very far away representations.

alright i know this could be “simple” BUT this my first graphics engine (in progress), and i know I could’ve done this very very fast with any AI in 10 minutes, but thats not the point…

i started 2 years ago with falling sand simulators using grids BUT everything was laggy because i was rendering and simulating on cpu.

so i started to do some research on how to render things and simulate things, bla bla bla, i found opengl but i was on mac, so started to look into Metal graphics API, and didn’t understand the simplest and basic “hello triangle” projects sooo…

wanted to learn everything from scratch so i started to read “Mathematics for 3D Game Programming and Computer Graphics” by Eric Lengyel (very good book), watched like 50 tutorials of “hello triangle” step by steps, studied how the rendering pipeline works, understood how vertex and fragment shaders work, made a couple cpu renderers on c and c++ using SDL, and after a lot of failed attempts, I finally could make a 3d gpu renderer that renders multiple objects on screen and have a proper scene/camera system :’)

thank you if you are reading this, i will keep working on my graphics engine and adding some physics to simulate stuff.

ps: i studied cs but cs degree doesn’t prepare you for this lol so it feels like starting from zero on gpu programming.

It's written in Java (as I didn't know C++ well enough back then...)

It supports:

• Rasterization of lines & triangles

• Programmable shaders

• Phong lighting (point, directional, spotlights)

• Backface culling, Z-buffering, clipping, frustum culling

• Textures with filtering + cube maps

• Blending

Stress testing my path tracer's capability to handle dynamic objects. For this test, 100k cube instances are dynamically moved each frame, requiring frequent TLAS updates. Typically, TLAS updates can be split into refit and rebuild. In this test, only refitting results in severe tracing performance degradation, which is why the tlas is rebuilt after ~2s of refitting.

10k of the cube instance are assigned a emissive material. The path tracer uses a light tree to improve NEE, and this helps especially in a scene like this. As the light tree is CPU-built, it's not feasable to update it in the main thread as it takes ~0.1-0.5s per TLAS build. Currently, the engine uses a thread pool to update the TLAS and potentially BLASes (in case of instance specific brightness changes or startup build).

Compared to my previous posts, i tested this on a 4060 laptop, which is roughly 10x slower than a 5090. To keep the framerate above 30 fps, DLSS RR quality preset and 2x frame gen are used.

If you are interested to test it out yourself, check out https://github.com/ML200/RoyalTracer-DX

Play Skydreams: https://killedbyapixel.github.io/TinyCode/1K/Skydreams
Official 1024 byte entry: https://js1024.fun/demos/2026/25/bar
My size code demos: https://github.com/KilledByAPixel/TinyCode

An endless race in the sky inspired by 90's 3D games like sky roads, marble madness, and sonic 3d. My goal was to create a dreamlike experience with full resolution full speed graphics that would be easy to pick up and play.

Having worked on much more complex stuff, it's a lot of fun to start a new project from scratch and make an tiny 3D rendering system. There are a lot of fun challenges trying to fit something in this small of a space that looks cool and runs well. The contest goes until July 19, plenty of time to make something, and there's even a WebGL category.

Features
- 3D level rendering system
- 3D player sphere with shadow
- colorful sky gradient with stars
- procedurally generated levels
- level increases in difficulty over time
- mouse controls
- enhanced version has keyboard and touch input

this is the entire html file. it needs to be RegPacked to fit in 1024k but that will not post into reddit...

<head><title>🌈☁️ Skydreams</title></head>
<body id=b style=margin:0>
<canvas id=a>
<script>
    // JS1024 shim
    a.width = innerWidth;
    a.height = innerHeight;
    c = a.getContext`2d`;
</script>
<script>z=A=B=C=D=E=0,F=H=3,I=a.width/2,J=[],K=(e,h,a,t=1)=>{c.fillStyle=`hsl(${e},${h}%,${a}%,${t})`},L=(e,h,t)=>[a.width/2+(e-z+(t-3)**2/50*Math.cos((B+t)/49))*a.height*.7/t,a.height/2-(h-2+t*t/50)*a.height*.7/t,.7*a.height/t];onmousemove=e=>I=e.x,onmousedown=e=>E=.1,onmouseup=e=>E=0,setInterval(e=>{for(e=500;e--;)K(170+e/9+B,70,70-e/10),c.fillRect(0,a.height*e/500,a.width,a.height/250),K(0,0,99),c.fillRect((e*e+B*e/20)%a.width,e**3.3%a.height,e%4*a.height/500,e%4*a.height/500);for(g=B+40|0;g>B;g--){for(e=J.length;e<=g;)for(D<-8&Math.random()<Math.min(.2,e/1e4)&&(D=2+Math.min(4,e/400)),Math.random()<.1&&(H=2+3*Math.random()|0,F=Math.max(0,Math.min(7-H,F-2+5*Math.random()|0))),D--,J[e++]=k=[],f=7;f--;)k[f]=e<40|.9<Math.random()|D<0&F<=f&f<F+H&Math.random()>Math.min(.2,B/1e4);for(f=2;f--;)for(e=7;e--;)J[g][e]&&([p,q]=L(e-3.5,0,g-B),[r,u]=L(e-2.5,0,g-B),[v,w]=L(e-3.5,0,g-B+1),[x,y]=L(e-2.5,0,g-B+1),f?(K(99+70*(g>>7),70,30+9*(g+e&1)),c.fillRect(v,w,x-v,(40-g+B)/30*a.height)):(K(99+70*(g>>7),70,9+5*(g+e&1)),c.fillRect(p,q,r-p,(40-g+B)/30*a.height),K(99+70*(g>>7),70,60+30*(g+e&1)),c.lineTo(p,q),c.lineTo(r,u),c.lineTo(x,y),c.lineTo(v,w),c.beginPath(c.fill())))}for(0<=A&J[B+3|0][Math.round(z+3)]&&(K(0,0,0,.5),[m,n,l]=L(z,0,3),c.ellipse(m,n,l/4,l/9,0,0,9),c.beginPath(c.fill())),e=99;e--;)K(B/9-e,90,99-.7*e),[m,n,l]=L(z+.1-e/1e3,A+.35-e/1e3,3),c.ellipse(m,n,e*l/300,e*l/300,0,0,9),c.beginPath(c.fill());-4<A&&(z+=I/a.width/2-.25,A+=C-=.006,B+=Math.min(.5,.2+B/5e3),A<0&-.3<A&J[B+3|0][Math.round(z+3)])&&(A=C=E)},16)</script>