This episode of FairLight TV explores four fundamental graphics programming tricks on the Commodore 64, primarily leveraging the VIC-II chip's $D011 (Y-scroll) register, along with D018 and D000. These techniques allow for impressive stretching, squeezing, and zooming effects previously thought impossible on the 42-year-old hardware, showcasing how new insights continue to push the boundaries of C64 demoscene graphics.
A C64 demo showcasing advanced graphics capabilities.
[
00:03:45
]
The video covers:
Trick 1: Repeated Character Lines: Manipulating the VIC-II's internal counters to create bad line-free screens, enabling effects like full-screen wobblers and pseudo fisheye by changing fonts.
Trick 2: Triggering Bad Lines Every Nth Line: Forcing bad lines early to control pixel line height, crucial for the Y-direction of the Graham Zoomer, and combining with pixel-shifted graphic versions for X-direction effects.
Trick 3: Bad Lines for N Rows, Then Relax for 7: Extending the first pixel line of a character, famously used in the Bitbuster stretcher to simulate full bitmap stretching by selecting shifted font/bitmap copies.
Trick 4: Bad Line Every Nth Line – But Not Always: A newer technique that selectively allows the VIC-II to update its internal counters, leading to advanced squishing effects like the Pernod Squeezer and full bitmap squishers with independent X and Y control.
An overview of the four fundamental graphics tricks discussed in the video.
[
00:05:10
]
This episode acts as a follow-up to a previous discussion on VIC tricks, delving deeper into advanced graphics techniques on the Commodore 64.
Modern C64 Demos: Recently, new demo effects like "Booze Design 2025" by Codeboys & Endians and "The Trip 2025" by Fairlight have emerged, displaying visuals previously considered impossible on the C64.
A C64 demo showcasing advanced graphics capabilities.
[
00:03:45
]
The Commodore 64 is a 42-year-old computer with no hardware-accelerated graphics (no built-in scaling or zooming).
The Core Registers: The key to these advanced effects lies in manipulating the $D011 (Y-scroll) register, primarily focusing on its three least significant bits, along with $D018 and $D000.
These manipulations allow for "impossible" stretching, squeezing, and zooming of graphics, effects never intended by the hardware designers.
Four Fundamental Tricks: The presentation will explain four underlying techniques that make these advanced effects possible, tracing their development from 1988 to 2025.
An overview of the four fundamental graphics tricks discussed in the video.
[
00:05:10
]
Screen Composition: The C64 screen consists of an outer border and an inner display area.
The inner screen operates in either text mode (40x25 characters) or bitmap mode (320x200 pixels).
While modes differ in pixel storage and color combination, the number of pixels displayed is generally the same.
VIC-II and CPU Interaction:
Normally, the VIC-II chip and CPU work in a synchronized lock-step, each accessing memory during different halves of a cycle.
Bad Lines [00:06:54]: Periodically, the VIC-II needs to access more memory (e.g., to read character pointers and colors), taking both memory access phases and "locking out" the CPU. These CPU-stalling moments are called "bad lines," resulting in a loss of 40 CPU cycles.
Bad lines typically occur at the start of each 8-pixel character row.
Internal Counters [00:08:11]: The VIC-II maintains internal counters for pixel rows (0-7) and character rows (X-axis) to manage what bits to display.
Counter Increment: Crucially, the VIC-II increments these internal counters in a two-step fashion on the seventh pixel row, just before a new bad line. This split-phase increment provides a small window for coders to interrupt the process.
Trick 1: Repeated Character Lines (Graphics without Bad Lines) [00:09:19]
Mechanism: This technique involves writing to $D011 at a precise moment (pixel row 7, cycle 52-56) just before the VIC-II would perform its next bad line read.
Diagram illustrating the repeated character lines trick (Trick 1), showing how bad lines are skipped to repeat character data.
[
00:09:51
]
By setting $D011 (specifically the least significant 3 bits representing the current pixel row) to 7, the programmer "tricks" the VIC-II into believing it has just completed a bad line.
The VIC-II then skips the actual bad line, but its internal character/bitmap pointers are not updated.
This causes the VIC-II to repeatedly display the same character or bitmap data from the previous bad line, effectively eliminating CPU-stalling bad lines for the subsequent 7 pixel rows.
To maintain the effect, $D011 must be reset sometime after the next expected bad line.
Advantages:
Bad Line-Free Screen Mode: Frees up CPU cycles for other computations, as the CPU is no longer stalled by bad lines.
Efficient Graphics Updates: Large portions of the screen can be updated by simply changing the initial 40 bytes that define the characters or bitmap data that is being repeated.
Applications:
Full-Screen Wobbler [00:16:16]: By changing the character set (font) for each row (up to 25 fonts can be used to cover the entire screen vertically), a wobbly, full-screen distortion effect can be created with minimal CPU overhead.
A full-screen wobbler effect, an application of the repeated character lines trick.
[
00:16:38
]
Pseudo Fisheye [00:17:18]: This effect uses 25 different fonts, each containing a vertically scaled version of the main image. By selecting the appropriate font for each character row, a fisheye lens distortion is created. The speed of the animation comes from only updating the 40 bytes pointing to the correct fonts.
Slingerbobs [00:19:50]: Utilizes the repeated character lines technique, painting "bobs" onto 25 different fonts. A table is indexed to quickly move these bobs vertically, and color registers are updated within the interrupt code to add vibrancy.
The slingerbobs effect, demonstrating rapid full-screen movement using repeated character lines.
[
00:20:18
]
Trick 2: Trigger Bad Line Every Nth Line (N ∈ [1, 7]) [00:22:01]
Mechanism: Unlike Trick 1, this doesn't require super-tight timing and can be set from a standard raster interrupt.
![Diagram explaining Trick 2, where bad lines are triggered every Nth line (N ∈ [1, 7]), leading to vertical compression.][8]
By actively setting the lower 3 bits of $D011 to a value N (e.g., 7 for 7 lines), a bad line is forced after N pixel lines.
Because the VIC-II is forced to do a bad line before it naturally increments its internal character/bitmap counters (which happens on pixel line 7), these counters effectively "stick."
This means the VIC-II restarts drawing the same pixel row (e.g., pixel row 0) from the same character/bitmap data repeatedly, but the line count is reset.
This allows programmers to control how many pixel lines of a character or bitmap are displayed before restarting the drawing of that character/bitmap, enabling vertical squeezing or stretching.
A basic screen showing the effect of triggering bad lines every Nth line, resulting in vertical distortion.
[
00:24:04
]
An extended diagram of Trick 2, highlighting that internal counters are not updated when bad lines are forced early.
[
00:24:58
]
Squeeze Scroll: This technique controls how many pixels of each character line are shown, selecting new fonts or screens for each line to create an impressive visual.
A squeeze scroll effect, an application of Trick 2 that compresses text vertically.
[
00:28:06
]
Y-Direction Zoom [00:30:22]: The Graham Zoomer uses this technique to create vertical zoom by smoothly varying the N value (e.g., from 7 down to 1 or any fractional value in between) across the screen lines. This effectively stretches or compresses the vertical display.
Diagram illustrating the Y-direction mechanism of the Graham Zoomer, by controlling the number of lines between bad lines.
[
00:30:49
]
X-Direction Zoom [00:32:51]: More complex, this involves preparing multiple pre-shifted versions of the graphics data (e.g., 4 or 8 versions, each shifted by one pixel). By strategically selecting which pre-shifted graphic version to display for each character column, a horizontal stretching or squeezing effect is achieved. The "Beyond Force" demo from 1992 was an early and impressive example.
Diagram illustrating the X-direction mechanism of the Graham Zoomer, showing pre-shifted graphic versions to create horizontal scaling.
[
00:34:41
]
Mipmap Graham Zoomer [00:39:11]: To reduce visual "coarseness" or flickering at extreme zoom levels (due to pixel granularity), the concept of mipmapping (from 3D graphics) is applied. Multiple pre-zoomed-out versions of the graphic are stored in memory. The program switches between these versions based on the zoom level, providing smoother transitions.
Dynamic Graham Zoomer [00:40:36]: This combines both X and Y Graham zoomer techniques. It allows "unlimited bobs" (small sprites) to be drawn and dynamically zoomed across the screen, creating impressive full-screen effects. This effect does not require cycle-perfect timing, utilizing raster interrupts to control the updates.
A logo squisher effect, combining X and Y scaling from the Graham Zoomer technique.
[
00:38:17
]
Trick 3: Bad Lines for N Rows, then Relax for 7 [00:42:45]
Mechanism: This technique involves forcing a series of bad lines for N consecutive rows, effectively stretching out the first pixel line of a character/bitmap.
Diagram illustrating Trick 3, where bad lines are forced for N rows before a normal 8-line segment, stretching the first pixel line.
[
00:43:16
]
After these N stretched lines, the programmer "relaxes" for 7 rows, allowing the VIC-II to naturally complete its 8-pixel character row and increment its internal counters (the "little X" event). This allows new character/bitmap data to be read for the next segment of the display.
This is typically implemented in a tight loop for the initial N lines, followed by a raster interrupt to set up the "relaxed" section.
Applications:
Cheap Stretchers [00:44:20]: Simple and efficient effects where only the first pixel line of each character block is stretched. These are visually appealing despite their simplicity and low CPU cost.
Bitbuster Stretcher [1988] [00:45:18]: A groundbreaking technique from 1988, capable of stretching every pixel line of a bitmap picture.
How it Works: To achieve this, multiple copies of the desired character/bitmap are created in memory, each shifted upwards by an increasing number of pixels. By dynamically selecting the appropriate "shifted" font/bitmap for each pixel line that needs to be displayed, the illusion of full vertical stretching is created.
This specific technique requires extremely precise, cycle-perfect timing, making it challenging to implement.
Examples: Bitmap logo stretchers, DYCP (Do-Your-Own-Character-Picture) stretchers, and mega scroll stretchers. These can display full-screen effects with many colors and often leave enough raster time for additional effects like raster bars, indicating their efficiency.
Trick 4: Bad Line Every Nth Line - But Not Always [01:02:30]
Mechanism: This is a more recently explored variation (circa 2024/2025) of the bad line manipulation.
Diagram explaining Trick 4, which involves selectively triggering bad lines to allow periodic updates of VIC-II internal counters.
[
01:03:03
]
It involves triggering bad lines within the typical 7-pixel line window, similar to Trick 2, but selectively.
Periodically, the programmer allows an entire 8-line cycle to complete normally. This allows the VIC-II's internal character/bitmap counters (the "little X") to update, fetching new data from memory.
This technique produces a "slight stretch" but, crucially, allows the underlying character or bitmap pointers to advance, enabling effects that combine stretching with bitmap updates.
Applications:
Colorcycling Stretcher [01:03:57]: Combines the selective bad line stretching with complex color cycling patterns across the screen.
Jarring Dithered Stretcher [01:04:32]: An effect that creates a visually distorted, stretched image, often combined with dithering.
A jarring dithered stretcher effect, an application of Trick 4 for visually distorted images.
[
01:05:17
]
Pernod Squeezer [2025] [01:05:22]: This technique is a significant breakthrough in vertical bitmap compression/stretching. It uses 6 separate bitmap pictures (each 22 characters high) and strategically triggers 7-pixel line stretches followed by an 8-pixel "catch-up" line. This creates a highly compressed image where the different bitmap portions are seamlessly interleaved. The main limitation is that all parts of the image must share the same D800 colors.
Diagram illustrating the Pernod Squeezer technique, showing how multiple bitmap sections are interleaved for extreme vertical compression.
[
01:07:09
]
Bitmap Squisher (Fairlight 2025) [01:09:49]: This is a pinnacle effect, combining the Pernod Squeezer's Y-stretching with the Graham Zoomer's X-direction logic.
It stores 8 pre-compressed versions of a logo for the X-axis manipulation.
By independently controlling the Y-stretching (Pernod Squeezer) and X-stretching (selecting from the 8 pre-compressed versions), truly orthogonal (independent X and Y) stretching and squeezing of full-color bitmap graphics are achieved.
These effects were considered impossible until very recently and demonstrate ongoing innovation on the C64.
The video concludes by reiterating the four main categories of VIC-II graphics tricks:
A summary of the four VIC-II graphics manipulation techniques for stretching, squeezing, and zooming.
[
01:11:56
]
Repeated character lines (bad line-free, full-screen distorters, rapid movement).
Trigger bad line every Nth row (character line squeezers, Graham zoomer).
Trigger bad line for N rows, then relax for 7 rows (cheap stretchers, Bitbuster stretcher).
Trigger bad line every Nth row, but not always (jarring stretchers, Pernod squeezer, squishy bitmaps).
Many of these techniques, especially the first three, are "old school" but still offer unexplored potential. The fourth trick represents a significant, more recent insight.
These advanced effects are not based on new hardware tricks but rather on clever insights into the fundamental operation of the VIC-II chip and innovative ways of arranging and presenting data in memory.
The continued discovery of such techniques on a decades-old machine highlights the depth of its hardware and the ingenuity of its programmers.
