There is a website called Shadertoy where people post images and animations that are generated entirely by code. No 3D models, no textures, no image files. The entire visual output is produced by a fragment shader, a small program that runs on the GPU and computes the color of every pixel on the screen from mathematical formulas. Some of these shaders produce photorealistic scenes: water, clouds, terrain, atmospheric scattering. Others produce abstract patterns, fractals, or psychedelic color fields. The most impressive shaders on Shadertoy are written by demoscene veterans and graphics engineers who have spent years learning how to trick a GPU into drawing anything from a formula. The site, launched in 2013 by Polish programmer Konstantin "iq" Kaplunov and others, has become the largest repository of shader code in the world. It demonstrates something that most people never think about: every pixel you see in a 3D game or film is the output of a program, and that program can be written to produce anything.
A shader is a small program that runs on a GPU and determines how a 3D surface appears. Shaders are part of the rendering pipeline, the sequence of steps that converts 3D data into a 2D image. Different types of shaders handle different stages of this pipeline. Vertex shaders transform 3D geometry. Fragment (or pixel) shaders compute the color of each pixel. Geometry shaders can generate new geometry. Compute shaders perform general-purpose computation on the GPU. Shaders are written in shading languages like GLSL (OpenGL Shading Language), HLSL (High-Level Shading Language, used with DirectX), MSL (Metal Shading Language, used with Apple's Metal API), and WGSL (WebGPU Shading Language).
This entry covers the history of shaders from Pixar's RenderMan Shading Language to modern GPU shaders, the artists and engineers who defined shader programming as a creative practice, and how 2026 developments in neural rendering and WebGPU are changing what shaders can do.
What Is a Shader and How Does It Work?
The rendering pipeline processes 3D data in stages. First, the vertex shader takes each vertex of the 3D mesh and transforms it from 3D model space into screen space. It applies the model, view, and projection matrices to compute where each vertex appears on the screen. The vertex shader can also modify vertex positions for animation, displacement, or morphing. The output is a set of screen-space vertices with associated data (texture coordinates, normals, colors) that are passed to the next stage.
The rasterizer takes the transformed vertices and converts them into pixels. For each triangle defined by three vertices, it determines which pixels are covered by the triangle and interpolates the vertex data across those pixels. Each interpolated pixel becomes a fragment.
The fragment shader (called a pixel shader in HLSL) takes each fragment and computes its final color. This is where the visual appearance of the surface is determined. The fragment shader can sample textures, compute lighting, apply normal maps for surface detail, calculate reflections, mix layers of material, and apply post-processing effects. The fragment shader is the most flexible and creative part of the pipeline, and it is where most of the visual character of a rendered image is established.
Compute shaders run outside the rendering pipeline and perform general-purpose computation on the GPU. They are used for particle simulation, image processing, AI inference, and any task that benefits from massive parallelism. Compute shaders are increasingly used in modern renderers for tasks that were previously done on the CPU.
Origins and History
RenderMan Shading Language (1989)
The concept of a shader was introduced by Pixar's RenderMan Shading Language (RSL), part of the RenderMan renderer first released in 1989. RSL was designed by Pat Hanrahan, who later won the Turing Award in 2019 for his contributions to computer graphics. RSL allowed artists to write custom programs that controlled how surfaces responded to light. Before RSL, renderers used fixed-function shading models: Phong, Blinn, Lambert. These models were built into the renderer and could not be modified. RSL gave artists a programming language to write their own shading models, which meant they could create any surface appearance they could describe mathematically.
Pixar used RSL to create the surfaces in Toy Story (1995). Each surface in the film, from Woody's plastic skin to the carpet in Sid's room, was described by a custom shader written in RSL. The shaders defined how light scattered, how color varied across the surface, how texture and bump maps modified the appearance, and how subsurface scattering made skin look soft and translucent. The film demonstrated that shaders were not a technical detail but the primary creative tool for controlling visual appearance in CGI.
GPU Shaders (2001-present)
The transition from offline renderers to real-time GPU shaders began in 2001. DirectX 8 introduced programmable vertex and pixel shaders, replacing the fixed-function pipeline that had been used since the first 3D accelerators. OpenGL followed with GLSL, introduced in OpenGL 1.5 in 2003. These early shader models were limited: pixel shaders had small instruction limits and could not perform loops or conditional branches. But they gave game developers their first opportunity to write custom shading code for real-time rendering.
The shader model evolved rapidly. Shader Model 2.0 (2002) added longer programs and floating-point precision. Shader Model 3.0 (2004) added dynamic branching and vertex texture fetch. By Shader Model 4.0 (2006, with DirectX 10), shaders were fully general programs with no significant instruction limits. Geometry shaders were added, and the unified shader model meant that the same hardware could execute any shader type. OpenGL 3.3 (2010) and OpenGL 4.0 (2010) added tessellation shaders and compute shaders.
The introduction of WebGL in 2011 brought shaders to the web browser. WebGL exposed OpenGL ES 2.0 to JavaScript, allowing web developers to write GLSL shaders that ran on the GPU. This enabled interactive 3D graphics, shader-based visual effects, and creative coding in the browser. Three.js, released by Ricardo Cabello (Mr.doob) in 2010, became the dominant JavaScript 3D library and made WebGL shaders accessible to a generation of creative coders.
Key Artists and Pioneers
Pat Hanrahan (b. 1955)
Hanrahan designed the RenderMan Shading Language at Pixar in the late 1980s. His work established that surface appearance could be described by programs rather than by fixed models, which is the foundational concept of all shader programming. Hanrahan later joined Stanford University, where his research group produced foundational work on GPU architecture, programmable graphics, and rendering algorithms. He received the Turing Award in 2019 jointly with Ed Catmull.
Ken Perlin (b. 1947)
Perlin invented Perlin noise in 1985 while working on the CGI for the film Tron (1982). Perlin noise is a gradient noise function that produces natural-looking randomness. It is used in shaders for procedural textures, terrain generation, water simulation, and any effect that needs organic variation. Perlin noise is so fundamental to shader programming that it is built into most shading languages or available as a standard library function. Perlin received an Academy Award for Technical Achievement in 1997 for this work.
Demoscene and Shader Artists
The demoscene, a subculture of programmers who create audiovisual demonstrations within strict size and time constraints, has produced some of the most technically accomplished shader work. Groups like Farbrausch, Fairlight, and RGBA have released demos where entire 3D scenes with lighting, textures, and post-processing are generated by shaders in executables of 64KB or less. The demoscene's emphasis on procedural generation and mathematical creativity has influenced mainstream graphics programming, and many demoscene veterans now work in game development and GPU research. Shadertoy, launched in 2013, grew directly from this community.
Inigo Quilez (b. 1972)
Quilez, known online as "iq," is a graphics engineer and shader artist who worked at Pixar, Oculus, and Apple. He is one of the most prolific contributors to Shadertoy and has written extensively about the mathematics of shader programming. His website, iquilezles.org, is a standard reference for ray marching, signed distance fields, and procedural rendering techniques. Quilez's work demonstrates that shaders can be a fine art medium, producing images of extraordinary beauty from pure mathematics.
Shaders in 2026: WebGPU, TSL, and Neural Rendering
In 2026, shader programming is being transformed by two developments: the transition from WebGL to WebGPU, and the integration of neural rendering into the shader pipeline.
WebGPU, the successor to WebGL, reached cross-browser stable status in 2025 and is seeing production adoption in 2026. WebGPU introduces WGSL (WebGPU Shading Language), a new language that replaces GLSL for web-based GPU programming. Three.js, the dominant web 3D library, introduced TSL (Three.js Shading Language) as a higher-level alternative. TSL lets developers describe shaders as composable JavaScript node graphs, which Three.js then compiles to WGSL or GLSL depending on the backend. A 2026 case study on Codrops described building a production WebGPU experience with TSL, noting that the node-based approach was cleaner than maintaining multiple GLSL files but that shader compilation time during initial load remained a challenge. Read more at Codrops.
NVIDIA's DLSS 5, presented at SIGGRAPH 2026, integrates neural rendering into the shader pipeline. DLSS 5 uses a compressed one-step pixel-space diffusion model that takes the engine's rendered frame and enhances it in real time. The model is small enough to run on a single GPU at 4K resolution with high frame rates and low latency. NVIDIA emphasized that DLSS 5 preserves artistic intention by working from the engine's own output rather than generating images from scratch. The model applies AI to graphics rather than replacing graphics with AI. Read more at WCCFTech.
Disney Research Studios presented a Neural Material Adapter at EGSR 2026 that maps complex layered material data into the parameter space of differentiable analytic BRDFs. The system trains a lightweight neural network that predicts view-dependent material parameters for unseen configurations, enabling high-fidelity materials that remain compatible with existing rendering pipelines. This bridges the gap between expensive physically based material simulation and efficient real-time shading. Read more at Disney Research.
Adobe's Substance 3D Painter 12.1, announced at SIGGRAPH 2026, introduced OpenPBR support, giving artists a standardized physically based material model that works consistently across tools and renderers. The OpenPBR specification was released as open source on GitHub, marking a shift toward shared material standards in the 3D industry. Read more at Adobe.
Shaders are part of the rendering pipeline, the process that converts 3D models into 2D images. They connect to procedural generation, since many shaders use procedural techniques like Perlin noise to generate textures and effects algorithmically. Shaders relate to generative art, as shader art is a form of generative art where the algorithm produces the visual output. They connect to digital art as a technical foundation for all 3D digital art. For more on digital art, read our post on the history of digital art from pixel to prompt, or explore our guide to digital art.
See Shaders in Practice
To see what shaders can do, visit Shadertoy at shadertoy.com, where thousands of shader artists post their work. Browse the "Featured" section for curated highlights. For shader art in a gallery context, look for work by demoscene groups at events like Revision (held annually in Germany) or at museums that have exhibited demoscene work, including the Technical Museum of Helsinki. Inigo Quilez's website, iquilezles.org, includes interactive shader examples and tutorials that demonstrate the mathematical foundations of shader art.
For more on the 3D pipeline, read our entries on 3D modeling and rendering, or explore our post on the history of digital art.
