Graphics Rendering

Rendering is the part of computer graphics that turns a scene description—shapes, materials, lights, and a camera—into an image.

11 frameworks, from 1967 to today · Computer Graphics · Computer Science

still a working view ended · each leads to its entry below

Overview

Rendering is the part of computer graphics that turns a scene description—shapes, materials, lights, and a camera—into an image1. The description might be a list of triangles, a mathematical surface, a cloud of particles, or a set of photographs1. The image might be a single frame for a film, a view in a video game that must appear sixty times a second, or a medical scan made visible. What is at stake is a three-way tension that has defined the field since the 1960s: an image should be convincing (physically or perceptually plausible), fast (cheap enough in time and memory for its purpose), and controllable (artists and engineers can predict and direct what comes out). Every era of rendering has answered that tension differently, and the answers have shaped film, design, medicine, and the screens in daily life.

The 1960s: Lines, Hidden Surfaces, and the First Shading

Early computer graphics grew out of military and scientific plotting2. Ivan Sutherland's Sketchpad (1963) let a user draw and manipulate line figures interactively, and the first displays drew only lines—vectors—not filled surfaces. The immediate problem was that a scene of solid objects drawn as wireframes is ambiguous: which edge is in front3? Hidden-surface determination became the first great rendering problem. The Watkins algorithm (1970) and later the z-buffer, developed at the University of Utah by Edwin Catmull and others around 1974, solved it by storing, for each pixel, the depth of the nearest surface found so far. The z-buffer's simplicity—compare depths, keep the closer one—made it the foundation of nearly all real-time rendering that followed14.

Filling surfaces raised the next question: what colour should a surface be? In 1967 Henri Gouraud introduced smooth shading, interpolating colours across a polygon's interior so that faceted models looked curved. Bui Tuong Phong's 1975 shading model went further, computing a highlight from the angle between the surface, the light, and the viewer15. These local shading models treat each point independently, using only the light that arrives directly from sources6. They are cheap and were enormously influential, but they cannot produce shadows, reflections between objects, or the soft light of a room—because that light depends on the rest of the scene.

The 1970s–1980s: Ray Tracing and the Idea of Global Light

A different strategy appeared in 1968, when Arthur Appel cast rays from the eye through each pixel to find what it hits—an early form of ray casting17. Turner Whitted's 1980 paper on recursive ray tracing made the idea powerful: when a ray hits a shiny surface, spawn a reflected ray; when it hits glass, spawn a refracted one; follow these recursively and combine the results189. For the first time a simple algorithm produced mirror reflections and transparent glass, and it did so elegantly1. Its weakness was cost and aliasing—one ray per pixel gives hard edges and misses small details—and it still handled only perfect mirrors, not the blurry reflections of real materials1.

Meanwhile the question of global light—light that bounces between surfaces—was being attacked from another direction. In 1984, researchers at Cornell (Cindy Goral, Kenneth Torrance, Donald Greenberg, and Bennett Battaile) adapted a method from thermal engineering called radiosity. They divided surfaces into patches, computed how much light each patch exchanged with every other, and solved the resulting system1. Radiosity gave soft, physically plausible indirect light and contact shadows, and it was view-independent: solve once, then look from anywhere. Its limitation was that it assumed surfaces diffuse light evenly, so it could not do glossy highlights or mirrors1. For a time, radiosity and ray tracing were seen as complementary rivals—one for soft diffuse light, one for sharp specular effects—and hybrid systems combined them.

1986: The Rendering Equation Unifies the Field

The conceptual turning point came in 1986, when James Kajiya and, independently, David Immel and colleagues formulated the rendering equation110. It states, in one integral, that the light leaving a point in a direction equals the light it emits plus the light arriving from every other direction, weighted by how the surface reflects it10. This was not a new algorithm but a unifying statement: radiosity, ray tracing, and local shading were all approximations of the same equation. It gave the field a common language and a target.

The equation's integral is generally impossible to solve exactly, so the practical answer was Monte Carlo light transport: estimate the integral by taking random samples of light paths and averaging19. Kajiya's 1986 paper introduced path tracing, which follows randomly chosen bouncing paths from the camera19. The method is conceptually simple and handles arbitrary materials and geometry, but early images were noisy, because random sampling converges slowly—noise falls only as the square root of the number of samples. Making Monte Carlo practical became a decades-long project: better sampling strategies, importance sampling (concentrating samples where they matter), and variance-reduction techniques gradually turned a beautiful but impractical idea into the backbone of film-quality rendering19.

The 1980s–1990s: The Rasterization Pipeline and Real-Time Graphics

While offline rendering pursued physical accuracy, interactive graphics took a different path. The rasterization pipeline—the hardware-and-software assembly line that projects triangles onto the screen, fills pixels, and shades them—became the standard for real-time work111. Its logic is the opposite of ray tracing's: instead of asking what each pixel sees, it takes each triangle and asks which pixels it covers1. The pipeline's stages (vertex transformation, clipping, rasterization, texturing, shading) map naturally onto parallel hardware, and by the late 1990s consumer graphics cards implemented it in silicon1. Texture mapping, developed in the 1970s and refined through the 1980s, let a flat polygon carry a detailed image, multiplying apparent realism at little cost. The pipeline's limitation was that it approximated global light poorly—shadows, reflections, and indirect bounce had to be faked with tricks like shadow maps (Lance Williams, 1978) and environment maps112.

The 1980s–1990s: Volumes and Images as Scene Descriptions

Two further expansions changed what a "scene" could be. Volume rendering addressed data that is not a surface but a field—a cloud, smoke, or a CT scan—where every point in space has a density or value131. Ray casting through such a volume, accumulating colour and opacity, made medical visualization and later realistic smoke and fire possible; the technique matured through the 1980s and 1990s. Image-based rendering took the opposite route: instead of modeling geometry, start from photographs14. Light fields and plenoptic functions, formalized in the 1990s, describe how light varies across space and direction, and techniques such as view morphing and layered depth images showed that convincing new viewpoints could be synthesized from a set of captured images. The appeal was fidelity and speed—real photographs carry detail no model can match—while the limitation was that you could only move so far from the captured views.

The 2000s–2010s: Physically Based Rendering Matures

The 2000s saw the rendering equation's promise realized in production. The book Physically Based Rendering (first edition 2004, by Matt Pharr and Greg Humphreys) codified the theory and practice of Monte Carlo rendering, and the field converged on physically based materials—descriptions of how surfaces reflect light that obey energy conservation15. Bidirectional methods, which trace paths from both the camera and the lights, and Metropolis light transport (1997) helped with difficult scenes19. By the 2010s, path tracing was producing photorealistic visual effects in film, and the same ideas began migrating to real time as GPUs grew more programmable.

The 2010s–Present: Learning to Render

The most recent turn is neural rendering: using machine learning, especially neural networks, to produce or accelerate images1. Its roots run through learned image synthesis and the use of deep networks to denoise Monte Carlo renders—a technique that lets a noisy, low-sample image be cleaned up convincingly, dramatically cutting render times1. A landmark came in 2020 with Neural Radiance Fields (NeRF), which represent a scene as a neural network mapping position and viewing direction to colour and density, trained from a handful of photographs and rendered by ray marching116. Gaussian splatting (2023) offered a faster, explicit alternative117. These methods blur the old boundaries: they are image-based in their inputs, volumetric in their representation, and learned in their machinery1. They inherit the field's oldest ambition—turn a description into a convincing picture—while raising new questions about how to control, edit, and trust images produced by networks rather than equations.

Where Rendering Stands

Today two broad families coexist1. Real-time rasterization, now augmented with ray-traced shadows and reflections on dedicated hardware, dominates games and interactive tools1. Offline Monte Carlo path tracing dominates film and product visualization, where accuracy matters more than speed1. Around them, volume rendering serves science and effects, image-based and neural methods serve capture and synthesis, and the rendering equation remains the common reference point against which every approximation is measured. The open questions are familiar in new clothes: how to make learned renderers controllable and editable; how to render at interactive rates without sacrificing physical correctness; and how to represent scenes—geometry, images, or networks—when the goal is not just a picture but a manipulable world.

References

  1. Rendering (computer graphics) (introduction, 3D geometry, Photogrammetry and scanning, Rasterization, Chronology of algorithms and techniques, Ray casting, Ray tracing, Techniques, Radiosity, Path tracing, History, Volumetric data, Machine learning, Neural approximations and light fields), Wikipedia
  2. Computer graphics (History), Wikipedia
  3. Hidden-surface determination, Wikipedia
  4. Z-buffering, Wikipedia
  5. Phong reflection model (introduction, History), Wikipedia
  6. Shading, Wikipedia
  7. Ray tracing (graphics) (History), Wikipedia
  8. J. Turner Whitted, Wikipedia
  9. Path tracing (History, introduction), Wikipedia
  10. Rendering equation, Wikipedia
  11. Graphics pipeline, Wikipedia
  12. Shadow mapping, Wikipedia
  13. Volume rendering, Wikipedia
  14. Image-based modeling and rendering, Wikipedia
  15. Physically based rendering (History), Wikipedia
  16. Neural radiance field, Wikipedia
  17. Gaussian splatting, Wikipedia

The frameworks of Graphics Rendering

Each framework is a way of working the field has used: when it held, and the question it answers.

  1. 1967-1995

    Local Shading Models

    How should a surface's colour be computed from its lights?

    Fly to its tower in Nousfarer

  2. 1970-1985

    Hidden-Surface Determination

    Which surfaces are visible in front of others?

    Fly to its tower in Nousfarer

  3. 1980-Present

    Graphics pipeline

    How can triangles be turned into pixels fast enough?

    Fly to its tower in Nousfarer

  4. 1980-Present

    Recursive Ray Tracing

    How can mirrors and glass be drawn by following rays?

    Fly to its tower in Nousfarer

  5. 1984-2000

    Radiosity

    How does light bounce between diffuse surfaces?

    Fly to its tower in Nousfarer

  6. 1985-Present

    Volume Rendering

    How can a cloud or scan be made visible?

    Fly to its tower in Nousfarer

  7. 1986-Present

    Monte Carlo Light Transport

    How can random samples estimate the light arriving at a point?

    Fly to its tower in Nousfarer

  8. 1986-Present

    The Rendering Equation

    What single law governs all light transport?

    Fly to its tower in Nousfarer

  9. 1991-Present

    Image-Based Rendering

    Can new views be made from photographs alone?

    Fly to its tower in Nousfarer

  10. 2004-Present

    Physically Based Rendering

    How can rendering be made physically accurate and practical?

    Fly to its tower in Nousfarer

  11. 2017-Present

    Neural Rendering

    Can networks learn to produce or speed up images?

    Fly to its tower in Nousfarer

How the ideas connect

Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.

Local Shading ModelsHidden-Surface DeterminationGraphics pipelineRecursive Ray TracingRadiosityVolume RenderingMonte Carlo Light TransportThe Rendering EquationImage-Based RenderingPhysically Based RenderingNeural Rendering

Beyond the field

Where Graphics Rendering's ideas came from in other fields, and what they led to there: the strongest 12 of 49 links.

A city in Nousfarer: a red-carpeted stair climbing terraces to a crowned tower on an acropolis, more towers round it, forest and snowy mountains beyond.
A city in Nousfarer, the game played in the browser.

Graphics Rendering is a planet in Nousfarer

Its city has a tower for each of these 11 frameworks. Land, walk in, and climb one concept at a time.

Land on Graphics Rendering

Related fields

Fields its ideas are linked to

More in Computer Graphics

See where Graphics Rendering sits on the Map of Human Knowledge