How the Commodore Plus/4 Rendered High-Resolution Graphics

The Commodore Plus/4 utilized a specialized integrated circuit known as the TED chip to manage its display output, differing significantly from the VIC-II found in the Commodore 64. This article explores the technical architecture behind the system’s 320x200 pixel capability, detailing the memory mapping, color limitations, and the specific bitmap modes available to developers. Readers will gain insight into how the CPU communicated with the video hardware to produce images without the aid of hardware sprites.

At the heart of the Plus/4 graphics system was the 7360 or 8360 Text Editing Device (TED). Unlike its predecessor, the VIC-II, the TED chip integrated the video controller, dynamic memory access controller, and interval timer into a single unit. This consolidation allowed for a more streamlined architecture but imposed specific constraints on how graphics were processed. The chip was responsible for fetching pixel data from the system RAM and converting it into video signals for the monitor, handling both text and high-resolution bitmap modes directly.

The standard high-resolution mode offered a display resolution of 320x200 pixels. To achieve this, the TED chip divided the screen into character cells of 8x8 pixels. In the high-resolution bitmap mode, each pixel within these cells could be individually addressed, allowing for detailed imagery. However, the system relied on a shared memory architecture where the main CPU and the video chip accessed the same RAM pool. The TED used Direct Memory Access (DMA) to fetch graphics data during the horizontal and vertical blanking intervals, ensuring the processor did not interfere with the video signal generation.

Color rendering on the Plus/4 was distinct from other Commodore machines of the era. While the TED chip supported a palette of 121 colors, the high-resolution bitmap mode was limited to two colors per 8x8 character cell. One color served as the background for the cell, and the other served as the foreground for the pixels within that block. This limitation was similar to the attribute clash found in the ZX Spectrum, requiring developers to plan graphics carefully to avoid unwanted color bleeding between adjacent objects.

Another critical difference in the Plus/4 rendering process was the absence of hardware sprites. The Commodore 64 could move objects independently of the background using sprite logic built into the VIC-II, but the TED chip lacked this feature. Consequently, all high-resolution graphics, including moving characters or objects, had to be drawn directly into the bitmap memory by the CPU. This placed a heavier burden on the 7501 or 8501 processor, requiring efficient code to update the screen buffer without causing flicker or slowing down the game logic.

Memory mapping for graphics was fixed within the system’s address space. The screen memory typically resided in the range of $0400 to $07FF. When in bitmap mode, this area stored the actual pixel data, where each bit represented a pixel on the screen. Color information was stored in a separate nibble associated with each 8x8 block, telling the TED chip which two colors from the palette to apply to that specific section of the display. This structure allowed for rapid screen updates but required precise management of memory to prevent corruption of the video output.

In summary, the Commodore Plus/4 rendered high-resolution graphics through the dedicated TED chip, which managed a 320x200 pixel grid using a bitmap system constrained by two colors per 8x8 block. The lack of hardware sprites meant the CPU handled all graphical updates directly from the system RAM. While these technical specifications presented challenges for developers, they defined the unique visual style and performance characteristics of the Plus/4 platform.