In recent years, neural networks have started to find their way into many areas of rendering. While antialiasing and upscaling are probably the most well‑known uses, they’re far from the only ones—…
Discontinuity-Aware 2D Neural Fields
Neural image representations offer the possibility of high fidelity, compact storage, and resolution-independent accuracy, providing an attractive alternative to traditional pixel- and grid-based representations. However, coordinate neural networks fail to capture discontinuities present in the image and tend to blur across them; we aim to address this challenge. In many cases, such as rendered images, vector graphics, diffusion curves, or solutions to partial differential equations, the locations of the discontinuities are known. We take those locations as input, represented as linear, quadratic, or cubic \bez curves, and construct a feature field that is discontinuous across these locations and smooth everywhere else. Finally, we use a shallow multi-layer perceptron to decode the features into the signal value. To construct the feature field, we develop a new data structure based on a curved triangular mesh, with features stored on the vertices and on a subset of the edges that are marked as discontinuous. We show that our method can be used to compress a 100,000^2-pixel rendered image into a 25MB file; can be used as a new diffusion-curve solver by combining with Monte-Carlo-based methods or directly supervised by the diffusion-curve energy; or can be used for compressing 2D physics simulation data.
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.
ASCII characters are not pixels: a deep dive into ASCII rendering
A look at how I used shape vectors to achieve sharp, high-quality ASCII rendering.
Fullscreen rendering - Claude Code Docs
Enable a smoother, flicker-free rendering mode with mouse support and stable memory usage in long conversations.
Compositing & Blending • Niklas Gadermann
Exploring the math and intuition behind blend modes in the browser
On Rendering Diffs
A technical deep dive into how we built the @pierre/diffs package and CodeView component for zero-blanking diff rendering at any scale.
Unmasking Synthetic Realities in Generative AI: A Comprehensive...
The rapid advancement of Generative Artificial Intelligence has fueled deepfake proliferation-synthetic media encompassing fully generated content and subtly edited authentic material-posing...
Thousands of Styled Rectangles in 120FPS on GPU
Secrets of rendering extremely fast UIs in WebGPU by minimizing overhead on the GPU.
Tiled rendering
Tiled rendering is the process of subdividing a computer graphics image by a regular grid in optical space and rendering each section of the grid, or tile, separately. The advantage to this design is that the amount of memory and bandwidth is reduced compared to immediate mode rendering systems that draw the entire frame at once. This has made tile rendering systems particularly common for low-power handheld device use. Tiled rendering is sometimes known as a "sort middle" architecture, because it performs the sorting of the geometry in the middle of the graphics pipeline instead of near the end.[1]
Rendering Particles with Compute Shaders
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.
heerich.js
Tiny engine for 3D voxel scenes rendered to SVG — boolean ops, oblique/perspective cameras, zero dependencies.
Mesh Outlines Without Post-Processing in Unreal Engine
Some time ago I saw a neat solution by Cory Spooner on outlining meshes using particle sprites. The concept has been done before – but it’s interesting enough to cover it regardless for Unreal Engine...
Glaze - Protecting Artists from Generative AI
Pixelmator Pro
Pixelmator Pro is a powerful, easy-to-use image editor that brings professional tools and powerful AI features to everyone across Mac and iPad.
