Theory
One program, many devices
Imagine writing a graphics program that must run on many different screens, printers, and graphics cards, each with its own hardware. Without some common ground, you would have to rewrite the drawing code for every device. That is unworkable.
Graphics standards solve this. A standard is an agreed specification, a common set of graphics commands, that many devices and systems support. Write your program to the standard, and it works across all of them. This closing lesson of the unit explains what graphics standards are and why they matter for portability.
Theory
What a graphics standard provides
A graphics standard defines a common interface: the set of functions and commands a programmer uses to produce graphics, independent of the specific hardware underneath. The program calls the standard's commands ('draw a line', 'fill a polygon'), and the standard's implementation translates those into whatever the actual device needs.
This gives device independence and portability: the same graphics code produces the same results on different machines, and a programmer's skills transfer between systems. Standards also make it easier for hardware makers (support the standard, and all conforming software runs) and for teaching (learn the standard, not a hundred device quirks).
At a glance
| Standard / API | Note |
|---|---|
| GKS (Graphical Kernel System) | An early standard for 2D graphics |
| PHIGS | Programmer's Hierarchical Interactive Graphics System, for structured 3D |
| OpenGL | A widely used cross-platform graphics API |
| DirectX | Microsoft's graphics and multimedia API (Windows) |
Formula
The point is portability and independence
Whatever the specific standard, the core benefit is the same: write once, run on many devices. By programming against a standard rather than a particular piece of hardware, your graphics application becomes portable and the hardware becomes interchangeable, as long as each device supports the standard.
This is the same idea you have met throughout computing: agree on a common interface, and independent parts can cooperate (like TCP/IP for networks, or the OSI model). Graphics standards apply it to drawing, freeing software from the details of any one device. Learn the standard, and your code, and your knowledge, travel.
Quiz
What is the main purpose of a computer graphics standard like OpenGL?
- To make graphics files smaller
- To provide a common set of graphics commands so a program can run across different hardware without being rewritten (portability and device independence)
- To replace the need for a graphics card
- To store images as vectors
Show the answer
To provide a common set of graphics commands so a program can run across different hardware without being rewritten (portability and device independence)
A graphics standard provides a common interface, an agreed set of graphics commands, so that a program written to the standard runs across different devices without rewriting, giving portability and device independence. Option A confuses standards with file compression; standards are about a programming interface, not shrinking files. Option C is wrong: a standard works WITH the graphics hardware (translating commands to it), it does not remove the need for it. Option D describes a file storage choice (vector vs raster), a different topic; a standard is an API, not a file format. The core value is write-once, run-on-many-devices.
Think first
Why is programming to a standard better than programming to specific hardware?
Why not just write graphics code tuned to one particular device? What does the standard buy you? Then tap.
Show the answer
Because tying your code to specific hardware makes it FRAGILE and UNPORTABLE, while programming to a standard makes it work everywhere the standard is supported, and lets both software and hardware evolve independently. If you wrote graphics directly for one particular graphics card or screen, your program would only run on that exact hardware; a different device, a newer card, or another platform would require rewriting the drawing code, an enormous, repeated effort, and your users would be locked to specific machines. By programming to a STANDARD like OpenGL, you call a common set of commands, and each device provides its own implementation (a driver) that translates those commands into what its hardware needs. So the same graphics program runs on many different cards and systems unchanged, because they all understand the standard. This decouples your software from the hardware: hardware makers can build new, faster devices that still run all existing standard-based software (just implement the standard), and software developers can target a huge range of devices by writing once. It also concentrates expertise, driver writers optimise the standard's commands for their hardware, so your app gets that performance for free. And it makes knowledge portable: learn the standard and you can write graphics for any conforming device. This is exactly the interface-versus-implementation principle that runs through computing (like an API, or a network protocol): agree on the interface, and the parts on either side can change freely. Standards turn 'works on this one device' into 'works everywhere', which is why they are foundational to graphics programming. Target the standard, not the metal.
Summary
Key takeaways
- A graphics standard is an agreed specification: a common set of graphics commands supported across devices.
- It gives device independence and portability, the same graphics code works on different hardware.
- The program calls the standard's commands, and its implementation translates them for the actual device.
- Known standards and APIs: GKS, PHIGS, OpenGL (cross-platform), DirectX (Microsoft/Windows).
- Standards help software (write once, run on many), hardware makers (support the standard, run all conforming apps), and learners.
- This is the interface-versus-implementation idea applied to graphics, like network protocols for networking.
- Memory hook: program to the standard, not to specific hardware, so your code runs on many devices.