Radiosity

Walk into a room painted with a bright red wall. Even though no red light bulb exists, everything near that wall takes on a warm pink glow. The wall is not just reflecting light at you — it is bleeding energy into the room. This phenomenon is called diffuse interreflection, and computing it realistically is one of the central problems of 3D rendering.

Radiosity is the classical solution. Invented in 1984 by Goral, Torrance, Greenberg and Bennett at Cornell, it borrows a concept from thermal engineering: every surface patch exchanges radiant energy with every other patch it can "see," and the total brightness of each patch is the sum of all the energy it receives.

The core insight is that, once you know how much of patch $i$'s hemisphere is occupied by patch $j$ — a number called the form factor $F_{ij}$ — the equilibrium brightnesses form a system of linear equations. Solve the system, and every patch's soft glow emerges at once.

Unlike ray tracing, which chases individual photons, radiosity pre-computes the energy budget for the whole scene. The result: perfectly smooth indirect light with no noise — at the cost of solving an $n \times n$ linear system for $n$ patches.

Below is a simplified Cornell-box scene with five patches: a top light, a red left wall, a blue right wall, a white floor, and a white back wall. Each step of the simulation transfers energy between patches using form factors.

<!-- {{c_html_comment}} -->
<div class="controls">
  <label>{{lbl_left_wall}}
    <input type="color" id="leftColor" value="#cc2222" title="{{title_left_color}}">
  </label>
  <label>{{lbl_right_wall}}
    <input type="color" id="rightColor" value="#2244cc" title="{{title_right_color}}">
  </label>
  <label>{{lbl_bounces}}
    <input type="range" id="bounces" min="1" max="8" value="4" step="1">
    <span id="bounceVal">4</span>
  </label>
  <button id="runBtn" type="button">{{btn_run}}</button>
  <button id="resetBtn" type="button" class="ghost">{{btn_reset}}</button>
</div>
<canvas id="scene" width="340" height="260" aria-label="{{aria_canvas}}"></canvas>
<div id="status" class="status" aria-live="polite"></div>

/* {{c_css_comment}} */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; background: #f5f7fa; }
.controls { display: flex; flex-wrap: wrap; gap: .5rem .9rem; align-items: center; margin-bottom: .7rem; }
label { display: flex; align-items: center; gap: .35rem; font-size: .88rem; font-weight: 500; }
input[type=color] { width: 36px; height: 28px; border: 1px solid #ccc; border-radius: 5px; padding: 1px; cursor: pointer; }
input[type=range] { width: 90px; accent-color: #1d3557; }
#bounceVal { font-size: .85rem; min-width: 1.2em; }
button { font: 600 13px system-ui, sans-serif; padding: .38rem .8rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 7px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
canvas { display: block; border-radius: 8px; box-shadow: 0 1px 6px #0002; }
.status { margin-top: .5rem; font-size: .9rem; font-weight: 600; min-height: 1.4em; color: #1d3557; }

// Code not found

Pick a wall color, adjust the number of bounces, and click Run. Notice how the floor gradually picks up the hue of whichever wall faces it — that is color bleeding, computed entirely by the radiosity linear system. More bounces converge to the true solution; one bounce is a crude approximation.

Radiosity looks elegant on paper, but the computational cost bites hard once scenes grow large.

• Form-factor computation: every patch $i$ must see every patch $j$, giving $O(n^{2})$ integrals. Each integral itself may require Monte-Carlo sampling or hemisphere ray-casting — so the setup alone is $O(n^{2})$ to $O(n^{2} \log n)$.
• The radiosity matrix: the system $(\mathbf{I} - \mathbf{F})\,\mathbf{B} = \mathbf{E}$ is dense and $n \times n$. Gaussian elimination costs $O(n^{3})$; iterative solvers like Gauss-Seidel converge in $O(k \cdot n^{2})$ where $k$ is the number of iterations — often surprisingly small because the matrix is diagonally dominant.
• Memory: storing the full form-factor matrix requires $O(n^{2})$ floats. For $n = 10{,}000$ patches that is already 400 MB at 32 bits.

These costs drove major algorithmic innovations:

• Progressive refinement (Cohen et al., 1988): shoot energy from the brightest patch first, updating all others incrementally. You get a good image long before convergence.
• Hierarchical radiosity (Hanrahan et al., 1991): group distant patches into clusters so that $O(n^{2})$ interactions collapse toward $O(n \log n)$.
• Wavelet radiosity represents brightness as a function (not a constant) per patch, dramatically reducing the patch count needed.

The underlying insight mirrors linear programming: the structure of the problem — a positive, diagonally dominant matrix — guarantees a unique, physically meaningful solution. Radiosity is not NP-hard; it is simply expensive in proportion to scene complexity.

Radiosity's ability to produce smooth, noise-free indirect light made it indispensable long before real-time ray tracing was feasible:

• Architectural visualization: clients judge a building design by the warmth of its light. Radiosity — not ray tracing — was the go-to tool for interior renders through the 1990s and 2000s.
• Game lightmaps: baked radiosity solutions are stored as textures and sampled at runtime. Unreal Engine, Unity, and id Tech have all shipped lightmap bakers based on progressive radiosity.
• Film VFX and animation: global illumination in pre-rendered content blends radiosity ideas with path tracing. The characteristic soft shadows and color bleeding in Pixar films trace their lineage here.
• Daylighting simulation: engineers simulate how sunlight distributes through a building to optimize energy use — the same form-factor equations, applied to thermal flux instead of visible light.

Today, hardware ray tracing and neural denoising have replaced radiosity for many use cases, but the form-factor framework remains the clearest physical model for diffuse energy exchange. Understanding radiosity means understanding why non-convex optimization is needed when specular reflections enter the picture and the linearity breaks down.

Radiosity is a beautiful marriage of physics and linear algebra. By reducing the question "how bright is each surface?" to a system of equations defined entirely by geometry, it turns the mystery of soft indirect light into a solvable problem — one with a unique, correct answer.

The cost is real: form factors scale as $O(n^{2})$, and the matrix grows with the scene. But every trick that tames that cost — progressive refinement, hierarchical grouping, wavelets — builds on the same underlying equation.

The next time you walk past a red wall and notice your hand blushing pink, you are witnessing a small instance of a linear system working silently in the physics of the world. Radiosity is just the algorithm that writes it down.