Developers could now manipulate geometry dynamically on the GPU.
But gradually, the magic happened. In the fall of 2003, a developer at NVIDIA wrote a simple GLSL shader:
Released by the Architecture Review Board (ARB) in 2004, OpenGL 2.0 was the milestone update that fundamentally transitioned real-time computer graphics from a rigid, hardcoded pipeline into a flexible, programmable sandbox. The Fixed-Function Era vs. The Programmable Pipeline
He realized they didn't need to replace the fixed-function pipeline. They needed to subsume it. The old way would become just one special, pre-written program among infinite possibilities. opengl 20
The core of OpenGL 2.0 was a revolutionary new architecture: the . For the first time, developers could write short programs called "shaders" that would run directly on the GPU. This gave programmers unprecedented control, allowing them to define exactly how vertices and pixels were processed, opening the door to infinite visual possibilities.
Between these, the (triangle setup) stayed fixed hardware, but shading became Turing-complete.
[ Application CPU Data ] │ ▼ ( Vertex Buffer ) │ ▼ ┌─────────────────────────────────┐ │ Vertex Shader (GLSL) │ <-- Programmable: Handles position & math └─────────────────────────────────┘ │ ▼ ( Primitive Assembly ) │ ▼ ( Rasterization Unit ) │ ▼ ┌─────────────────────────────────┐ │ Fragment Shader (GLSL) │ <-- Programmable: Handles colors & textures └─────────────────────────────────┘ │ ▼ ( Per-Fragment Testing ) <-- Scissor, Depth, Stencil, Blending │ ▼ [ Framebuffer / Screen ] Historical Context: The Shader Wars Developers could now manipulate geometry dynamically on the
OpenGL 3.0 (2008) kept compatibility but added deprecation marks. OpenGL 3.1 (2009) removed the fixed pipeline entirely, forcing everyone to use shaders. OpenGL 3.2 introduced geometry shaders, and 4.0 brought tessellation. Yet, the DNA of modern OpenGL remains the one introduced in version 2.0: .
If you run a 3D application in a web browser using WebGL 1.0, you are fundamentally running OpenGL 2.0 under the hood. WebGL 1.0 is a JavaScript wrapper strictly based on (the embedded systems variant of OpenGL 2.0). Because WebGL 1.0 has near-universal compatibility across billions of smartphones, tablets, and legacy PCs, writing OpenGL 2.0-style shaders remains a vital skill for web developers. 2. Embedded Systems and IoT
OpenGL 2.0 arrived later than DirectX 9 (late 2002), but it offered cleaner abstraction: The Fixed-Function Era vs
Before OpenGL, 3D graphics were a fragmented and proprietary world. The story begins in 1982 when Silicon Graphics (SGI) revolutionized workstations with its hardware graphics pipeline, accessed via a proprietary API called . By 1991, SGI recognized the potential for an open, cross-platform standard. This led to the creation of OpenGL and the establishment of the OpenGL Architecture Review Board (ARB) to manage its evolution.
Despite its power, OpenGL 2.0 retained much of the legacy fixed-function baggage. The specification was a hybrid beast: you could still call glBegin() / glEnd() and glLightfv() alongside shaders. This flexibility was a blessing for migrating legacy code but a curse for clean, modern design.