Blitter
Dedicated circuit for rapid memory data movement and modification.
A blitter is a dedicated circuit—either a separate coprocessor or a logic block built into a microprocessor—designed to move and alter data in a computer's memory quickly. It can shift large blocks of data between memory locations much faster than the CPU alone, and it works in parallel with the CPU, leaving the processor free to handle more complex tasks. The term "blitter" comes from the "bit blit" operation (short for bit-block transfer) introduced in the 1973 Xerox Alto.
A blit operation goes beyond a simple memory copy. It can handle data that isn't aligned to byte boundaries (hence the "bit" in bit blit), manage transparent pixels that shouldn't overwrite the destination, and combine source and destination data in various ways. Over time, blitters have mostly been replaced by programmable graphics processing units.
In the 1970s and 1980s, most home computers and IBM PC compatibles (through the mid-1990s) lacked hardware-accelerated raster graphics. Their frame buffers lived in CPU-accessible memory, and drawing was done entirely in software. For tasks like compositing a small image into a larger one (common in video games) or drawing a filled rectangle, the CPU had to spend many cycles fetching and decoding short loops of load and store instructions. Some early systems used dedicated hardware like sprites or text-drawing circuits to offload this work, but those features largely vanished as the market shifted toward business applications in the 1980s.
To save memory, systems often offered graphics modes with lower resolution or fewer colors. A black-and-white display, for instance, uses only one bit per pixel, packing eight pixels into a single byte. Changing a single pixel then required reading the byte, updating the correct bit, and writing it back—a process that involved extra shifting and masking by the CPU. Blitters were created to take over these repetitive tasks—copying data or filling memory blocks—faster than the CPU could, and they could handle tricky cases like transparent pixels or non-byte-aligned data that would be much slower to code by hand.
Key milestones in blitter history include the 1973 Xerox Alto, which implemented bit block transfer in microcode (designed by Dan Ingalls), making it much faster than a software version. In 1978, the Bally Astrocade home console had primitive blitter hardware.
- Origin
- 1973 Xerox Alto, bit blit term originated
- First use of term blitter in patent
- 1985, Commodore-Amiga, Inc.
- Notable performance figure
- 910 KB/second (Robotron: 2084 blitter, 1982)
- Notable implementations
- Amiga (1985), Atari ST (1987), TMS34010 (1986), IBM 8514/A (1987), Atari Jaguar (1993)
Lore & Background
In computers without hardware accelerated raster graphics, which includes most 1970s and 1980s home computers and IBM PC compatibles through the mid-1990s, the frame buffer was commonly stored in CPU-accessible memory. Drawing was accomplished by updating the frame buffer via software. For fundamental graphics routines, large amounts of memory needed to be manipulated, and many cycles were spent fetching and decoding short loops of load/store instructions. Some systems had dedicated hardware to offload this task, mostly in the form of sprites or dedicated text drawing systems, but these largely disappeared as the market turned to business applications in the 1980s.
Blitters were developed to offload repetitive tasks of copying data or filling blocks of memory faster than possible by the CPU. This could be done in parallel with the CPU and also handle special cases such as skipping over pixels marked as transparent or handling data that isn't byte-aligned. A typical use for a blitter is the movement of a bitmap, such as windows and icons in a graphical user interface or images and backgrounds in a 2D video game. A blit operation is more than a memory copy, because it can involve data that's not byte aligned, handling transparent pixels, and various ways of combining the source and destination data.
Notable historical implementations include the 1973 Xerox Alto with a bit block transfer instruction in microcode, the 1982 Robotron: 2084 arcade game with two blitter chips allowing up to 80 simultaneously moving objects, the 1985 Amiga personal computer with a blitter coprocessor, and the 1986 TMS34010 processor with built-in PIXBLT instructions. The Atari ST shipped with a blitter chip in 1987, and the Atari Jaguar console included blitter hardware in 1993. Blitters have largely been superseded by programmable graphics processing units.
Reader's Guide
Blitters were significant because they offloaded repetitive memory manipulation tasks from the CPU, allowing parallel operation and freeing the CPU for other work. They were especially important in the era before hardware-accelerated raster graphics, when frame buffers were stored in CPU-accessible memory and drawing was done via software. Blitters could handle special cases that would be significantly slower if coded by hand, such as skipping transparent pixels or working with non-byte-aligned data. The article notes that blitters have largely been superseded by programmable graphics processing units, but their legacy includes the fundamental concept of hardware-accelerated bit-block transfer that underlies modern GPU operations. The VESA Group introduced a standardized way to access hardware Bit Block transfers with VBE/accelerator functions in 1996 on IBM PC compatibles, marking a late standardization effort before GPUs became dominant.
Did You Know?
- The term 'blitter' comes from the 'bit blit' operation of the 1973 Xerox Alto, which stands for bit-block transfer.
- The first US patent filing to use the term 'blitter' was 'Personal computer apparatus for block transfer of bit-mapped image data,' assigned to Commodore-Amiga, Inc. in 1985.
- The Robotron: 2084 arcade game from 1982 used two blitter chips to achieve up to 80 simultaneously moving objects at roughly 910 KB/second.
- The TMS34010 processor, introduced in 1986, served as both CPU and GPU for arcade games including Mortal Kombat and NBA Jam.
Frequently Asked Questions
What is a blitter in PC hardware?
A blitter is a dedicated circuit—either a standalone coprocessor or a logic block fused into the microprocessor—built specifically to move and modify data in memory at high speed. It operates in parallel with the main CPU, freeing the processor to handle more complex computation while the blitter handles bulk data transfers.
Where does the term 'blitter' come from?
The name traces back to the 'bit blit' operation (short for bit-block transfer) that first appeared on the 1973 Xerox Alto. Commodore-Amiga, Inc. appears to have been the first company to use the word 'blitter' in a patent, filing one in 1985.
How does a blit operation differ from a simple CPU memory copy?
A blit can handle data that isn't aligned to byte boundaries, and it shifts large blocks between memory locations far faster than the CPU managing the transfer alone. Because it works concurrently with the processor, the CPU remains available for logic and other tasks during the transfer.
What are some notable blitter implementations in PC hardware history?
Notable examples include the Amiga (1985), TMS34010 (1986), Atari ST (1987), IBM 8514/A (1987), and Atari Jaguar (1993). An early standout was the Robotron: 2084 blitter from 1982, which achieved a throughput of 910 KB/second.
Why were blitters important for 8-bit and 16-bit era computers?
They let relatively modest CPUs perform graphics-intensive screen updates and large data transfers at speeds the processor simply couldn't match on its own. By offloading bulk memory work to a parallel circuit, the main processor stayed free for game logic, audio, and user input handling.
More in PC Hardware, Part 3 1-24
Spotted an error? Know more?
Reader corrections go straight into our review queue. Suggest an edit · How this site is sourced