The radiosity method is yet another global illumination rendering method for computer graphics, similar to ray tracing in that respect, but while ray tracing models global specular illumination, radiosity is capable of modeling global diffuse illumination. Unlike most other conventional rendering methods, there is no ambient light term (which really is a very crummy way of approximating global diffuse interreflections), and every surface is considered as an emitter or reflector of diffuse illumination that obeys Lambert's Law. The diffuse illumination computations are view-independent, meaning they have to be done only once for a particular scene, and provided the scene geometry doesn't change, the same computations can be used to render the same scene from a different viewpoint. This rendering method is very powerful, capable of rendering penumbrae (soft shadows) and color bleeding effects convincingly, among other things, and can create highly compelling photorealistic renderings. Often radiosity demo images show an actual picture of a scene along with with a 3D model of the same scene at the same viewpoint for comparison.

The method was first introduced by Cindy Goral, Kenneth Torrance, Donald Greenberg, and Bennett Battaille in their paper presented at SIGGRAPH 1984: "Modeling the Interaction of Light from Diffuse Surfaces."

The most common form of radiosity algorithm is actually an algorithm for solving radiative heat transfer problems using finite element methods adapted to computer graphics rendering. The algorithm in its most basic form subdivides the entire scene into finite-sized polygonal patches, and attempts to compute a radiosity (diffuse light emission intensity) for the patch, which is computed from its own emitted radiosity (if any) and the radiosity contributions of *all* other patches in the environment. Once a final answer for the radiosity has been obtained, this is used to compute a color for the patch, which is usually used as an intensity in a Gouraud shader for the final rendering.

The radiosities are computed by solving a large system of linear equations, with one equation for every patch, each equation with as many terms as there are patches, because it's possible for every other patch in the scene to contribute to the radiosity of any given patch (although in practice only a few patches greatly influence the calculated radiosity of any given patch). These large equation systems are frequently solved using Gauss-Seidel iteration, which is designed to cope with the large equation systems that are typical in finite-element problems.

The `j`th term in the `i`th equation in the radiosity matrix contains a dimensionless term called a form factor, which measures how much the radiosity of patch `j` will contribute to the radiosity of patch `i`, i.e. how much each patch can "see" of some other patch. These form factors are generally very difficult to compute exactly except in the most simple of environments. The original paper by Goral et. al. used contour integrals to compute exact form factors in their very simple scene (the interior of a cube with colored faces). Algorithms were soon developed for computing approximate form factors efficiently, the most well known being the hemicube algorithm developed by Pat Hanrahan. Ray tracing has also been adapted to aid in the calculation of approximate form factors as well.

As one might imagine, the memory and processing requirements for even a modest radiosity simulation can be prodigious, far more so than ray tracing: a scene of medium complexity that has been subdivided into a million patches would require a matrix with one trillion coefficients, and the computation of a trillion form factors. Fortunately, a technique called substructuring has been developed for adaptively subdividing surfaces into patches, creating more patches where the radiosity gradient is estimated to be high (such as near a shadow boundary), and less where the gradient is low. There has also been progress in the development of progressive refinement radiosity algorithms that compute incremental solutions that can be refined to better ones later on.