A framebuffer is the region of memory that holds the array of pixel values representing the image currently being produced for display. In raster graphics, every drawing operation ultimately writes into the framebuffer, and the display hardware scans that memory out to the screen. The framebuffer is therefore the endpoint of the rendering pipeline: geometry is transformed, primitives are rasterized into fragments, and those fragments are resolved into pixel values stored in the framebuffer.
The OpenGL specification gives the framebuffer a precise, layered structure. In the OpenGL graphics system (the version 1.0 specification is dated 1 July 1994), the framebuffer is described as a collection of logical buffers: color buffers for displayed pixel values, a depth buffer for visibility (the z-buffer), a stencil buffer, and an accumulation buffer. Each pixel position in the framebuffer holds a set of values across these buffers, and the per-fragment operations stage of the pipeline decides, for each incoming fragment, whether and how it updates them.
That per-fragment stage is where the framebuffer’s central role becomes concrete. Before a fragment is written, the pipeline can perform depth testing against the depth buffer (discarding fragments that are hidden behind nearer geometry), blending the incoming fragment color with the color already stored, and masking or logical operations. NVIDIA’s GPU Gems 2 description of the GeForce 6 pipeline lists exactly this ordering: rasterization, fragment processing, then depth testing and blending, with the final stage being output to the frame buffer.
A key practical technique built on the framebuffer is double buffering. Rather than drawing directly into the buffer being scanned out to the display, a renderer draws the next frame into a separate back buffer; when the frame is complete the back and front buffers are swapped. This prevents the viewer from ever seeing a half-drawn image and is fundamental to smooth, flicker-free animation in interactive graphics. The OpenGL framebuffer model accommodates this by distinguishing front and back color buffers that the application can draw to and swap between.
The framebuffer concept long predates these specifications, going back to early bitmapped displays and dedicated frame buffer memory in graphics terminals and workstations, but the OpenGL model standardized a portable description of it: a structured set of per-pixel buffers, written through a well-defined per-fragment pipeline, that together hold the image the GPU is building. Modern hardware extends the idea with application-created framebuffer objects for rendering to off-screen targets, but the core meaning is unchanged: the framebuffer is the memory that becomes the picture.
This entry uses the OpenGL 1.0 specification date of 1 July 1994 as the anchor, since that document provides the verified primary description of the framebuffer model cited here.