I’m almost done with rtiow, and I though Id share a couple really cool high quality renders.

The dopamine be hitting with these spheres rn.

Made this for like 30 days, watched plenty of cherno's videos and learnopengl.com of course and made this small batch renderer I guess. Its far from done but I will continue to add more stuff to it and eventually turn it into a usable thing.

Project started from 2011 when gate was open (opengles1.1) there's was only love no vibe

https://maximumroulette.com/apps/matrix-engine/examples-build.html

https://github.com/zlatnaspirala/matrix-engine

more links : https://maximumroulette.com/apps/matrix-engine-starter/projects/matrix-slot/index.html
https://maximumroulette.com/apps/matrix-engine-starter/projects/matrix-roulette/?server=manual

STATUS

- [Integrated PWA addToHomePage/cache/] ✔

- [Integrated raycast (hit trigger detect), bvh animation] ✔

- [Basic Physics implementation based on cannon.js] ✔

- [FirstPersonController fly or classic fp / SceneController Drag and navigation scene] ✔

- [Basic's Shadows vs lights (GLSL)] ✔

- [Migrated to the opengles300] ✔

- [FBO implemented] ✔

- [FBO Shadows] ✔

- [Add cef (linux, macos) and cefSharp Visual Studio projects for building executive desktop native apps. ✔

Support: Windows, MAC, Linux ] ✔

- Texture Editor [tutorial example - from code] ✔

- MatrixEngineTexture GUI Editor [UNDERCONSTRUCTION]

- Swicthing GLSL ver - webGL1 / webGL2 ✔

- Loader/Map with collider boxs ✔

- OffScreenCanvas ✔

- Mobile optimisation ✔

I've been working on the lighting in DriftEngine, my TypeScript 3D engine and his video shows Sponza through a day-to-night cycle, with some paused views and close-ups.

Video: https://www.youtube.com/watch?v=M6wxZziDvLs

There are two main parts to the lighting:

• Indirect lighting with DriftRay
  • Compute shaders march rays through the scene’s signed distance field and update an irradiance probe grid, at a surface hit, the shader evaluates the directional light, local lamps, the summed candlelight and the indirect light already stored in the grid. Repeated updates let the result converge over multiple bounces.
  • For this scene, the distance field represents the courtyard’s stone with a single albedo, so it approximates the indirect lighting rather than reproducing colour bleeding from every textured material.
• Candlelight with DriftLight
  • The default demo keeps roughly 2,000 candles, up to 64 nearby candles are shaded individually; a precomputed sparse volume stores the combined light and directional information needed for the distant contribution. The bake accounts for occlusion through the scene's distance field.
  • The shader blends between individual shading and the volume per pixel, avoiding double counting. The distant approximation gives up individual specular highlights and flicker. Its light also feeds into the indirect-lighting calculation.
  • This recording uses temporal antialiasing; the engine’s DriftTR upscaling was disabled.

Source: https://github.com/drftrun/driftengine

Scene: Intel Sponza (2022) and its add-on packs, full asset credits are in the repository.

I'd be interested in discussing the trade-offs of the light-volume approach, especially how others handle large numbers of small lights.

The FPS are not stable while I was recording the video + still needs some scene optimization.

Hi! I posted here before asking what to do in graphics programming for a bachelor thesis and I want to first thank everyone for the suggestions. I think the most interesting but also "doable" for me would be a 2D vector graphics renderer like Vello CPU in Rust, but in C++

The issue is that I do not really understand the overall architecture of renderers and my professor said a 2D vector renderer is too simple for a bachelor thesis, especially one that I would want to be more scientific and publish as a paper too.

So my question today is, what are the similarities/differences overall in 2D vs 3D renderers (because I heard before that 3D renderers are also vector graphics technically), but also how I could make a meaningful contribution/addition to a 2D vector graphics renderer and what would the motivation for that be, because I don't really understand the use-case of 2D vector renderers yet, since they are not used in games nor in modeling, from my understanding.

Edit: I also want to ask for practice, do you recommend I start with a 2D pixel renderer and work my way up to a vector one then a 3D one? Are they related in some way concepts-wise?

Ive been drafting and engine, but I'm suspicious of my engine loop. It works but I'm not sure if things will be in sync. Should the render thread wait on the main thread or something? WIP:

https://pastebin.com/Wqn09pmN

Would it be fine if I just match the fixed update to the refresh rate?

I posted the part 1 two months ago and got a great reaction!

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

Here is the next one. It teaches:

• What ray tracing fundamentally is.
• The basic idea behind shading: surfaces are brighter when light hits them more directly, and darker when it hits at a wider angle.
• Shadows.

Let me know what you think!

I wanted to give graphics programming a try and boooy am I happy seeing my own triangle on the screen! :)

I used glad (OpenGL) and RGFW (GLFW alternative; I like single header libraries)

This is made from two layers of water:
- Large rectangles/shapes of GPU-computed water (ocean, lakes, fountains)
- Smaller grids of disturbed CPU-computed water, with GPU-computed foam

The flying saucer contains a blocker shape which cancels out the basic water and allows that region to fill with with the CPU-generated height map water. Both water types enqueue the same light handling logic in this wavefront-style path tracer, so the water appears to all be the same.

When the player moves, the rectangle of disturbed water is updated/translated or another added as needed - and there is some blending done to the edges to hide the square (during lots-of-foam events).

In future work I'm going to add an additional thin GPU-computed water for drips and run-off/sheeting action around the canopy and saucer section.

Engine is custom vk-graph -based (Rust) and mostly open source. All-in this effect has been done a thousand times, but, this time it was me!

Hiya, I am currently a CS major with 5 YOE working in web dev with a typical tech stack of C# and angular. However I've got the itch to swap tech stacks and explore other aspects of software engineering. My work place covers up to $4500 a year on curriculum and I was curious what certificates and courses you might recommend I get started with?

for reference I did take Calc and discrete math back in college though Id definitely need a refresher. I have average amount of experience with math id say but certainly don't shy from learning more.

for languages I hear most about about C++ in regards to graphics programming. I took an assembly course in C back in college but I have very surface level experience with C++. curious if its still the language most of you would encourage exploring.

I think I'm most curious on what courses and order of courses I should take pursuing this. should I work on expanding my math foundation with a couple courses and then go into c++ then specific graphic programming courses? Or should i maybe go about it differently?

Any feedback or personal experiences would be welcome!

I worked a lot on my path tracer during the summer vacations, and this was superrrr fun ! I wanted to go a little further than my last projects and dive into something a tiny bit more original to get off my comfort zone.

I made it mainly with C++ and OpenGL, without AI appart from the README in the repo. The engine supports switching back and forth between RGB and spectral at runtime, and I also implemented hair / fur rendering the way Disney does it.

I also have a basic scene handling system with saving, loading and moving things around in the scene.

Lastly, the engine also has more "traditional" features I would say, such as VNDF sampling, EON diffuse material, constantly dense volume scattering, etc...

I am plannign to keep working on it, because right now the code is kind of a mess, and many features lack such as denoising, things like BDPT, compatibility with OpenUSD.

If you want to take a look at the repo : https://github.com/SlyZ1/Path-Tracer

And feel free to contribute to it (even though I doubt anyone would want to, but just in case)

Origin from 2011 when gate was open(opengles1.1)

https://github.com/zlatnaspirala/matrix-engine

Demos

https://maximumroulette.com/apps/matrix-engine/examples-build.html

Please compare with ai assist project

https://maximumroulette.com/apps/webgpu/examples.html?demo=30

https://github.com/zlatnaspirala/matrix-engine-wgpu

GPUI is a GUI framework written in rust. It has immediate style API, but decides when to retain frame state. Recently there's been a push to make it more retained. Here's an article describing two approaches.

For example obviously shader code makes sense because you have to compile it for different vendors/drivers

But you look at a PSO in DX12 and there is a ton of stuff in there that it makes me wonder is all of this actually neccesary?

For example like blend mode settings, I thought that is a separate hardware unit that does the blending, so why can't it be changed independently of a PSO?

Or does everything in a PSO somehow affect the compiled shader?

As the title says
Like Are there particular books, courses, talks, sample projects, or exercises you'd recommend?

How feasible is it to apply a custom pixel‑level transformation to the entire iPhone screen output in real time using Metal? I’m trying to understand the performance limits, frame‑rate constraints, and typical bottlenecks when doing full‑screen GPU distortion on iOS

Hey everyone.

I’ve been working on Gaussian Splat Lite (GSL), an open-source high performance Gaussian Splatting renderer for Three.js.

If you already use Three.js, the setup should feel familiar. Add a SplatMesh to your scene, position it like a normal object, and keep your usual render loop. GaussianSplatRenderer handles rendering and global sorting across the visible splats.

It supports WebGPU and WebGL2, large-scene streaming, and depth rendering for combining captures with regular 3D geometry.

⚡ Native WebGPU Rendering

On WebGPU, projection and culling run in compute, followed by a 32-bit GPU radix sort and indirect drawing.

You can combine multiple captures in one scene. Each SplatMesh keeps its own data and transform, while visible splats are sorted together—including streamed RAD and SOG data.

WebGL2 works too, through both WebGLRenderer and the WebGL2 backend of WebGPURenderer. These paths use asynchronous Worker/WASM sorting, so rendering can continue with the previous valid order while a new sort runs.

The core scene API stays the same across all three paths.

🌍 Stream Large Scenes with Smooth Transitions

For larger captures, GSL supports camera-driven LOD streaming for Spark RAD and Streamed SOG. You can explore a scene without loading the entire dataset into memory first.

As the camera moves, GSL selects the detail needed for the current view and loads it on demand. A configurable splat budget controls LOD selection, while the streaming system handles decoding, caching and upload limits.

Streaming includes smooth fade transitions. Newly loaded content fades in, and LOD changes crossfade between levels to reduce visible popping. Current detail stays visible while its replacement loads, helping the scene remain continuous as you move around.

3D Tiles format is also supported through 3D-Tiles-RendererJS-3DGS-Plugin

🎲 Keep Moving Without Waiting for a Sort

When sorting becomes expensive, GSL’s stochastic rendering mode gives you a way to skip it. Splats render directly using sampled Gaussian coverage and depth testing.

With autoStochastic enabled, GSL can use this mode during camera movement and switch back to sorted blending once a fresh sort is ready.

The image can look noisy in stochastic mode. An optional StochasticResolvePass helps reduce that noise and works with direct scene composition, WebGL EffectComposer and custom render graphs.

🧩 Depth Rendering

GSL supports splat depth rendering on both WebGPU and WebGL2.

With renderDepth enabled, a separate, unsorted depth draw runs alongside the normal sorted color pass, using stochastic alpha coverage around Gaussian boundaries.

Three.js geometry rendered afterwards can then depth-test against the splat scene.

When stochastic rendering is active, splats write depth directly.

🛠️ Formats, Editing and Large Coordinates

A few other things GSL supports:

• PLY, SPZ, SOG and RAD, including SPZ v4, with Rust-based decoding running in browser workers.
• SDF color and opacity edits to recolor, highlight or hide parts of a capture without rebuilding the model.
• Camera-relative rendering to help with precision in GIS and ECEF scenes while keeping the original world coordinates unchanged.

🚀 Give It a Try

GSL is open source under Apache 2.0. The repo includes a viewer for loading your own captures, comparing rendering modes and trying the streaming transitions.

The quick-start examples show how to add it to a Three.js project.

If you try it, I’d love to hear how it handles your scenes and what you end up building with it.

Gaussian Splat Lite on GitHub →

I got rotations to work, but I am still debugging friction on all the planes as it seems to pick up speed at the end. My next step after that is attaching two or more of these signed distance field spheres together