Overview I developed a technique to render single-pixel particles (using additive blending) with compute shaders rather than the usual fixed-function rasterization with vertex and fragment shaders. My approach runs 31–350% faster than rasterization on the cases I tested and is particularly faster for some “pathological” cases (which for my application are not actually that uncommon). I observed these speedups on both NVIDIA and AMD GPUs. Using this technique allowed me to ship an app that runs on minimum-spec hardware without sacrificing visual fidelity.
Hash Functions for GPU Rendering – Nathan Reed’s coding blog
Pixels and polygons and shaders, oh my!
vik on Twitter / X
Photon, our inference engine, isn't fast just because of GPU kernels. A lot of the speedup comes from engine-level work: request scheduling, prefix caching, image processing, all tuned to keep the GPU saturated. https://t.co/3M7eFcFKo5— vik (@vikhyatk) May 2, 2026
Evaluating and Sampling Glinty NDFs in Constant Time
Geometric features between the micro and macro scales produce an expressive family of visual effects grouped under the term 'glints'. Efficiently rendering these effects amounts to finding the highlights caused by the geometry under each pixel. To allow for fast rendering, we represent our faceted geometry as a 4D point process on an implicit multiscale grid, designed to efficiently find the facets most likely to cause a highlight. The facets' normals are generated to match a given micro-facet normal distribution such as Trowbridge-Reitz (GGX) or Beckmann, to which our model converges under increasing surface area. Our method is simple to implement, memory-and-precomputation-free, allows for importance sampling and covers a wide range of different appearances such as anisotropic as well as individually colored particles. We provide a base implementation as a standalone fragment shader.
Surfel-based global illumination on the web
Can we use WebGPU to compute real-time global illumination with surface patches called surfels? Does it look good enough? Is it fast enough? And can we finally construct viable compute-heavy rendering pipelines right here on the open web? Join me on this journey and let's find out!
Visualizing GL_NV_shader_sm_builtins
Using GL_NV_shader_sm_builtins to visualize Streaming Multiprocessors and Warps
Thousands of Styled Rectangles in 120FPS on GPU
Secrets of rendering extremely fast UIs in WebGPU by minimizing overhead on the GPU.
InferenceMAX™: Open Source Inference Benchmarking
NVIDIA GB200 NVL72, AMD MI355X, Throughput Token per GPU, Latency Tok/s/user, Perf per Dollar, Tokens per Provisioned Megawatt, DeepSeek R1 670B, GPTOSS 120B, Llama3 70B
Stochastic Barnes-Hut Approximation for Fast Summation on the GPU
We present a novel stochastic version of the Barnes-Hut approximation. Regarding the level-of-detail (LOD) family of approximations as control variates, we construct an unbiased estimator of the kernel sum being approximated. Through several examples in graphics applications such as winding number computation and smooth distance evaluation, we demonstrate that our method is well-suited for GPU computation, capable of outperforming a GPU-optimized implementation of the deterministic Barnes-Hut approximation by achieving equal median error in up to 9.4x less time.
Leveraging Rust and the GPU to render user interfaces at 120 FPS
From the Zed Blog: A deep-dive into the graphical underpinnings of GPUI, the hardware-accelerated framework that powers Zed's user interface.
Open Source AI Inference Benchmark | InferenceX
Compare AI inference performance across GPUs and frameworks. Real benchmarks on NVIDIA GB200, B200, AMD MI355X, and more. Free, open-source, continuously updated.
Random Forest ML on GPU
In my recent post on Rastair , we looked at some performance best-practices and optimizations for Rastair , a bioinformatics tool that I’m currently working on. One of the slowest parts of the tool is …
RightNow AI - YC-Backed GPU Research Lab
YC-backed GPU research lab building the RightNow CUDA editor, RunInfra inference infra, Forge kernels, and publishing AutoMegaKernel and related papers on arXiv.
TypeGPU – Type-safe WebGPU toolkit
Discover how it can change the way you work with GPU rendering and computing.
Shaders
Component library for creative WebGPU effects in modern frontend frameworks. Compose interactive visuals for Vue, React, Svelte and Solid.
Unreal Scoop: Making a “Compiling Shaders…” Screen
Unreal has a reputation amoung the ill-informed for being plagued by shader compilation stutter. As an attribute of Unreal itself, this is basically made up – devs are just not always doing what they are supposed to do pre-ship to avoid this issue. I’ll elaborate, but basically, to avoid compiling shaders during gameplay, you want to do it up-front, like during an initial loading screen, which maybe says “Compiling shaders” on it, and not let the player begin until it’s done. To do that last part properly, you need a little bit of C++. I had to do this for InFlux Redux recently, so here’s mine.
