G-Buffers: Screen-Space Data for Deferred Rendering

• G-buffers are screen-space collections of per-pixel attributes—such as depth, normals, albedo, materials, lighting, and motion—that describe visible surfaces after rasterization and enable deferred shading, reprojection, editing, and synthesis.
• They support applications ranging from real-time deferred rendering and scientific visualization to frame generation, Gaussian-splatting inverse rendering, and diffusion-based image synthesis, but remain view-dependent and cannot generally recover hidden geometry or unstored attributes.
• Designing a G-buffer requires balancing channel coverage and image quality against memory, bandwidth, synchronization, and approximation costs, with failures commonly arising from disocclusions, depth discontinuities, incomplete materials, temporal motion, and ambiguous RGB decomposition.

G-buffers, or geometry buffers, are screen-space representations that store per-pixel geometric, material, depth, lighting, motion, or scalar-field information for use after visibility determination and rasterization. In conventional deferred rendering, they decouple geometry processing from shading; in scientific visualization, they preserve view-dependent image-space attributes for later exploration; in generative rendering, they serve as structured conditioning variables; and in inverse rendering, they form an interface between scene representations and physically based or learned image synthesis. The expression is context-dependent: related research also uses “buffer” for finite packet storage, queue capacity, temporary manipulation storage, or graph-partition boundary sets, but those meanings are distinct from graphics G-buffers.

1. Terminology and conceptual scope

A graphics G-buffer is a collection of image-space render targets associated with a camera sample. Instead of producing only a final shaded color image, a renderer records attributes of the visible surface at each pixel. These attributes can subsequently support deferred lighting, temporal reprojection, denoising, compositing, frame generation, relighting, inverse rendering, or interactive visualization.

The exact channel inventory is engine- and application-dependent. Common attributes include depth, surface normals, albedo or base color, motion vectors, roughness, metallicity, emissive color, opacity, object identifiers, primitive identifiers, world-space position, visibility, radiance, and multiple depth layers. A G-buffer is therefore not a universally fixed tensor layout. It may contain only depth and scalar fields, as in Cinema Darkroom, or depth, normals, BRDF parameters, and direct-light radiance, as in GI-GS.

The representation is generally view-dependent. A depth value describes the visible surface from a particular camera rather than providing an object-space description of the entire scene. Consequently, a G-buffer does not normally encode surfaces hidden behind the frontmost visible layer, arbitrary new viewpoints, or geometry and attributes that were not generated or stored. This limitation is explicit in deferred visualization, frame extrapolation, Gaussian-splatting-based inverse rendering, and diffusion-based generative rendering.

The term is also used more broadly in adjacent systems, although these meanings should not be conflated:

• Scientific visualization: geometry buffers preserve depth and scalar images for post hoc shading and exploration (Lukasczyk et al., 2020).
• Frame generation: G-buffers provide depth, normals, motion, and material information for temporal reprojection and extrapolation (Wu et al., 2024).
• Inverse rendering: G-buffers represent reconstructed geometry and material properties used for direct and indirect illumination (Chen et al., 2024).
• Generative rendering: G-buffers act as structured controls for diffusion-based RGB synthesis or intrinsic decomposition (Xue et al., 18 Mar 2025, Zeng et al., 14 Aug 2026).
• Non-graphics buffering: finite queue buffers, graph buffers, and manipulation buffers are storage or combinatorial resources rather than screen-space render targets (Ikhlef et al., 2011, Even et al., 2014, Gao et al., 2021).

2. Deferred-rendering architecture

In a forward-rendering pipeline, geometry processing, visibility determination, material evaluation, lighting, and rasterization are commonly coupled. A change to lighting, color mapping, or another visualization parameter may require rerunning geometry processing. Deferred rendering separates the geometry pass from subsequent shading passes:

$$\text{geometry and visibility} \rightarrow \text{G-buffer} \rightarrow \text{deferred shading} \rightarrow \text{final image}.$$

The geometry pass determines the visible surface and writes its attributes into screen-space buffers. Later passes read those buffers and compute lighting or image operations. Because lighting is evaluated after visibility has been resolved, expensive shading calculations are performed per visible pixel rather than repeatedly for every contributing geometric primitive.

In conventional real-time rendering, G-buffers may include depth, normals, albedo, roughness, metallicity, motion vectors, and object or material identifiers. Their contents are consumed by deferred lighting, temporal reconstruction, reprojection, denoising, and frame-generation systems. The exact storage format, precision, compression, render-target layout, and resource lifetime are implementation-dependent.

G-buffers are also intermediate interfaces between otherwise separate components. GI-GS uses depth, normal, and BRDF maps rendered from 3D Gaussian Splatting as inputs to direct PBR and lightweight path tracing. Its pipeline is:

$$\text{3D Gaussians} \rightarrow \text{G-buffer} \rightarrow \text{direct PBR} \rightarrow \text{indirect-light estimation} \rightarrow \text{final image}.$$

The depth map provides surface distance, normals define local orientation and sampling hemispheres, and material maps provide albedo, metallicity, and roughness. Surface position is reconstructed from depth and camera parameters rather than necessarily stored as an independent channel. GI-GS uses depth-buffer ray-intersection tests and reuses the first-pass direct-light image to approximate diffuse indirect illumination (Chen et al., 2024).

The principal trade-off is flexibility versus storage and bandwidth. Additional full-resolution render targets require extra rasterization writes, shader reads, cache capacity, synchronization, and resource management. G-buffer-dependent frame extrapolation methods may also require future-view geometry passes and engine integration across material shaders, motion-vector generation, resource layouts, and graphics/post-processing synchronization (Wu et al., 2024).

3. Attribute channels and deferred operations

Depth and position

Depth is a scalar image describing the distance to the visible surface. With known camera calibration, a pixel and its depth can be unprojected into a world-space or view-space position. This enables screen-space lighting, depth testing, compositing, ray marching, depth of field, and geometric reprojection.

Depth quality affects reconstructed positions, ray origins, occlusion tests, projected samples, and indirect-light queries. Depth discontinuities and incomplete visibility can produce incorrect surface reconstruction or holes in downstream operations.

Surface normals

A normal buffer stores the local surface orientation, typically as a three-component vector. Normals determine diffuse and specular shading, hemispherical sampling, ambient occlusion, and BRDF orientation. They may be generated directly during rasterization, learned as Gaussian attributes, or reconstructed from neighboring depth-derived positions.

Normal reconstruction from depth is accurate only where the depth map sufficiently represents the underlying surface. In GI-GS, learned Gaussian normals are supervised using pseudo normals derived from local depth geometry and regularized with edge-aware normal total variation (Chen et al., 2024).

Albedo and material parameters

Albedo represents intrinsic base color separated conceptually from illumination. Roughness controls the spread of the specular response, while metallicity distinguishes dielectric-like and conductor-like behavior. Other possible material channels include specular parameters, emissive color, opacity, and transparency.

Material channels allow deferred systems to modify lighting without regenerating geometry. They also support object-level editing and generative control. In diffusion-based G-buffer generation, albedo, normals, depth, roughness, and metallicity can be generated jointly and then edited before neural rendering (Xue et al., 18 Mar 2025).

Motion vectors

Motion vectors encode screen-space displacement between frames. They are important for temporal reprojection, frame interpolation, frame extrapolation, motion-compensated reconstruction, and history-buffer management. A conventional motion vector is normally engine-provided for rendered frames; GFFE uses rendered-frame motion vectors together with depth and camera poses but does not require future-frame G-buffers (Wu et al., 2024).

Lighting and radiance

Lighting representations may include irradiance, direct lighting, radiance, ambient-occlusion information, or environment-map-derived quantities. These are not always considered geometry channels in the narrow sense, but they can be stored alongside geometric and material attributes as part of a broader deferred representation.

Cinema Darkroom generally stores depth and scalar buffers, then applies color mapping, compositing, SSAO, SSDD, SSDoF, IBS, and FXAA post hoc. GI-GS stores or derives direct-light radiance for use as an indirect-light source. RGBX-Next treats diffuse irradiance and albedo-free direct lighting as explicit conditioning modalities for generative rendering (Lukasczyk et al., 2020, Chen et al., 2024, Zeng et al., 14 Aug 2026).

Image-space operations

G-buffers support several classes of deferred operation:

• Lighting: direct illumination, PBR, SSAO, and screen-space depth darkening.
• Compositing: depth comparison selects the frontmost pixel among opaque image products.
• Post-processing: depth of field, silhouettes, anti-aliasing, and edge enhancement.
• Temporal processing: reprojection, motion compensation, history tracking, and extrapolation.
• Editing: channel-wise copy-and-paste, masked lighting regeneration, and object repositioning.
• Inverse rendering: estimation of intrinsic geometry, material, and illumination properties from RGB.
• Generative rendering: synthesis of realistic RGB from incomplete or predicted buffer modalities.

4. Scientific visualization and image-based rendering

Cinema Darkroom applies deferred rendering to in-situ visualization of large-scale datasets. Its CinemaImaging filter accepts a triangulated dataset and a sampling grid of camera locations and calibrations. An Embree-based ray tracer generates depth and scalar images, together with camera metadata, and stores them in a Cinema database (Lukasczyk et al., 2020).

The default configuration stores:

• a depth buffer containing distance to the camera;
• one scalar buffer for each scalar field defined on the input dataset.

Optional data include world-space positions, surface normals, motion-blur information, and additional information for true global illumination. The stored data can represent density, velocity magnitude, vorticity magnitude, height, entropy, integration time, or other selected scalar fields.

During post hoc exploration, the browser-based front end retrieves the image-space buffers and processes them using Three.js, WebGL, WebGL framebuffer objects, and a graph-based shading pipeline. Users can change color maps, scalar transfer functions, SSAO radius, depth-compositing operations, depth-of-field settings, silhouette effects, and filter connections without rerunning the expensive geometry and visibility computation.

The method decouples post hoc interaction from the original number of triangles, cells, particles, or extracted geometric elements. The RMI example represents a contour containing roughly 300 million triangles with one $4096\times2048$ depth image and approximately 100 retained maxima points. The IFC database contains more than 2,000 $2048^2$ images and is approximately $20\times$ smaller than the original unstructured quad mesh, excluding further compression (Lukasczyk et al., 2020).

This decoupling is bounded by view dependence and attribute availability. A new camera generally requires another in-situ G-buffer. New isovalues, streamlines, scalar fields, material properties, translucent layers, or volume-rendering effects cannot generally be recovered unless corresponding data were stored. Cinema Darkroom is primarily designed for fully opaque geometry, and its particle example demonstrates artifacts when screen-space ambient occlusion is applied to highly discontinuous particle depth buffers.

5. G-buffers in temporal and neural rendering

Frame extrapolation

Frame-generation systems use G-buffers to infer how visible surfaces move between frames. Typical inputs include depth, motion vectors, normals, albedo, roughness, metallicity, and object identifiers. Future-frame G-buffers can provide explicit geometry and material information but require an additional future-view geometry pass, which increases engine integration cost, memory use, bandwidth, synchronization, and rendering time.

GFFE defines “G-buffer free” specifically as not rendering G-buffers for extrapolated frames. It still uses current rendered color, current depth, rendered-frame motion vectors, camera poses, and view-projection matrices. It tracks fragments in world space, predicts their positions, forward-warps them into the future view, maintains hierarchical background color/depth buffers, and applies a shading-correction network for shadows, reflections, and other appearance changes (Wu et al., 2024).

The method illustrates both the utility and limitation of G-buffers. Depth and motion are sufficient for many geometric reprojection operations, but they do not provide unseen disocclusions, arbitrary dynamic acceleration, view-dependent material changes, or complete future lighting. GFFE therefore replaces explicit future G-buffers with temporal history, generated depth and motion, adaptive rendering windows, background layers, masks, and learned image-space correction.

Gaussian-splatting inverse rendering

GI-GS augments 3D Gaussian Splatting with learned normals and BRDF/material attributes. Gaussian rasterization produces depth, normal, and material maps. Surface positions are reconstructed from depth and camera parameters. Direct lighting is evaluated through a deferred PBR stage, while diffuse indirect illumination is approximated by depth-buffer ray marching and reuse of direct-light radiance.

The design converts projected Gaussian primitives into a ray-traceable screen-space surface proxy. However, its indirect-light estimator is not an unrestricted unbiased multi-bounce path tracer: indirect lighting is diffuse, radiance is reused from the direct-light image, and indirect specular transport is not modeled. The cubemap variant extends the representation beyond the current view by rendering depth, normals, and direct-light RGB from six directions (Chen et al., 2024).

Diffusion-generated and learned G-buffers

Diffusion-based systems use G-buffers as an intermediate language between text, structured scene information, and RGB synthesis. “Diffusion-based G-buffer generation and rendering” generates albedo, normals, depth, roughness, metallic, irradiance, and optional edit masks from text, then renders an RGB image through a modular neural network. Geometry, material, and lighting are processed in separate branches, while masked irradiance identifies regions requiring lighting regeneration (Xue et al., 18 Mar 2025).

RGBX-Next generalizes the concept to a unified diffusion-transformer framework for inverse and forward rendering. Its explicit modalities include albedo $a$, normal $n$, depth $z$, material properties $m$, diffuse irradiance $E$, and albedo-free direct lighting $$\text{3D Gaussians} \rightarrow \text{G-buffer} \rightarrow \text{direct PBR} \rightarrow \text{indirect-light estimation} \rightarrow \text{final image}.$$0. Clean input modalities are represented as conditioning tokens, while noisy output modalities are denoised through flow matching. The same architecture supports RGB-to-G-buffer estimation and G-buffer-to-RGB synthesis (Zeng et al., 14 Aug 2026).

These systems do not treat G-buffers as complete physically accurate scene descriptions. Predicted buffers may contain ambiguous decompositions, residual shading, uncertain depth, or nonphysical compromises. Conversely, traditionally rendered buffers are aligned and numerically clean but may produce synthetic-looking RGB if used without real-data adaptation. RGBX-Next addresses this by training forward rendering on real RGB videos paired with G-buffers estimated by its inverse renderer.

6. System design, limitations, and related buffer concepts

A G-buffer pipeline requires decisions about representation, generation, storage, consumption, and failure handling. Important design variables include the camera sampling strategy, image resolution, channel set, numerical precision, compression, visibility representation, temporal history, material model, and whether missing values are rejected, synthesized, or left invalid.

The main limitations are structural:

• View dependence: a buffer represents a camera-dependent visible surface.
• Occlusion incompleteness: hidden surfaces are unavailable unless multiple layers or additional views are stored.
• Attribute incompleteness: post hoc operations cannot recover fields that were never generated.
• Bandwidth and memory cost: multiple full-resolution render targets increase storage and data movement.
• Synchronization cost: consumers must wait for buffer writes and resource transitions.
• Geometric approximation: depth-based ray tests and reconstructed normals may not match exact continuous geometry.
• Material ambiguity: RGB-to-G-buffer decomposition is not unique.
• Temporal failure: motion prediction and history reuse fail under abrupt motion, topology changes, or previously unseen disocclusions.
• Lighting limitation: screen-space and learned methods may not reproduce view-dependent BRDF effects, complex transparency, or complete global illumination.

Several non-graphics research areas use analogous buffer concepts but optimize different objectives. Buffered relay selection stores packets at relays so that the best source-relay and relay-destination channels can be selected independently. Max-max relay selection and hybrid relay selection improve coding gain while retaining diversity order $$\text{3D Gaussians} \rightarrow \text{G-buffer} \rightarrow \text{direct PBR} \rightarrow \text{indirect-light estimation} \rightarrow \text{final image}.$$1; finite buffers introduce overflow and underflow constraints (Ikhlef et al., 2011). In online packet routing, a bounded node buffer is modeled as a capacity constraint on a temporal waiting edge in a space-time graph, alongside communication-link capacity (Even et al., 2014). In finite-buffer queueing networks, downstream saturation blocks upstream transmission and can reduce the stability region; occupancy-responsive local policies are analyzed through ODE stability conditions (Wu et al., 2024).

In tabletop rearrangement, a running buffer is an external temporary storage location currently occupied by an object. The minimum running buffer, or MRB, is the minimum peak simultaneous occupancy over a rearrangement plan, and is related to dependency-graph vertex separation rather than to image-space rendering (Gao et al., 2021). In lattice rearrangement, a buffer is instead a temporary holding slot on a robot end-effector; additional buffers reduce travel distance but do not reduce the minimum number of pick-and-swap operations, with diminishing returns for random permutations (Gao et al., 2022).

Graph partitioning provides another distinct use: buffered expansion deletes edges from a component to a small assigned buffer when measuring its residual boundary. An $$\text{3D Gaussians} \rightarrow \text{G-buffer} \rightarrow \text{direct PBR} \rightarrow \text{indirect-light estimation} \rightarrow \text{final image}.$$2-buffered $$\text{3D Gaussians} \rightarrow \text{G-buffer} \rightarrow \text{direct PBR} \rightarrow \text{indirect-light estimation} \rightarrow \text{final image}.$$3-partitioning requires disjoint components and buffers satisfying $$\text{3D Gaussians} \rightarrow \text{G-buffer} \rightarrow \text{direct PBR} \rightarrow \text{indirect-light estimation} \rightarrow \text{final image}.$$4. Its spectral guarantee is linear in the relevant normalized-Laplacian eigenvalue, with a factor $$\text{3D Gaussians} \rightarrow \text{G-buffer} \rightarrow \text{direct PBR} \rightarrow \text{indirect-light estimation} \rightarrow \text{final image}.$$5, thereby avoiding the square-root loss of ordinary higher-order Cheeger inequalities (Makarychev et al., 2023).

Thus, “G-buffer” has a precise primary meaning in rendering—camera-associated screen-space attribute storage—but its broader conceptual theme is the decoupling of an expensive or constrained primary process from later decisions. In graphics, the decoupling separates visibility and geometry from shading and synthesis. In visualization, it separates in-situ geometry processing from post hoc analysis. In generative rendering, it separates structured scene control from learned appearance generation. In other domains, analogous buffers mediate scheduling, routing, stability, manipulation, or graph partitioning, but their state variables, capacity constraints, and performance objectives are not interchangeable with those of graphics G-buffers.