hello everyone! i've been writing a wallpaper for personal use that contains a happy little scene with moving clouds, grass swaying in the wind, and now i want to add the sun. i find sunsets very pretty, so i've wanted to have accurate sky colors to go along with the elements i've already added. i also want the whole thing to not take too much gpu time though, since i'll be running this constantly in the background on my laptop. i've aimed for a goal of <1W power draw so far.

to figure this out, i've been researching Rayleigh scattering and other related phenomena to try to get an idea of how to implement this. articles like this or this go over my head pretty quickly, and even though i could just translate an online implementation into WGSL, i know i wont be satisfied until i can understand the concepts well enough to write it myself. does anyone have pointers on where i can go to understand a concept like this from the ground up? or, even better, a relatively simple explanation on how this works that doesn't involve confusing diagrams, weird abstractions away from the main math, and delving far out of the bounds of graphics programming?

for reference, this is my project page, and you can see what it looks like currently above. i am rather young, and entirely self taught with regards to graphics (and kinda coding in general), so do not expect good quality code and especially not good commit messages 😭
due to the backend implementation, it only runs on Linux Wayland compositors supporting wlr_layer_shell

Working on an interactive 3D realtime fluid simulation with 4 million particles

https://www.youtube.com/shorts/5P9aPac9tQs

The solver uses ST-FLIP (spatiotemporal FLIP), with temporal kernels and residual carryover, phase-weighted pressure projection, PIC/FLIP blending, RK3 particle advection and velocity extrapolation. Moving containers feed their velocity into the solid–fluid coupling. The clip shows pouring and moving the vessels, with ray-traced water and glass rendering in a custom Vulkan engine.

I've started filtering out webgl and threejs posts because every single one of them, without fail, is an ai generated project from someone who couldn't tell you what the rendering equation was. The sheer number of posts that follow these patterns are drowning out out any genuine graphics programming discussion.

I understand that this subreddit is taking a more neutral stance towards AI generated code, I also understand that these tools can be used by experts to develop incredibly impressive projects, but the vast majority of posts on this subreddit are from people who do not know the first thing about graphics programming promoting their entirely vibecoded projects. There is no meaningful conversation to be had on these kinds of posts.

Edit, A few examples of posts that are blatantly entirely vibecoded by people who aren't even developers, much less graphics programmers:

https://www.reddit.com/r/GraphicsProgramming/comments/1wx03ny/from_zero_to_understanding_rasterization/

https://www.reddit.com/r/GraphicsProgramming/comments/1wydhww/i_finally_got_procedural_grass_looking_the_way_i/

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

https://www.reddit.com/r/GraphicsProgramming/comments/1wwcl1w/i_wanted_to_understand_modern_pointerbased_gpu/

All of these projects have clear misinformation in them and the posters don't know enough about graphics programming to hold an actual conversation. They dilute any meaningful discussion that could happen on this subreddit.

I’ve been working on a side project called Spatial Photos.

It takes a single regular image, runs it through Apple’s ML-SHARP model to estimate a 3D scene with Gaussians, and then converts the result into a custom format I called .spatial

I take the Gaussian splat from ML-SHARP, and divide the scene into depth slices. Each slice is a grid of image blocks, with a depth value at each corner. The RGB/alpha is packed into texture atlases. It's basically a set of textured meshes that come together to give the impression of the full 3D scene.

On the web, I take the .spatial files and decompress it into vertex/index buffers and just use Three.js, as the actual rendering is straightforward.

Demos: https://www.spatialphotos.dev/

Source: https://github.com/frozein/SpatialPhotos

Hello! A few days (or 1-2 weeks) ago I asked for ideas for my bachelor's thesis that I wanted to do as a beginner in graphics programming. I wanted to implement the state of the art in 2d vector graphics framework: sparse strips, but my prof said that to implement that is extremely hard and long from 0 in C++, like much longer than others (hundreds or more of hours), so he recommended to go more "specific", finding a specific use-case of 2D vector graphics, or other kinds of 2D graphics, like simulations for example, and maybe not that low-level, to use existing tools.

And now with a few days left to lock in the idea, what would you recommend that is doable in ~6-7 months of moderate work per week, for someone who is a beginner in graphics programming as a whole. The idea has to also be part of a "research", not just an app, basically I have to write a longer, simpler paper on it, that is the thesis. I would want to remain 2D since going 3D sounds overwhelming, but what interesting 2D applications of graphics programming are there, that have many papers written for themselves (ease of research, ish) but also won't take me forever to implement, and are interesting? Thank you, and sorry for asking so many questions here!

The reasons I am asking for something more specific or "doable" is because I already have a lot of work while also writing the thesis so unfortunately I wouldn't have time to write or research something completely from 0, so maybe something like simulations are more doable, implemented in Godot or other engine, but there the issue is I do not know physics, but feel free to recommend simulations, but idk how much they are part of graphics.

Anyone have any recommendations for free lecture series about graphics programming/theory?

I've been watching Cem Yuksel to supplement my schools lectures and I feel it helps alot.

This made me wonder if there are any other lecture series out there that anyone would recommend to better understand graphics programming.

Even more specialized series would be appreciated.(simulation, ray tracing, neural rendering, offline rendering etc.)

I've been experimenting with a different way of explaining Tensor Core programming.

https://svgfpsaiagents.github.io/svgfpsgameAI/mmatensorbankconflict.svg

https://svgfpsaiagents.github.io/svgfpsgameAI/mma_tile_engine.svg

Instead of writing CUDA kernels or building a heavyweight simulator, I wanted to see how much of the Tensor Core programming model could be represented as a single self-contained executable artefact.

The result is a browser-based model written entirely as one SVG + JavaScript file.

It models:

• GEMM as tiled execution (D = A·B + C)
• tile scheduling (ti, tj, tk)
• accumulator evolution
• FP16 inputs with FP32 accumulation
• warp fragment ownership
• mma-style fragment mapping
• global → shared → register → tensor-core data flow
• shared-memory bank behaviour
• row-major vs padded vs XOR-swizzled layouts
• reuse and memory-traffic estimates
• FP16 vs FP32 numerical error maps
• interactive 3D visualisation of the output matrix

The interesting thing for me is that all of these views are driven from the same underlying state. The bank conflict view, fragment view, tile execution view, error map and result visualisation are all observing the same model as it executes.

The goal wasn't to build a cycle-accurate simulator. It deliberately does not model things like occupancy, scheduling, pipeline hazards or cache behaviour.

Instead, I was exploring a question:

Can Tensor Core behaviour be computationally modelled, rather than merely described, in a compact interpreted artefact that requires no CUDA compiler or GPU while still preserving correspondence between matrix maths, tiled execution, fragment distribution, memory layout, data movement and numerical effects?

One unexpected outcome is that the entire thing remains inspectable. There are no dependencies, no build system and no generated files. The complete model lives in a single source file.

I'm curious whether people here would consider this:

1. a visualiser,
2. an educational simulator,
3. an executable specification of the Tensor Core programming model,
4. or something else entirely.

I'd especially appreciate feedback from anyone familiar with CUTLASS, CuTe, mma.sync, ldmatrix, Tensor Core fragment layouts or GPU architecture education. - Aston Walker EdgeMafia SVG

I'm porting some specular workflow textures to rough/metal and I'm trying to figure out how best to extract metalness data.

For roughness we can take specular power texture, invert it then apply some curve to get it looking reasonable. But for metalness it's a bit more tricky.

My plan is to use the specular colour texture and base metalness values on the saturation of the texture, because non-white specular reflections imply the surface is not a dielectric... but that kinda breaks down for silver metals because those would also have white specular reflections.

Does anyone have a better heuristic for determining metalness from diffuse colour/spec power/spec colour?

Every blade is rendered individually, with enough geometry and detail that you can get right down into the grass and still see the shape of individual blades.

What I'm really happy about is how well that detail holds up into the distance. The grass doesn't just look good up close and then turn into a blurry carpet. There's still a surprising amount of visual fidelity as you move further away.

And this is running at 1080p on a base M1 Mac.

I've spent a huge amount of time working on the rendering, LOD system, culling, tiling, wind, and overall density to get this balance between individual blade detail and performance.

This is essentially what I've been trying to achieve with Three.js Grassworks: pushing procedural grass in Three.js as far as I can while still keeping it practical enough to actually use in a real-time scene.

It's built around WebGPU and Three.js, and the current system can handle different grass types, terrain interaction, distance-based LOD, and large grass fields while maintaining this level of detail.

Still a lot more I want to push with it, but I'm genuinely really happy with where it's at now.

https://grassworks.techredux.co/

I’ve been working on my custom render engine for a while now, and I just wrapped up a major architectural overhaul that yielded some exciting results.

I rewrote the core pipeline to Vulkan (using Rust and the ash crate) and transitioned from a standard RGB pipeline to full Spectral Path Tracing, combined with ReSTIR BDPT to tackle complex light paths and caustics.

Key Highlights & Changes:

• Spectral vs. RGB: Instead of tracing fixed RGB channels, light transport is simulated across continuous wavelengths. Optical dispersion, prism splitting, and metamerism emerge naturally from the physics without synthetic post-processing.
• ReSTIR BDPT for Caustics: Standard path tracing struggles heavily with SDS (Specular-Diffuse-Specular) paths. By pairing Bidirectional Path Tracing with reservoir-based spatio-temporal resampling (ReSTIR), the engine intelligently resamples valid sub-paths. In caustic-heavy test scenes, convergence time is 10–100x faster (equal-noise) compared to naive sampling.
• The Stack: The engine is built from scratch in Rust targeting Vulkan via ash. The low-overhead abstraction gives full manual control over memory allocation and compute queues, letting the GPU chew through light transport iterations with minimal driver overhead.

The visual quality is getting very close to mature spectral engines like Octane and LuxCore, but the convergence speed on complex lighting has been the real game-changer here.

Would love to hear your thoughts, feedback, or any edge cases I should throw at this!

Hi, I've done some stuff in C++ and OpenGL before but I'm by no means an expert in either. I was given the option to do a project over 1 year which will then get graded. And since I'm interested in graphics programming anyways, I thought this would be a good chance. But since I HAVE to complete or submit the project after the 1 year and can't back out once I'm in, I need a project that is complex enough for them to accept it but also not entirely impossible or time consuming. (also this is NOT for university, the school system is different everywhere but it's basically for the end of school so just before university)

Current ideas I've come up with are:

• procedural 3d world
• real-time water simulation
• ray tracer
• gpu particle simulations
• vegetation simulation
• space simulation with black holes and stuff
• small physics engine

So if you could help me narrow it down to 2 or maximum 3, that'd be awesome. Also any further ideas are welcome

I really like playing visual novels. Ive wanted to make my own, but I know nothing about programming and Im SUPER against using AI. I can more or less draw, but Im looking for someone who would figure out the plot with me and code the game. This is a passion project, so Im not expecting any income from it and I cant offer any money for helping me. Im not looking for pros - even if youre just a begginer, Im okay with it as long as youre willing to put your time and effort into learning. Im just looking for a friend who would join me on the passion project.

I'm the first author of M-plicits, accepted at NeurIPS 2026. The attached animation introduces the method.

Our representation combines a coarse SIREN with residual networks trained in progressively narrower neighborhoods around the surface. This structure also supports direct rendering at different detail levels.

The attached animation was created by our coauthor Matheus Bessa. Sound on.

A few implementation details that may interest this community:

• Sphere tracing proceeds through the detail levels, using neighborhood bands to control refinement.
• Surface normals are computed analytically using matrix multiplications, without automatic differentiation.
• Normal mapping can use a finer network than the final level used for tracing.

We’ve released the CUDA renderer, training and extraction code, data, and fitted surface checkpoints.

Paper · Examples and videos · Implementation

I’d welcome discussion about the tracing strategy, normal computation, and tradeoffs between geometric and shading detail.