January 15, 2026
Bringing 10PRINT to the Apple II with Applesoft BASIC and Lo-Res graphics, exploring both text-mode and graphical approaches to this iconic one-liner.
May 16, 2025
Implementing 10PRINT on a KIM-1 clone (PAL-II) in both Microsoft BASIC and 6502 assembly, displaying the maze on the 7-segment LED display.
March 26, 2025
Running 10PRINT and 100 Doors on the Clockwork Pi PicoCalc, a retro-inspired Raspberry Pi Pico handheld running PicoMite BASIC.
January 16, 2025
A visual exploration of the classic 100 Doors programming problem implemented in PICO-8, featuring animated circles that show the door-toggling pattern in action. This version pays homage to the VIC-20 implementation while leveraging PICO-8’s built-in game loop for smooth animation and visual feedback. Complete with code explanations and comparison to the classic VIC-20 version.
January 10, 2025
Continuing the exploration of 10PRINT, we look at how to implement the 10 Print algorithm on the Pico-8 platform.
July 30, 2024
A head-to-head performance comparison of the classic 10PRINT maze algorithm implemented in Rust and C, with benchmarks measuring millions of iterations.
April 19, 2024
Exploring wAx, a native assembler for the VIC-20 that integrates with BASIC. Includes examples implementing 10PRINT and Fibonacci in assembly directly on the machine.
April 5, 2024
Implementing the classic 10PRINT maze algorithm on the HP-42s calculator using RPN programming. Works on SwissMicros DM42 and Free42 emulators too.
November 30, 2023
Implementing 10PRINT on the TI-92 calculator using TI-BASIC. Also covers Python versions on the Numworks and TI-nspire calculators.
June 28, 2023
Rockwell International was a powerhouse of the 1970s and 80s.
The Rockwell AIM 65 computer, also known as the Advanced Interactive Microcomputer 65, is an early microcomputer produced by Rockwell International in the late 1970s. It was essentially a development system, intended primarily for engineers, educators, and hobbyists, and was named for its built-in alphanumeric keyboard and LED display.

The AIM 65 was built around the 6502 microprocessor, the same chip used in popular systems like the Apple II, Commodore PET, and Atari 2600. The AIM 65 was designed as a single-board computer, with the processor, memory, input, and output all integrated into one circuit board.
January 15, 2026
Bringing 10PRINT to the Apple II with Applesoft BASIC and Lo-Res graphics, exploring both text-mode and graphical approaches to this iconic one-liner.
January 15, 2026
Bringing 10PRINT to the Apple II with Applesoft BASIC and Lo-Res graphics, exploring both text-mode and graphical approaches to this iconic one-liner.
December 17, 2025
Visualizing sorting algorithms in real-time on the Commodore 64 using PETSCII characters. Three classic algorithms rendered as animated bar charts in BASIC.
May 30, 2025
Exploring three different maze generation algorithms on the Commodore 64: Depth-First Search, Randomized Prim’s, and the classic 1981 algorithm from Compute! magazine.
March 26, 2025
Running 10PRINT and 100 Doors on the Clockwork Pi PicoCalc, a retro-inspired Raspberry Pi Pico handheld running PicoMite BASIC.
March 21, 2024
Solving the classic McNuggets Problem in Commodore BASIC: what’s the largest number of nuggets you can’t buy with 6, 9, and 20 packs?
March 13, 2024
Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
June 28, 2023
Rockwell International was a powerhouse of the 1970s and 80s.
The Rockwell AIM 65 computer, also known as the Advanced Interactive Microcomputer 65, is an early microcomputer produced by Rockwell International in the late 1970s. It was essentially a development system, intended primarily for engineers, educators, and hobbyists, and was named for its built-in alphanumeric keyboard and LED display.

The AIM 65 was built around the 6502 microprocessor, the same chip used in popular systems like the Apple II, Commodore PET, and Atari 2600. The AIM 65 was designed as a single-board computer, with the processor, memory, input, and output all integrated into one circuit board.
January 15, 2026
Bringing 10PRINT to the Apple II with Applesoft BASIC and Lo-Res graphics, exploring both text-mode and graphical approaches to this iconic one-liner.
December 17, 2025
Visualizing sorting algorithms in real-time on the Commodore 64 using PETSCII characters. Three classic algorithms rendered as animated bar charts in BASIC.
May 30, 2025
Exploring three different maze generation algorithms on the Commodore 64: Depth-First Search, Randomized Prim’s, and the classic 1981 algorithm from Compute! magazine.
May 20, 2025
Implementing 16-bit unsigned AND operations in Commodore BASIC using two’s complement to work around the signed integer limitation.
May 16, 2025
Celebrating the gloriously absurd cover of ‘FORTH on the Atari’—possibly the greatest unintentionally funny book cover ever created.
May 16, 2025
Implementing 10PRINT on a KIM-1 clone (PAL-II) in both Microsoft BASIC and 6502 assembly, displaying the maze on the 7-segment LED display.
March 26, 2025
Running 10PRINT and 100 Doors on the Clockwork Pi PicoCalc, a retro-inspired Raspberry Pi Pico handheld running PicoMite BASIC.
January 16, 2025
A visual exploration of the classic 100 Doors programming problem implemented in PICO-8, featuring animated circles that show the door-toggling pattern in action. This version pays homage to the VIC-20 implementation while leveraging PICO-8’s built-in game loop for smooth animation and visual feedback. Complete with code explanations and comparison to the classic VIC-20 version.
January 10, 2025
Continuing the exploration of 10PRINT, we look at how to implement the 10 Print algorithm on the Pico-8 platform.
September 13, 2024
We draw some dragon curves with Logo on the Commodore 64 inspired by Jurassic Park
July 30, 2024
A head-to-head performance comparison of the classic 10PRINT maze algorithm implemented in Rust and C, with benchmarks measuring millions of iterations.
April 19, 2024
Exploring wAx, a native assembler for the VIC-20 that integrates with BASIC. Includes examples implementing 10PRINT and Fibonacci in assembly directly on the machine.
April 5, 2024
Implementing the classic 10PRINT maze algorithm on the HP-42s calculator using RPN programming. Works on SwissMicros DM42 and Free42 emulators too.
March 21, 2024
Solving the classic McNuggets Problem in Commodore BASIC: what’s the largest number of nuggets you can’t buy with 6, 9, and 20 packs?
March 13, 2024
Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.
January 11, 2024
Optimizing a simple counting loop on the 6502, progressing from slow BASIC to increasingly faster assembly implementations. A practical guide to 6502 optimization.
January 3, 2024
Building and verifying the Commodore 64 SID chip’s 23-bit LFSR in hardware on a breadboard and comparing the output against the actual SID chip.
December 21, 2023
An introduction to Linear Feedback Shift Registers: how they work, building one on a breadboard with shift registers and XOR gates, and implementing them in Python and Rust.
December 19, 2023
Commodore BASIC 2.0
A lot of fun with binary numbers can be had by printing them to the screen. This is a quick post to show how to do that with Commodore BASIC 2.0. This is a follow up to Quick Post: XOR in Commodore BASIC 2.0.
We’ll be using both of these in upcoming posts, so it’s good to have them handy.
5 REM PRINT ALL 8 BIT NUMBERS IN BINARY
10 FOR N= 0 TO 255
20 FORI=7 TO 0 STEP-1
25 B=0
30 IF N AND 2^I THEN B=1
40 PRINTMID$(STR$(B),2);
50 NEXT
60 PRINTN
70 NEXT
This prints all the numbers from 0 to 255 in binary. It’s a little slow, but it’s easy to understand and fun to watch.
November 30, 2023
Implementing 10PRINT on the TI-92 calculator using TI-BASIC. Also covers Python versions on the Numworks and TI-nspire calculators.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
October 12, 2023
Solving the classic N-Queens puzzle using backtracking. Covers both iterative and recursive approaches with implementations on the Commodore 64.
September 8, 2023
Implementing the Rail Fence Cipher on the Commodore 64 and TI 99/4A. A fun transposition cipher for secret messages with kids.
June 28, 2023
Rockwell International was a powerhouse of the 1970s and 80s.
The Rockwell AIM 65 computer, also known as the Advanced Interactive Microcomputer 65, is an early microcomputer produced by Rockwell International in the late 1970s. It was essentially a development system, intended primarily for engineers, educators, and hobbyists, and was named for its built-in alphanumeric keyboard and LED display.

The AIM 65 was built around the 6502 microprocessor, the same chip used in popular systems like the Apple II, Commodore PET, and Atari 2600. The AIM 65 was designed as a single-board computer, with the processor, memory, input, and output all integrated into one circuit board.
May 5, 2023
Modern and retro mix
One of my favorite peices of retro clone hardware is Bob Corsham’s KIM-1 Clone. I’ve featured it many places like the 6502 speed series.
I have the latest model of this board, and he made an interesting design choice. It actually has an FTDI chip on board and you use that via USB to connect via a modern computer with an FTDI driver. This is very convenient for working with a modern computer, but then eliminates the ability to use a real serial port.
March 2, 2023
Driving LEDs from the VIC-20 and KIM-1 USR ports. Binary counting in the real world with vintage hardware.
January 26, 2023
Exploring the elegant maze generator from Compute! magazine (December 1981). A line-by-line breakdown of how this classic BASIC algorithm works.
December 1, 2022
Writing code to validate Pilish text—prose where word lengths match the digits of Pi. Implementations in Julia and Commodore BASIC.
October 21, 2022
Evaluating vintage computers for NaNoWriMo 2022: VIC-20, Plus/4, Commodore 64, and PET. Word processing on 8-bit machines with SpeedScript and other tools.
July 15, 2022
Adding integers with hundreds of digits using string manipulation in Commodore BASIC. When your numbers are too big for Wolfram Alpha.
July 7, 2022
Understanding the MOS paper tape format used by the KIM-1 and other 6502 systems. Breaking down the hex format line by line with checksum verification.
June 22, 2022
Optimizing 6502 memory transfers beyond the general-purpose approach. Testing on a 1MHz KIM-1 clone with precise timing measurements.
June 14, 2022
Testing real-world memory transfer speeds on 6502 machines. Inspired by Apple M2 marketing, let’s see what Commodore hardware can actually do.
May 25, 2022
Finding k-almost-primes using TinyBASIC on a KIM-1 clone. A look at the copyleft origins of TinyBASIC and Bill Gates’ infamous open letter.
May 15, 2022
Starting a year-long project to reverse engineer and create a drop-in FPGA replacement for the VIC-20’s 6560/6561 video chip.
May 10, 2022
Implementing 64-bit arithmetic in 6502 assembly to solve the wheat and chessboard problem. Handling numbers too large for standard calculators on 8-bit machines.
May 4, 2022
Extending Commodore BASIC with a PRINT AT command using machine language, then using it to visualize the 100 door problem.
March 24, 2022
Computing and displaying the first 10 Fibonacci numbers on a KIM-1’s hex display. Learning 6502 assembly the hard way with pencil and paper.
March 21, 2022
Visualizing the poor randomness of RND() on the Commodore 64 and 128 compared to the PET and Plus/4. Clear patterns emerge when you plot the output.
February 28, 2022
A quick technique for splitting the Commodore 64 screen into two solid colors by manipulating VIC registers and screen memory.
January 11, 2022
Recreating the visual 100 door problem from vintage 8-bit machines in Python using the Asciimatics library for ASCII screen positioning.
December 20, 2021
Generating all 362,880 permutations of 1-9 the hard way: understanding algorithms instead of relying on library functions. Implementations in Python, BASIC, and 6502 assembly.
December 14, 2021
Attempting the annual Advent of Code challenge on vintage 8-bit computers. Completing about 60% of puzzles on Commodore hardware.
October 28, 2021
Implementing Tower of Hanoi with SID sound on the Commodore 64, inspired by Numberphile’s Ayliean MacDonald video.
October 28, 2021
Testing the Commodore 64’s random number generator by simulating dice rolls and comparing the frequency distribution to theoretical values.
October 8, 2021
A week exploring the Atari 800XL from a Commodore guy’s perspective. Comparing BASIC implementations and discovering the platform’s strengths.
October 6, 2021
Two weeks with a Tandy Color Computer 2 for SepTandy. Exploring a machine I’ve owned for years but never really used.
September 9, 2021
A simple slot machine game written in BASIC for the Tandy TRS-80 PC-4 pocket computer during SepTandy.
September 3, 2021
Calculating Pi on a Tandy Color Computer 2 with basic (non-Extended) BASIC. Working around the missing exponent function.
August 5, 2021
Solving the classic 100 door problem with visual output on multiple vintage systems: VIC-20, C64, PET, Atari, and Color Maximite.
July 18, 2021
How to load and run Commodore 64 BASIC programs on a PET. Working around the PET’s lack of program relocation.
July 9, 2021
Building the CERBERUS 2080, an open-source computer with three processors: ATMega328p, W65C02, and Z80. A project to truly understand how computers work.
June 9, 2021
Generating pseudo-random numbers with the Lagged Fibonacci Sequence on the VIC-20. Building reusable BASIC subroutines for the cipher toolbox.
May 19, 2021
Porting Robin’s VIC-20 Super Expander programming challenge to the Commodore 64 using Super Expander 64 and Simon’s BASIC.
May 15, 2021
How to perform modulo operations in Commodore BASIC 2 without a cartridge. A one-line solution for VIC-20 and C64.
May 13, 2021
Implementing Pontifex/Solitaire—the playing card cipher from Cryptonomicon designed by Bruce Schneier—on the Commodore 64.
May 10, 2021
Generating one-time pads on a Commodore 64. Probably a bad idea for real security, but it looks cool.
April 28, 2021
Understanding hash collisions by finding them in a simple checksum from a 1984 type-in game. Demonstrating why weak hashes fail.
April 26, 2021
Finding prime numbers on the Commodore 64 for cryptographic purposes. A practical introduction to primes and primality testing.
April 22, 2021
How to display text character by character with delays in 6502 assembly using Turbo Macro Pro. A quick tip for a 12-year-old learning assembly.
April 19, 2021
Implementing the RC4 stream cipher on the Commodore 64, exploring the algorithm that powered WEP, WPA, and many other encryption protocols.
April 6, 2021
Exploring pseudo-random number generation on the Commodore 64 using Linear Congruential Generators, a key building block for cryptographic applications.
April 1, 2021
Understanding the XOR operation and its magical properties for data recovery in cryptography and disk storage on the Commodore 64.
March 29, 2021
A deep dive video exploring hidden Easter eggs within an Easter egg on a 35-year-old album discovered using a Commodore 64.
March 29, 2021
A quick tutorial on determining string length in 6510 assembly language, comparing the approach to Python’s simple len() function.
March 18, 2021
Benchmarking BASIC execution speed across various retro computers using jiffy timing, comparing Commodore machines and other vintage systems.
March 18, 2021
How to use the Commodore 64’s jiffy clock for benchmarking in both BASIC and assembly language, measuring time in 1/60th second increments.
March 16, 2021
Recreating the WarGames movie launch code sequence on the Commodore 64, implementing brute-force hash table searching in assembly.
March 13, 2021
Calculating Pi using the Gregory-Leibniz series in BASIC on the VIC-20 for Pi Day, demonstrating the inefficient but educational iterative approach.
March 13, 2021
Comparing two assembly language approaches to counting to 16 million on the Commodore 64, demonstrating significant performance differences.
March 7, 2021
Building a Caesar cipher encoder and brute-force decoder on the Commodore 64, demonstrating how to crack simple substitution ciphers programmatically.
March 1, 2021
Implementing the shift cipher on the Commodore 64, encoding messages by rotating alphabet positions similar to a physical code wheel.
February 24, 2021
Starting a series on implementing ciphers in Commodore assembly language, beginning with a simple string reversal as the first building block.
January 26, 2021
A beginner’s guide to learning 6502 assembly programming on the Commodore 64, including recommended tools, resources, and development environment setup.
January 21, 2021
Quick instructions for switching a Raspberry Pi from 32-bit to 64-bit Raspbian Linux for ARM assembly programming.
November 25, 2020
Reflections on getting back into 8-bit computing after building Ben Eater’s breadboard 6502, and why learning vintage assembly language doesn’t need justification.
January 15, 2026
Bringing 10PRINT to the Apple II with Applesoft BASIC and Lo-Res graphics, exploring both text-mode and graphical approaches to this iconic one-liner.
December 17, 2025
Visualizing sorting algorithms in real-time on the Commodore 64 using PETSCII characters. Three classic algorithms rendered as animated bar charts in BASIC.
May 30, 2025
Exploring three different maze generation algorithms on the Commodore 64: Depth-First Search, Randomized Prim’s, and the classic 1981 algorithm from Compute! magazine.
May 16, 2025
Celebrating the gloriously absurd cover of ‘FORTH on the Atari’—possibly the greatest unintentionally funny book cover ever created.
May 16, 2025
Implementing 10PRINT on a KIM-1 clone (PAL-II) in both Microsoft BASIC and 6502 assembly, displaying the maze on the 7-segment LED display.
March 26, 2025
Running 10PRINT and 100 Doors on the Clockwork Pi PicoCalc, a retro-inspired Raspberry Pi Pico handheld running PicoMite BASIC.
January 16, 2025
A visual exploration of the classic 100 Doors programming problem implemented in PICO-8, featuring animated circles that show the door-toggling pattern in action. This version pays homage to the VIC-20 implementation while leveraging PICO-8’s built-in game loop for smooth animation and visual feedback. Complete with code explanations and comparison to the classic VIC-20 version.
January 10, 2025
Continuing the exploration of 10PRINT, we look at how to implement the 10 Print algorithm on the Pico-8 platform.
September 13, 2024
We draw some dragon curves with Logo on the Commodore 64 inspired by Jurassic Park
July 30, 2024
A head-to-head performance comparison of the classic 10PRINT maze algorithm implemented in Rust and C, with benchmarks measuring millions of iterations.
April 19, 2024
Exploring wAx, a native assembler for the VIC-20 that integrates with BASIC. Includes examples implementing 10PRINT and Fibonacci in assembly directly on the machine.
April 5, 2024
Implementing the classic 10PRINT maze algorithm on the HP-42s calculator using RPN programming. Works on SwissMicros DM42 and Free42 emulators too.
March 21, 2024
Solving the classic McNuggets Problem in Commodore BASIC: what’s the largest number of nuggets you can’t buy with 6, 9, and 20 packs?
March 13, 2024
Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.
January 11, 2024
Optimizing a simple counting loop on the 6502, progressing from slow BASIC to increasingly faster assembly implementations. A practical guide to 6502 optimization.
January 3, 2024
Building and verifying the Commodore 64 SID chip’s 23-bit LFSR in hardware on a breadboard and comparing the output against the actual SID chip.
December 21, 2023
An introduction to Linear Feedback Shift Registers: how they work, building one on a breadboard with shift registers and XOR gates, and implementing them in Python and Rust.
December 19, 2023
Commodore BASIC 2.0
A lot of fun with binary numbers can be had by printing them to the screen. This is a quick post to show how to do that with Commodore BASIC 2.0. This is a follow up to Quick Post: XOR in Commodore BASIC 2.0.
We’ll be using both of these in upcoming posts, so it’s good to have them handy.
5 REM PRINT ALL 8 BIT NUMBERS IN BINARY
10 FOR N= 0 TO 255
20 FORI=7 TO 0 STEP-1
25 B=0
30 IF N AND 2^I THEN B=1
40 PRINTMID$(STR$(B),2);
50 NEXT
60 PRINTN
70 NEXT
This prints all the numbers from 0 to 255 in binary. It’s a little slow, but it’s easy to understand and fun to watch.
November 30, 2023
Implementing 10PRINT on the TI-92 calculator using TI-BASIC. Also covers Python versions on the Numworks and TI-nspire calculators.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
October 12, 2023
Solving the classic N-Queens puzzle using backtracking. Covers both iterative and recursive approaches with implementations on the Commodore 64.
September 8, 2023
Implementing the Rail Fence Cipher on the Commodore 64 and TI 99/4A. A fun transposition cipher for secret messages with kids.
June 28, 2023
Rockwell International was a powerhouse of the 1970s and 80s.
The Rockwell AIM 65 computer, also known as the Advanced Interactive Microcomputer 65, is an early microcomputer produced by Rockwell International in the late 1970s. It was essentially a development system, intended primarily for engineers, educators, and hobbyists, and was named for its built-in alphanumeric keyboard and LED display.

The AIM 65 was built around the 6502 microprocessor, the same chip used in popular systems like the Apple II, Commodore PET, and Atari 2600. The AIM 65 was designed as a single-board computer, with the processor, memory, input, and output all integrated into one circuit board.
May 5, 2023
Modern and retro mix
One of my favorite peices of retro clone hardware is Bob Corsham’s KIM-1 Clone. I’ve featured it many places like the 6502 speed series.
I have the latest model of this board, and he made an interesting design choice. It actually has an FTDI chip on board and you use that via USB to connect via a modern computer with an FTDI driver. This is very convenient for working with a modern computer, but then eliminates the ability to use a real serial port.
March 2, 2023
Driving LEDs from the VIC-20 and KIM-1 USR ports. Binary counting in the real world with vintage hardware.
January 26, 2023
Exploring the elegant maze generator from Compute! magazine (December 1981). A line-by-line breakdown of how this classic BASIC algorithm works.
December 1, 2022
Writing code to validate Pilish text—prose where word lengths match the digits of Pi. Implementations in Julia and Commodore BASIC.
October 21, 2022
Evaluating vintage computers for NaNoWriMo 2022: VIC-20, Plus/4, Commodore 64, and PET. Word processing on 8-bit machines with SpeedScript and other tools.
July 7, 2022
Understanding the MOS paper tape format used by the KIM-1 and other 6502 systems. Breaking down the hex format line by line with checksum verification.
May 10, 2022
Implementing 64-bit arithmetic in 6502 assembly to solve the wheat and chessboard problem. Handling numbers too large for standard calculators on 8-bit machines.
December 14, 2021
Attempting the annual Advent of Code challenge on vintage 8-bit computers. Completing about 60% of puzzles on Commodore hardware.
October 8, 2021
A week exploring the Atari 800XL from a Commodore guy’s perspective. Comparing BASIC implementations and discovering the platform’s strengths.
May 18, 2021
Documenting oscilloscope readings from working vintage computer chips to help diagnose faulty machines. A collaborative troubleshooting resource.
April 22, 2021
How to display text character by character with delays in 6502 assembly using Turbo Macro Pro. A quick tip for a 12-year-old learning assembly.
January 26, 2021
A beginner’s guide to learning 6502 assembly programming on the Commodore 64, including recommended tools, resources, and development environment setup.
December 31, 2020
A defense of using modern conveniences like LCD monitors, SD2IEC devices, and flash cartridges with vintage computers, explaining the practical reasons behind these choices.
November 25, 2020
Reflections on getting back into 8-bit computing after building Ben Eater’s breadboard 6502, and why learning vintage assembly language doesn’t need justification.
January 15, 2026
Bringing 10PRINT to the Apple II with Applesoft BASIC and Lo-Res graphics, exploring both text-mode and graphical approaches to this iconic one-liner.
December 17, 2025
Visualizing sorting algorithms in real-time on the Commodore 64 using PETSCII characters. Three classic algorithms rendered as animated bar charts in BASIC.
May 30, 2025
Exploring three different maze generation algorithms on the Commodore 64: Depth-First Search, Randomized Prim’s, and the classic 1981 algorithm from Compute! magazine.
May 20, 2025
Implementing 16-bit unsigned AND operations in Commodore BASIC using two’s complement to work around the signed integer limitation.
May 16, 2025
Celebrating the gloriously absurd cover of ‘FORTH on the Atari’—possibly the greatest unintentionally funny book cover ever created.
May 16, 2025
Implementing 10PRINT on a KIM-1 clone (PAL-II) in both Microsoft BASIC and 6502 assembly, displaying the maze on the 7-segment LED display.
March 26, 2025
Running 10PRINT and 100 Doors on the Clockwork Pi PicoCalc, a retro-inspired Raspberry Pi Pico handheld running PicoMite BASIC.
January 16, 2025
A visual exploration of the classic 100 Doors programming problem implemented in PICO-8, featuring animated circles that show the door-toggling pattern in action. This version pays homage to the VIC-20 implementation while leveraging PICO-8’s built-in game loop for smooth animation and visual feedback. Complete with code explanations and comparison to the classic VIC-20 version.
January 10, 2025
Continuing the exploration of 10PRINT, we look at how to implement the 10 Print algorithm on the Pico-8 platform.
September 13, 2024
We draw some dragon curves with Logo on the Commodore 64 inspired by Jurassic Park
July 30, 2024
A head-to-head performance comparison of the classic 10PRINT maze algorithm implemented in Rust and C, with benchmarks measuring millions of iterations.
April 19, 2024
Exploring wAx, a native assembler for the VIC-20 that integrates with BASIC. Includes examples implementing 10PRINT and Fibonacci in assembly directly on the machine.
April 5, 2024
Implementing the classic 10PRINT maze algorithm on the HP-42s calculator using RPN programming. Works on SwissMicros DM42 and Free42 emulators too.
March 21, 2024
Solving the classic McNuggets Problem in Commodore BASIC: what’s the largest number of nuggets you can’t buy with 6, 9, and 20 packs?
March 13, 2024
Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.
January 11, 2024
Optimizing a simple counting loop on the 6502, progressing from slow BASIC to increasingly faster assembly implementations. A practical guide to 6502 optimization.
January 3, 2024
Building and verifying the Commodore 64 SID chip’s 23-bit LFSR in hardware on a breadboard and comparing the output against the actual SID chip.
December 21, 2023
An introduction to Linear Feedback Shift Registers: how they work, building one on a breadboard with shift registers and XOR gates, and implementing them in Python and Rust.
December 19, 2023
Commodore BASIC 2.0
A lot of fun with binary numbers can be had by printing them to the screen. This is a quick post to show how to do that with Commodore BASIC 2.0. This is a follow up to Quick Post: XOR in Commodore BASIC 2.0.
We’ll be using both of these in upcoming posts, so it’s good to have them handy.
5 REM PRINT ALL 8 BIT NUMBERS IN BINARY
10 FOR N= 0 TO 255
20 FORI=7 TO 0 STEP-1
25 B=0
30 IF N AND 2^I THEN B=1
40 PRINTMID$(STR$(B),2);
50 NEXT
60 PRINTN
70 NEXT
This prints all the numbers from 0 to 255 in binary. It’s a little slow, but it’s easy to understand and fun to watch.
November 30, 2023
Implementing 10PRINT on the TI-92 calculator using TI-BASIC. Also covers Python versions on the Numworks and TI-nspire calculators.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
October 12, 2023
Solving the classic N-Queens puzzle using backtracking. Covers both iterative and recursive approaches with implementations on the Commodore 64.
September 8, 2023
Implementing the Rail Fence Cipher on the Commodore 64 and TI 99/4A. A fun transposition cipher for secret messages with kids.
June 28, 2023
Rockwell International was a powerhouse of the 1970s and 80s.
The Rockwell AIM 65 computer, also known as the Advanced Interactive Microcomputer 65, is an early microcomputer produced by Rockwell International in the late 1970s. It was essentially a development system, intended primarily for engineers, educators, and hobbyists, and was named for its built-in alphanumeric keyboard and LED display.

The AIM 65 was built around the 6502 microprocessor, the same chip used in popular systems like the Apple II, Commodore PET, and Atari 2600. The AIM 65 was designed as a single-board computer, with the processor, memory, input, and output all integrated into one circuit board.
May 5, 2023
Modern and retro mix
One of my favorite peices of retro clone hardware is Bob Corsham’s KIM-1 Clone. I’ve featured it many places like the 6502 speed series.
I have the latest model of this board, and he made an interesting design choice. It actually has an FTDI chip on board and you use that via USB to connect via a modern computer with an FTDI driver. This is very convenient for working with a modern computer, but then eliminates the ability to use a real serial port.
March 2, 2023
Driving LEDs from the VIC-20 and KIM-1 USR ports. Binary counting in the real world with vintage hardware.
January 26, 2023
Exploring the elegant maze generator from Compute! magazine (December 1981). A line-by-line breakdown of how this classic BASIC algorithm works.
December 1, 2022
Writing code to validate Pilish text—prose where word lengths match the digits of Pi. Implementations in Julia and Commodore BASIC.
October 21, 2022
Evaluating vintage computers for NaNoWriMo 2022: VIC-20, Plus/4, Commodore 64, and PET. Word processing on 8-bit machines with SpeedScript and other tools.
July 15, 2022
Adding integers with hundreds of digits using string manipulation in Commodore BASIC. When your numbers are too big for Wolfram Alpha.
July 7, 2022
Understanding the MOS paper tape format used by the KIM-1 and other 6502 systems. Breaking down the hex format line by line with checksum verification.
June 22, 2022
Optimizing 6502 memory transfers beyond the general-purpose approach. Testing on a 1MHz KIM-1 clone with precise timing measurements.
June 14, 2022
Testing real-world memory transfer speeds on 6502 machines. Inspired by Apple M2 marketing, let’s see what Commodore hardware can actually do.
May 25, 2022
Finding k-almost-primes using TinyBASIC on a KIM-1 clone. A look at the copyleft origins of TinyBASIC and Bill Gates’ infamous open letter.
May 15, 2022
Starting a year-long project to reverse engineer and create a drop-in FPGA replacement for the VIC-20’s 6560/6561 video chip.
May 10, 2022
Implementing 64-bit arithmetic in 6502 assembly to solve the wheat and chessboard problem. Handling numbers too large for standard calculators on 8-bit machines.
May 5, 2022
Before and after comparison of S-Video mod results on the Vicky-20 PAL replica board. Dramatic improvement over composite output.
May 4, 2022
Extending Commodore BASIC with a PRINT AT command using machine language, then using it to visualize the 100 door problem.
March 24, 2022
Computing and displaying the first 10 Fibonacci numbers on a KIM-1’s hex display. Learning 6502 assembly the hard way with pencil and paper.
March 21, 2022
Visualizing the poor randomness of RND() on the Commodore 64 and 128 compared to the PET and Plus/4. Clear patterns emerge when you plot the output.
March 16, 2022
Adding green and amber screen colors to the MiniPET 40/80 replica using a cheap monochrome VGA color adapter from Tindie.
February 28, 2022
A quick technique for splitting the Commodore 64 screen into two solid colors by manipulating VIC registers and screen memory.
January 11, 2022
Recreating the visual 100 door problem from vintage 8-bit machines in Python using the Asciimatics library for ASCII screen positioning.
December 20, 2021
Generating all 362,880 permutations of 1-9 the hard way: understanding algorithms instead of relying on library functions. Implementations in Python, BASIC, and 6502 assembly.
December 14, 2021
Attempting the annual Advent of Code challenge on vintage 8-bit computers. Completing about 60% of puzzles on Commodore hardware.
October 28, 2021
Testing the Commodore 64’s random number generator by simulating dice rolls and comparing the frequency distribution to theoretical values.
October 8, 2021
A week exploring the Atari 800XL from a Commodore guy’s perspective. Comparing BASIC implementations and discovering the platform’s strengths.
October 6, 2021
Two weeks with a Tandy Color Computer 2 for SepTandy. Exploring a machine I’ve owned for years but never really used.
September 9, 2021
A simple slot machine game written in BASIC for the Tandy TRS-80 PC-4 pocket computer during SepTandy.
September 3, 2021
Calculating Pi on a Tandy Color Computer 2 with basic (non-Extended) BASIC. Working around the missing exponent function.
August 5, 2021
Solving the classic 100 door problem with visual output on multiple vintage systems: VIC-20, C64, PET, Atari, and Color Maximite.
July 18, 2021
How to load and run Commodore 64 BASIC programs on a PET. Working around the PET’s lack of program relocation.
July 9, 2021
Building the CERBERUS 2080, an open-source computer with three processors: ATMega328p, W65C02, and Z80. A project to truly understand how computers work.
June 9, 2021
Generating pseudo-random numbers with the Lagged Fibonacci Sequence on the VIC-20. Building reusable BASIC subroutines for the cipher toolbox.
May 19, 2021
Porting Robin’s VIC-20 Super Expander programming challenge to the Commodore 64 using Super Expander 64 and Simon’s BASIC.
May 13, 2021
Implementing Pontifex/Solitaire—the playing card cipher from Cryptonomicon designed by Bruce Schneier—on the Commodore 64.
May 10, 2021
Generating one-time pads on a Commodore 64. Probably a bad idea for real security, but it looks cool.
April 28, 2021
Understanding hash collisions by finding them in a simple checksum from a 1984 type-in game. Demonstrating why weak hashes fail.
April 26, 2021
Finding prime numbers on the Commodore 64 for cryptographic purposes. A practical introduction to primes and primality testing.
April 22, 2021
How to display text character by character with delays in 6502 assembly using Turbo Macro Pro. A quick tip for a 12-year-old learning assembly.
April 21, 2021
Building a portable Commodore 64 development rig using a Pelican case, external monitor, and either TheC64 or Ultimate 64 for on-the-go retro computing.
April 19, 2021
Implementing the RC4 stream cipher on the Commodore 64, exploring the algorithm that powered WEP, WPA, and many other encryption protocols.
April 14, 2021
Repairing a Commodore 128 with bad RAM using DIY Chris’s RAM tester to diagnose and replace faulty 4164 memory chips.
April 6, 2021
Exploring pseudo-random number generation on the Commodore 64 using Linear Congruential Generators, a key building block for cryptographic applications.
April 1, 2021
Understanding the XOR operation and its magical properties for data recovery in cryptography and disk storage on the Commodore 64.
March 18, 2021
How to use the Commodore 64’s jiffy clock for benchmarking in both BASIC and assembly language, measuring time in 1/60th second increments.
March 16, 2021
Recreating the WarGames movie launch code sequence on the Commodore 64, implementing brute-force hash table searching in assembly.
March 13, 2021
Calculating Pi using the Gregory-Leibniz series in BASIC on the VIC-20 for Pi Day, demonstrating the inefficient but educational iterative approach.
March 13, 2021
Comparing two assembly language approaches to counting to 16 million on the Commodore 64, demonstrating significant performance differences.
March 10, 2021
Comparing various video output improvements for vintage Commodore computers including RF modulator replacement, chroma resistor mod, and the c0pperdragon component video mod.
March 8, 2021
Recreating the Terminator 2 ATM PIN cracker scene on the Commodore 64, using SID chip random numbers and 6502 assembly.
March 1, 2021
Implementing the shift cipher on the Commodore 64, encoding messages by rotating alphabet positions similar to a physical code wheel.
February 26, 2021
Replacing the RF modulator on a PAL Commodore 64C with an S-Video bypass board to dramatically improve video output quality.
February 24, 2021
Starting a series on implementing ciphers in Commodore assembly language, beginning with a simple string reversal as the first building block.
February 10, 2021
Implementing a one-time pad cipher by hand using dice-generated random numbers, inspired by the encryption methods in Cryptonomicon.
January 26, 2021
A beginner’s guide to learning 6502 assembly programming on the Commodore 64, including recommended tools, resources, and development environment setup.
January 21, 2021
Quick instructions for switching a Raspberry Pi from 32-bit to 64-bit Raspbian Linux for ARM assembly programming.
January 15, 2026
Bringing 10PRINT to the Apple II with Applesoft BASIC and Lo-Res graphics, exploring both text-mode and graphical approaches to this iconic one-liner.
December 17, 2025
Visualizing sorting algorithms in real-time on the Commodore 64 using PETSCII characters. Three classic algorithms rendered as animated bar charts in BASIC.
November 26, 2025
Vibe coding with AI feels productive until it isn’t. Dorothy Vaughan’s team didn’t just operate the IBM—they understood the math behind it. That’s why they succeeded. Here’s why first principles must come before AI assistance.
November 24, 2025
When IBM machines threatened to make her job obsolete, Dorothy Vaughan didn’t retreat—she learned FORTRAN and taught her entire team. Her story offers a blueprint for surviving technological change in any era.
May 30, 2025
Exploring three different maze generation algorithms on the Commodore 64: Depth-First Search, Randomized Prim’s, and the classic 1981 algorithm from Compute! magazine.
May 20, 2025
Implementing 16-bit unsigned AND operations in Commodore BASIC using two’s complement to work around the signed integer limitation.
May 16, 2025
Celebrating the gloriously absurd cover of ‘FORTH on the Atari’—possibly the greatest unintentionally funny book cover ever created.
May 16, 2025
Implementing 10PRINT on a KIM-1 clone (PAL-II) in both Microsoft BASIC and 6502 assembly, displaying the maze on the 7-segment LED display.
March 26, 2025
Running 10PRINT and 100 Doors on the Clockwork Pi PicoCalc, a retro-inspired Raspberry Pi Pico handheld running PicoMite BASIC.
January 16, 2025
A visual exploration of the classic 100 Doors programming problem implemented in PICO-8, featuring animated circles that show the door-toggling pattern in action. This version pays homage to the VIC-20 implementation while leveraging PICO-8’s built-in game loop for smooth animation and visual feedback. Complete with code explanations and comparison to the classic VIC-20 version.
January 10, 2025
Continuing the exploration of 10PRINT, we look at how to implement the 10 Print algorithm on the Pico-8 platform.
September 13, 2024
We draw some dragon curves with Logo on the Commodore 64 inspired by Jurassic Park
July 30, 2024
A head-to-head performance comparison of the classic 10PRINT maze algorithm implemented in Rust and C, with benchmarks measuring millions of iterations.
April 19, 2024
Exploring wAx, a native assembler for the VIC-20 that integrates with BASIC. Includes examples implementing 10PRINT and Fibonacci in assembly directly on the machine.
April 5, 2024
Implementing the classic 10PRINT maze algorithm on the HP-42s calculator using RPN programming. Works on SwissMicros DM42 and Free42 emulators too.
March 21, 2024
Solving the classic McNuggets Problem in Commodore BASIC: what’s the largest number of nuggets you can’t buy with 6, 9, and 20 packs?
March 13, 2024
Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.
January 11, 2024
Optimizing a simple counting loop on the 6502, progressing from slow BASIC to increasingly faster assembly implementations. A practical guide to 6502 optimization.
January 15, 2026
Bringing 10PRINT to the Apple II with Applesoft BASIC and Lo-Res graphics, exploring both text-mode and graphical approaches to this iconic one-liner.
January 8, 2026
Why German cryptographers believed Enigma was unbreakable, and why Allied codebreakers ultimately proved them wrong.
December 17, 2025
Visualizing sorting algorithms in real-time on the Commodore 64 using PETSCII characters. Three classic algorithms rendered as animated bar charts in BASIC.
May 30, 2025
Exploring three different maze generation algorithms on the Commodore 64: Depth-First Search, Randomized Prim’s, and the classic 1981 algorithm from Compute! magazine.
May 20, 2025
Implementing 16-bit unsigned AND operations in Commodore BASIC using two’s complement to work around the signed integer limitation.
May 16, 2025
Celebrating the gloriously absurd cover of ‘FORTH on the Atari’—possibly the greatest unintentionally funny book cover ever created.
May 16, 2025
Implementing 10PRINT on a KIM-1 clone (PAL-II) in both Microsoft BASIC and 6502 assembly, displaying the maze on the 7-segment LED display.
March 26, 2025
Running 10PRINT and 100 Doors on the Clockwork Pi PicoCalc, a retro-inspired Raspberry Pi Pico handheld running PicoMite BASIC.
January 16, 2025
A visual exploration of the classic 100 Doors programming problem implemented in PICO-8, featuring animated circles that show the door-toggling pattern in action. This version pays homage to the VIC-20 implementation while leveraging PICO-8’s built-in game loop for smooth animation and visual feedback. Complete with code explanations and comparison to the classic VIC-20 version.
January 10, 2025
Continuing the exploration of 10PRINT, we look at how to implement the 10 Print algorithm on the Pico-8 platform.
September 13, 2024
We draw some dragon curves with Logo on the Commodore 64 inspired by Jurassic Park
July 30, 2024
A head-to-head performance comparison of the classic 10PRINT maze algorithm implemented in Rust and C, with benchmarks measuring millions of iterations.
April 19, 2024
Exploring wAx, a native assembler for the VIC-20 that integrates with BASIC. Includes examples implementing 10PRINT and Fibonacci in assembly directly on the machine.
April 5, 2024
Implementing the classic 10PRINT maze algorithm on the HP-42s calculator using RPN programming. Works on SwissMicros DM42 and Free42 emulators too.
March 21, 2024
Solving the classic McNuggets Problem in Commodore BASIC: what’s the largest number of nuggets you can’t buy with 6, 9, and 20 packs?
March 13, 2024
Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.
January 11, 2024
Optimizing a simple counting loop on the 6502, progressing from slow BASIC to increasingly faster assembly implementations. A practical guide to 6502 optimization.
January 3, 2024
Building and verifying the Commodore 64 SID chip’s 23-bit LFSR in hardware on a breadboard and comparing the output against the actual SID chip.
December 21, 2023
An introduction to Linear Feedback Shift Registers: how they work, building one on a breadboard with shift registers and XOR gates, and implementing them in Python and Rust.
December 19, 2023
Commodore BASIC 2.0
A lot of fun with binary numbers can be had by printing them to the screen. This is a quick post to show how to do that with Commodore BASIC 2.0. This is a follow up to Quick Post: XOR in Commodore BASIC 2.0.
We’ll be using both of these in upcoming posts, so it’s good to have them handy.
5 REM PRINT ALL 8 BIT NUMBERS IN BINARY
10 FOR N= 0 TO 255
20 FORI=7 TO 0 STEP-1
25 B=0
30 IF N AND 2^I THEN B=1
40 PRINTMID$(STR$(B),2);
50 NEXT
60 PRINTN
70 NEXT
This prints all the numbers from 0 to 255 in binary. It’s a little slow, but it’s easy to understand and fun to watch.
November 30, 2023
Implementing 10PRINT on the TI-92 calculator using TI-BASIC. Also covers Python versions on the Numworks and TI-nspire calculators.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
October 12, 2023
Solving the classic N-Queens puzzle using backtracking. Covers both iterative and recursive approaches with implementations on the Commodore 64.
September 8, 2023
Implementing the Rail Fence Cipher on the Commodore 64 and TI 99/4A. A fun transposition cipher for secret messages with kids.
June 28, 2023
Rockwell International was a powerhouse of the 1970s and 80s.
The Rockwell AIM 65 computer, also known as the Advanced Interactive Microcomputer 65, is an early microcomputer produced by Rockwell International in the late 1970s. It was essentially a development system, intended primarily for engineers, educators, and hobbyists, and was named for its built-in alphanumeric keyboard and LED display.

The AIM 65 was built around the 6502 microprocessor, the same chip used in popular systems like the Apple II, Commodore PET, and Atari 2600. The AIM 65 was designed as a single-board computer, with the processor, memory, input, and output all integrated into one circuit board.
May 5, 2023
Modern and retro mix
One of my favorite peices of retro clone hardware is Bob Corsham’s KIM-1 Clone. I’ve featured it many places like the 6502 speed series.
I have the latest model of this board, and he made an interesting design choice. It actually has an FTDI chip on board and you use that via USB to connect via a modern computer with an FTDI driver. This is very convenient for working with a modern computer, but then eliminates the ability to use a real serial port.
March 2, 2023
Driving LEDs from the VIC-20 and KIM-1 USR ports. Binary counting in the real world with vintage hardware.
January 26, 2023
Exploring the elegant maze generator from Compute! magazine (December 1981). A line-by-line breakdown of how this classic BASIC algorithm works.
December 1, 2022
Writing code to validate Pilish text—prose where word lengths match the digits of Pi. Implementations in Julia and Commodore BASIC.
October 21, 2022
Evaluating vintage computers for NaNoWriMo 2022: VIC-20, Plus/4, Commodore 64, and PET. Word processing on 8-bit machines with SpeedScript and other tools.
July 15, 2022
Adding integers with hundreds of digits using string manipulation in Commodore BASIC. When your numbers are too big for Wolfram Alpha.
July 7, 2022
Understanding the MOS paper tape format used by the KIM-1 and other 6502 systems. Breaking down the hex format line by line with checksum verification.
June 22, 2022
Optimizing 6502 memory transfers beyond the general-purpose approach. Testing on a 1MHz KIM-1 clone with precise timing measurements.
June 14, 2022
Testing real-world memory transfer speeds on 6502 machines. Inspired by Apple M2 marketing, let’s see what Commodore hardware can actually do.
May 25, 2022
Finding k-almost-primes using TinyBASIC on a KIM-1 clone. A look at the copyleft origins of TinyBASIC and Bill Gates’ infamous open letter.
May 15, 2022
Starting a year-long project to reverse engineer and create a drop-in FPGA replacement for the VIC-20’s 6560/6561 video chip.
May 10, 2022
Implementing 64-bit arithmetic in 6502 assembly to solve the wheat and chessboard problem. Handling numbers too large for standard calculators on 8-bit machines.
May 5, 2022
Before and after comparison of S-Video mod results on the Vicky-20 PAL replica board. Dramatic improvement over composite output.
May 4, 2022
Extending Commodore BASIC with a PRINT AT command using machine language, then using it to visualize the 100 door problem.
March 27, 2022
Writing a y^x exponent program for the HP-16C calculator, which curiously lacks scientific functions. Building a kit clone and programming in RPN.
March 24, 2022
Computing and displaying the first 10 Fibonacci numbers on a KIM-1’s hex display. Learning 6502 assembly the hard way with pencil and paper.
March 21, 2022
Visualizing the poor randomness of RND() on the Commodore 64 and 128 compared to the PET and Plus/4. Clear patterns emerge when you plot the output.
March 16, 2022
Adding green and amber screen colors to the MiniPET 40/80 replica using a cheap monochrome VGA color adapter from Tindie.
February 28, 2022
A quick technique for splitting the Commodore 64 screen into two solid colors by manipulating VIC registers and screen memory.
January 11, 2022
Recreating the visual 100 door problem from vintage 8-bit machines in Python using the Asciimatics library for ASCII screen positioning.
December 20, 2021
Generating all 362,880 permutations of 1-9 the hard way: understanding algorithms instead of relying on library functions. Implementations in Python, BASIC, and 6502 assembly.
December 14, 2021
Attempting the annual Advent of Code challenge on vintage 8-bit computers. Completing about 60% of puzzles on Commodore hardware.
October 28, 2021
Implementing Tower of Hanoi with SID sound on the Commodore 64, inspired by Numberphile’s Ayliean MacDonald video.
October 28, 2021
Testing the Commodore 64’s random number generator by simulating dice rolls and comparing the frequency distribution to theoretical values.
October 8, 2021
A week exploring the Atari 800XL from a Commodore guy’s perspective. Comparing BASIC implementations and discovering the platform’s strengths.
October 6, 2021
Two weeks with a Tandy Color Computer 2 for SepTandy. Exploring a machine I’ve owned for years but never really used.
September 9, 2021
A simple slot machine game written in BASIC for the Tandy TRS-80 PC-4 pocket computer during SepTandy.
September 3, 2021
Calculating Pi on a Tandy Color Computer 2 with basic (non-Extended) BASIC. Working around the missing exponent function.
August 5, 2021
Solving the classic 100 door problem with visual output on multiple vintage systems: VIC-20, C64, PET, Atari, and Color Maximite.
July 18, 2021
How to load and run Commodore 64 BASIC programs on a PET. Working around the PET’s lack of program relocation.
July 9, 2021
Building the CERBERUS 2080, an open-source computer with three processors: ATMega328p, W65C02, and Z80. A project to truly understand how computers work.
June 9, 2021
Generating pseudo-random numbers with the Lagged Fibonacci Sequence on the VIC-20. Building reusable BASIC subroutines for the cipher toolbox.
May 19, 2021
Porting Robin’s VIC-20 Super Expander programming challenge to the Commodore 64 using Super Expander 64 and Simon’s BASIC.
May 18, 2021
Documenting oscilloscope readings from working vintage computer chips to help diagnose faulty machines. A collaborative troubleshooting resource.
May 15, 2021
How to perform modulo operations in Commodore BASIC 2 without a cartridge. A one-line solution for VIC-20 and C64.
May 13, 2021
Implementing Pontifex/Solitaire—the playing card cipher from Cryptonomicon designed by Bruce Schneier—on the Commodore 64.
May 10, 2021
Generating one-time pads on a Commodore 64. Probably a bad idea for real security, but it looks cool.
April 28, 2021
Understanding hash collisions by finding them in a simple checksum from a 1984 type-in game. Demonstrating why weak hashes fail.
April 26, 2021
Finding prime numbers on the Commodore 64 for cryptographic purposes. A practical introduction to primes and primality testing.
April 22, 2021
How to display text character by character with delays in 6502 assembly using Turbo Macro Pro. A quick tip for a 12-year-old learning assembly.
April 21, 2021
Building a portable Commodore 64 development rig using a Pelican case, external monitor, and either TheC64 or Ultimate 64 for on-the-go retro computing.
April 19, 2021
Implementing the RC4 stream cipher on the Commodore 64, exploring the algorithm that powered WEP, WPA, and many other encryption protocols.
April 16, 2021
A nostalgic look at ‘How to Run a Railroad’ by Harvey Weiss, the childhood library book that sparked a lifelong passion for model trains and hands-on learning.
April 14, 2021
Repairing a Commodore 128 with bad RAM using DIY Chris’s RAM tester to diagnose and replace faulty 4164 memory chips.
April 6, 2021
Exploring pseudo-random number generation on the Commodore 64 using Linear Congruential Generators, a key building block for cryptographic applications.
April 1, 2021
Understanding the XOR operation and its magical properties for data recovery in cryptography and disk storage on the Commodore 64.
March 29, 2021
A deep dive video exploring hidden Easter eggs within an Easter egg on a 35-year-old album discovered using a Commodore 64.
March 29, 2021
A quick tutorial on determining string length in 6510 assembly language, comparing the approach to Python’s simple len() function.
March 18, 2021
Benchmarking BASIC execution speed across various retro computers using jiffy timing, comparing Commodore machines and other vintage systems.
March 18, 2021
How to use the Commodore 64’s jiffy clock for benchmarking in both BASIC and assembly language, measuring time in 1/60th second increments.
March 16, 2021
Recreating the WarGames movie launch code sequence on the Commodore 64, implementing brute-force hash table searching in assembly.
March 13, 2021
Calculating Pi using the Gregory-Leibniz series in BASIC on the VIC-20 for Pi Day, demonstrating the inefficient but educational iterative approach.
March 13, 2021
Comparing two assembly language approaches to counting to 16 million on the Commodore 64, demonstrating significant performance differences.
March 10, 2021
Comparing various video output improvements for vintage Commodore computers including RF modulator replacement, chroma resistor mod, and the c0pperdragon component video mod.
March 8, 2021
Recreating the Terminator 2 ATM PIN cracker scene on the Commodore 64, using SID chip random numbers and 6502 assembly.
March 7, 2021
Building a Caesar cipher encoder and brute-force decoder on the Commodore 64, demonstrating how to crack simple substitution ciphers programmatically.
March 1, 2021
Implementing the shift cipher on the Commodore 64, encoding messages by rotating alphabet positions similar to a physical code wheel.
February 26, 2021
Replacing the RF modulator on a PAL Commodore 64C with an S-Video bypass board to dramatically improve video output quality.
February 24, 2021
Starting a series on implementing ciphers in Commodore assembly language, beginning with a simple string reversal as the first building block.
February 10, 2021
Implementing a one-time pad cipher by hand using dice-generated random numbers, inspired by the encryption methods in Cryptonomicon.
January 26, 2021
A beginner’s guide to learning 6502 assembly programming on the Commodore 64, including recommended tools, resources, and development environment setup.
January 22, 2021
Reviewing Soul Force and Outrage, two modern Commodore 64 games from Protovision being played on a PAL 64C.
December 31, 2020
A defense of using modern conveniences like LCD monitors, SD2IEC devices, and flash cartridges with vintage computers, explaining the practical reasons behind these choices.
November 25, 2020
Reflections on getting back into 8-bit computing after building Ben Eater’s breadboard 6502, and why learning vintage assembly language doesn’t need justification.
January 15, 2026
Bringing 10PRINT to the Apple II with Applesoft BASIC and Lo-Res graphics, exploring both text-mode and graphical approaches to this iconic one-liner.
December 17, 2025
Visualizing sorting algorithms in real-time on the Commodore 64 using PETSCII characters. Three classic algorithms rendered as animated bar charts in BASIC.
May 30, 2025
Exploring three different maze generation algorithms on the Commodore 64: Depth-First Search, Randomized Prim’s, and the classic 1981 algorithm from Compute! magazine.
May 20, 2025
Implementing 16-bit unsigned AND operations in Commodore BASIC using two’s complement to work around the signed integer limitation.
May 16, 2025
Celebrating the gloriously absurd cover of ‘FORTH on the Atari’—possibly the greatest unintentionally funny book cover ever created.
May 16, 2025
Implementing 10PRINT on a KIM-1 clone (PAL-II) in both Microsoft BASIC and 6502 assembly, displaying the maze on the 7-segment LED display.
March 26, 2025
Running 10PRINT and 100 Doors on the Clockwork Pi PicoCalc, a retro-inspired Raspberry Pi Pico handheld running PicoMite BASIC.
January 16, 2025
A visual exploration of the classic 100 Doors programming problem implemented in PICO-8, featuring animated circles that show the door-toggling pattern in action. This version pays homage to the VIC-20 implementation while leveraging PICO-8’s built-in game loop for smooth animation and visual feedback. Complete with code explanations and comparison to the classic VIC-20 version.
January 10, 2025
Continuing the exploration of 10PRINT, we look at how to implement the 10 Print algorithm on the Pico-8 platform.
September 13, 2024
We draw some dragon curves with Logo on the Commodore 64 inspired by Jurassic Park
July 30, 2024
A head-to-head performance comparison of the classic 10PRINT maze algorithm implemented in Rust and C, with benchmarks measuring millions of iterations.
April 19, 2024
Exploring wAx, a native assembler for the VIC-20 that integrates with BASIC. Includes examples implementing 10PRINT and Fibonacci in assembly directly on the machine.
April 5, 2024
Implementing the classic 10PRINT maze algorithm on the HP-42s calculator using RPN programming. Works on SwissMicros DM42 and Free42 emulators too.
March 21, 2024
Solving the classic McNuggets Problem in Commodore BASIC: what’s the largest number of nuggets you can’t buy with 6, 9, and 20 packs?
March 13, 2024
Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.
January 8, 2026
Why German cryptographers believed Enigma was unbreakable, and why Allied codebreakers ultimately proved them wrong.
January 8, 2026
Why German cryptographers believed Enigma was unbreakable, and why Allied codebreakers ultimately proved them wrong.
January 8, 2026
Why German cryptographers believed Enigma was unbreakable, and why Allied codebreakers ultimately proved them wrong.
November 24, 2025
When IBM machines threatened to make her job obsolete, Dorothy Vaughan didn’t retreat—she learned FORTRAN and taught her entire team. Her story offers a blueprint for surviving technological change in any era.
January 8, 2026
Why German cryptographers believed Enigma was unbreakable, and why Allied codebreakers ultimately proved them wrong.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
December 17, 2025
Visualizing sorting algorithms in real-time on the Commodore 64 using PETSCII characters. Three classic algorithms rendered as animated bar charts in BASIC.
December 17, 2025
Visualizing sorting algorithms in real-time on the Commodore 64 using PETSCII characters. Three classic algorithms rendered as animated bar charts in BASIC.
May 30, 2025
Exploring three different maze generation algorithms on the Commodore 64: Depth-First Search, Randomized Prim’s, and the classic 1981 algorithm from Compute! magazine.
May 20, 2025
Implementing 16-bit unsigned AND operations in Commodore BASIC using two’s complement to work around the signed integer limitation.
March 13, 2024
Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.
January 11, 2024
Optimizing a simple counting loop on the 6502, progressing from slow BASIC to increasingly faster assembly implementations. A practical guide to 6502 optimization.
January 3, 2024
Building and verifying the Commodore 64 SID chip’s 23-bit LFSR in hardware on a breadboard and comparing the output against the actual SID chip.
December 21, 2023
An introduction to Linear Feedback Shift Registers: how they work, building one on a breadboard with shift registers and XOR gates, and implementing them in Python and Rust.
December 19, 2023
Commodore BASIC 2.0
A lot of fun with binary numbers can be had by printing them to the screen. This is a quick post to show how to do that with Commodore BASIC 2.0. This is a follow up to Quick Post: XOR in Commodore BASIC 2.0.
We’ll be using both of these in upcoming posts, so it’s good to have them handy.
5 REM PRINT ALL 8 BIT NUMBERS IN BINARY
10 FOR N= 0 TO 255
20 FORI=7 TO 0 STEP-1
25 B=0
30 IF N AND 2^I THEN B=1
40 PRINTMID$(STR$(B),2);
50 NEXT
60 PRINTN
70 NEXT
This prints all the numbers from 0 to 255 in binary. It’s a little slow, but it’s easy to understand and fun to watch.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
October 12, 2023
Solving the classic N-Queens puzzle using backtracking. Covers both iterative and recursive approaches with implementations on the Commodore 64.
September 8, 2023
Implementing the Rail Fence Cipher on the Commodore 64 and TI 99/4A. A fun transposition cipher for secret messages with kids.
August 11, 2023
Drawing grids for screen layout planning on the Commodore 64 and VIC-20. Comparing BASIC, Simon’s BASIC, and Super Expander approaches.
May 5, 2023
Modern and retro mix
One of my favorite peices of retro clone hardware is Bob Corsham’s KIM-1 Clone. I’ve featured it many places like the 6502 speed series.
I have the latest model of this board, and he made an interesting design choice. It actually has an FTDI chip on board and you use that via USB to connect via a modern computer with an FTDI driver. This is very convenient for working with a modern computer, but then eliminates the ability to use a real serial port.
March 2, 2023
Driving LEDs from the VIC-20 and KIM-1 USR ports. Binary counting in the real world with vintage hardware.
January 26, 2023
Exploring the elegant maze generator from Compute! magazine (December 1981). A line-by-line breakdown of how this classic BASIC algorithm works.
December 1, 2022
Writing code to validate Pilish text—prose where word lengths match the digits of Pi. Implementations in Julia and Commodore BASIC.
October 21, 2022
Evaluating vintage computers for NaNoWriMo 2022: VIC-20, Plus/4, Commodore 64, and PET. Word processing on 8-bit machines with SpeedScript and other tools.
June 22, 2022
Optimizing 6502 memory transfers beyond the general-purpose approach. Testing on a 1MHz KIM-1 clone with precise timing measurements.
June 14, 2022
Testing real-world memory transfer speeds on 6502 machines. Inspired by Apple M2 marketing, let’s see what Commodore hardware can actually do.
May 10, 2022
Implementing 64-bit arithmetic in 6502 assembly to solve the wheat and chessboard problem. Handling numbers too large for standard calculators on 8-bit machines.
May 4, 2022
Extending Commodore BASIC with a PRINT AT command using machine language, then using it to visualize the 100 door problem.
March 21, 2022
Visualizing the poor randomness of RND() on the Commodore 64 and 128 compared to the PET and Plus/4. Clear patterns emerge when you plot the output.
February 28, 2022
A quick technique for splitting the Commodore 64 screen into two solid colors by manipulating VIC registers and screen memory.
December 20, 2021
Generating all 362,880 permutations of 1-9 the hard way: understanding algorithms instead of relying on library functions. Implementations in Python, BASIC, and 6502 assembly.
December 14, 2021
Attempting the annual Advent of Code challenge on vintage 8-bit computers. Completing about 60% of puzzles on Commodore hardware.
October 28, 2021
Implementing Tower of Hanoi with SID sound on the Commodore 64, inspired by Numberphile’s Ayliean MacDonald video.
October 28, 2021
Testing the Commodore 64’s random number generator by simulating dice rolls and comparing the frequency distribution to theoretical values.
September 3, 2021
Calculating Pi on a Tandy Color Computer 2 with basic (non-Extended) BASIC. Working around the missing exponent function.
August 5, 2021
Solving the classic 100 door problem with visual output on multiple vintage systems: VIC-20, C64, PET, Atari, and Color Maximite.
July 18, 2021
How to load and run Commodore 64 BASIC programs on a PET. Working around the PET’s lack of program relocation.
June 9, 2021
Generating pseudo-random numbers with the Lagged Fibonacci Sequence on the VIC-20. Building reusable BASIC subroutines for the cipher toolbox.
May 19, 2021
Porting Robin’s VIC-20 Super Expander programming challenge to the Commodore 64 using Super Expander 64 and Simon’s BASIC.
May 18, 2021
Documenting oscilloscope readings from working vintage computer chips to help diagnose faulty machines. A collaborative troubleshooting resource.
May 15, 2021
How to perform modulo operations in Commodore BASIC 2 without a cartridge. A one-line solution for VIC-20 and C64.
May 13, 2021
Implementing Pontifex/Solitaire—the playing card cipher from Cryptonomicon designed by Bruce Schneier—on the Commodore 64.
May 10, 2021
Generating one-time pads on a Commodore 64. Probably a bad idea for real security, but it looks cool.
April 28, 2021
Understanding hash collisions by finding them in a simple checksum from a 1984 type-in game. Demonstrating why weak hashes fail.
April 26, 2021
Finding prime numbers on the Commodore 64 for cryptographic purposes. A practical introduction to primes and primality testing.
April 22, 2021
How to display text character by character with delays in 6502 assembly using Turbo Macro Pro. A quick tip for a 12-year-old learning assembly.
April 21, 2021
Building a portable Commodore 64 development rig using a Pelican case, external monitor, and either TheC64 or Ultimate 64 for on-the-go retro computing.
April 19, 2021
Implementing the RC4 stream cipher on the Commodore 64, exploring the algorithm that powered WEP, WPA, and many other encryption protocols.
April 14, 2021
Repairing a Commodore 128 with bad RAM using DIY Chris’s RAM tester to diagnose and replace faulty 4164 memory chips.
April 6, 2021
Exploring pseudo-random number generation on the Commodore 64 using Linear Congruential Generators, a key building block for cryptographic applications.
April 1, 2021
Understanding the XOR operation and its magical properties for data recovery in cryptography and disk storage on the Commodore 64.
March 29, 2021
A deep dive video exploring hidden Easter eggs within an Easter egg on a 35-year-old album discovered using a Commodore 64.
March 29, 2021
A quick tutorial on determining string length in 6510 assembly language, comparing the approach to Python’s simple len() function.
March 18, 2021
Benchmarking BASIC execution speed across various retro computers using jiffy timing, comparing Commodore machines and other vintage systems.
March 18, 2021
How to use the Commodore 64’s jiffy clock for benchmarking in both BASIC and assembly language, measuring time in 1/60th second increments.
March 16, 2021
Recreating the WarGames movie launch code sequence on the Commodore 64, implementing brute-force hash table searching in assembly.
March 13, 2021
Calculating Pi using the Gregory-Leibniz series in BASIC on the VIC-20 for Pi Day, demonstrating the inefficient but educational iterative approach.
March 13, 2021
Comparing two assembly language approaches to counting to 16 million on the Commodore 64, demonstrating significant performance differences.
March 10, 2021
Comparing various video output improvements for vintage Commodore computers including RF modulator replacement, chroma resistor mod, and the c0pperdragon component video mod.
March 8, 2021
Recreating the Terminator 2 ATM PIN cracker scene on the Commodore 64, using SID chip random numbers and 6502 assembly.
March 7, 2021
Building a Caesar cipher encoder and brute-force decoder on the Commodore 64, demonstrating how to crack simple substitution ciphers programmatically.
March 1, 2021
Implementing the shift cipher on the Commodore 64, encoding messages by rotating alphabet positions similar to a physical code wheel.
February 26, 2021
Replacing the RF modulator on a PAL Commodore 64C with an S-Video bypass board to dramatically improve video output quality.
February 24, 2021
Starting a series on implementing ciphers in Commodore assembly language, beginning with a simple string reversal as the first building block.
February 10, 2021
Implementing a one-time pad cipher by hand using dice-generated random numbers, inspired by the encryption methods in Cryptonomicon.
January 26, 2021
A beginner’s guide to learning 6502 assembly programming on the Commodore 64, including recommended tools, resources, and development environment setup.
January 22, 2021
Reviewing Soul Force and Outrage, two modern Commodore 64 games from Protovision being played on a PAL 64C.
December 31, 2020
A defense of using modern conveniences like LCD monitors, SD2IEC devices, and flash cartridges with vintage computers, explaining the practical reasons behind these choices.
December 24, 2020
A Christmas greeting featuring a Commodore 64 holiday demo video.
November 25, 2020
Reflections on getting back into 8-bit computing after building Ben Eater’s breadboard 6502, and why learning vintage assembly language doesn’t need justification.
December 17, 2025
Visualizing sorting algorithms in real-time on the Commodore 64 using PETSCII characters. Three classic algorithms rendered as animated bar charts in BASIC.
November 24, 2025
When IBM machines threatened to make her job obsolete, Dorothy Vaughan didn’t retreat—she learned FORTRAN and taught her entire team. Her story offers a blueprint for surviving technological change in any era.
May 20, 2025
Implementing 16-bit unsigned AND operations in Commodore BASIC using two’s complement to work around the signed integer limitation.
September 13, 2024
We draw some dragon curves with Logo on the Commodore 64 inspired by Jurassic Park
March 21, 2024
Solving the classic McNuggets Problem in Commodore BASIC: what’s the largest number of nuggets you can’t buy with 6, 9, and 20 packs?
March 13, 2024
Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.
January 11, 2024
Optimizing a simple counting loop on the 6502, progressing from slow BASIC to increasingly faster assembly implementations. A practical guide to 6502 optimization.
January 3, 2024
Building and verifying the Commodore 64 SID chip’s 23-bit LFSR in hardware on a breadboard and comparing the output against the actual SID chip.
December 21, 2023
An introduction to Linear Feedback Shift Registers: how they work, building one on a breadboard with shift registers and XOR gates, and implementing them in Python and Rust.
December 19, 2023
Commodore BASIC 2.0
A lot of fun with binary numbers can be had by printing them to the screen. This is a quick post to show how to do that with Commodore BASIC 2.0. This is a follow up to Quick Post: XOR in Commodore BASIC 2.0.
We’ll be using both of these in upcoming posts, so it’s good to have them handy.
5 REM PRINT ALL 8 BIT NUMBERS IN BINARY
10 FOR N= 0 TO 255
20 FORI=7 TO 0 STEP-1
25 B=0
30 IF N AND 2^I THEN B=1
40 PRINTMID$(STR$(B),2);
50 NEXT
60 PRINTN
70 NEXT
This prints all the numbers from 0 to 255 in binary. It’s a little slow, but it’s easy to understand and fun to watch.
November 30, 2023
Implementing 10PRINT on the TI-92 calculator using TI-BASIC. Also covers Python versions on the Numworks and TI-nspire calculators.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
October 12, 2023
Solving the classic N-Queens puzzle using backtracking. Covers both iterative and recursive approaches with implementations on the Commodore 64.
September 8, 2023
Implementing the Rail Fence Cipher on the Commodore 64 and TI 99/4A. A fun transposition cipher for secret messages with kids.
May 5, 2023
Modern and retro mix
One of my favorite peices of retro clone hardware is Bob Corsham’s KIM-1 Clone. I’ve featured it many places like the 6502 speed series.
I have the latest model of this board, and he made an interesting design choice. It actually has an FTDI chip on board and you use that via USB to connect via a modern computer with an FTDI driver. This is very convenient for working with a modern computer, but then eliminates the ability to use a real serial port.
March 2, 2023
Driving LEDs from the VIC-20 and KIM-1 USR ports. Binary counting in the real world with vintage hardware.
January 26, 2023
Exploring the elegant maze generator from Compute! magazine (December 1981). A line-by-line breakdown of how this classic BASIC algorithm works.
December 1, 2022
Writing code to validate Pilish text—prose where word lengths match the digits of Pi. Implementations in Julia and Commodore BASIC.
October 21, 2022
Evaluating vintage computers for NaNoWriMo 2022: VIC-20, Plus/4, Commodore 64, and PET. Word processing on 8-bit machines with SpeedScript and other tools.
July 15, 2022
Adding integers with hundreds of digits using string manipulation in Commodore BASIC. When your numbers are too big for Wolfram Alpha.
July 7, 2022
Understanding the MOS paper tape format used by the KIM-1 and other 6502 systems. Breaking down the hex format line by line with checksum verification.
June 22, 2022
Optimizing 6502 memory transfers beyond the general-purpose approach. Testing on a 1MHz KIM-1 clone with precise timing measurements.
June 14, 2022
Testing real-world memory transfer speeds on 6502 machines. Inspired by Apple M2 marketing, let’s see what Commodore hardware can actually do.
May 25, 2022
Finding k-almost-primes using TinyBASIC on a KIM-1 clone. A look at the copyleft origins of TinyBASIC and Bill Gates’ infamous open letter.
May 15, 2022
Starting a year-long project to reverse engineer and create a drop-in FPGA replacement for the VIC-20’s 6560/6561 video chip.
May 10, 2022
Implementing 64-bit arithmetic in 6502 assembly to solve the wheat and chessboard problem. Handling numbers too large for standard calculators on 8-bit machines.
May 5, 2022
Before and after comparison of S-Video mod results on the Vicky-20 PAL replica board. Dramatic improvement over composite output.
May 4, 2022
Extending Commodore BASIC with a PRINT AT command using machine language, then using it to visualize the 100 door problem.
March 24, 2022
Computing and displaying the first 10 Fibonacci numbers on a KIM-1’s hex display. Learning 6502 assembly the hard way with pencil and paper.
March 21, 2022
Visualizing the poor randomness of RND() on the Commodore 64 and 128 compared to the PET and Plus/4. Clear patterns emerge when you plot the output.
March 16, 2022
Adding green and amber screen colors to the MiniPET 40/80 replica using a cheap monochrome VGA color adapter from Tindie.
February 28, 2022
A quick technique for splitting the Commodore 64 screen into two solid colors by manipulating VIC registers and screen memory.
December 20, 2021
Generating all 362,880 permutations of 1-9 the hard way: understanding algorithms instead of relying on library functions. Implementations in Python, BASIC, and 6502 assembly.
December 14, 2021
Attempting the annual Advent of Code challenge on vintage 8-bit computers. Completing about 60% of puzzles on Commodore hardware.
October 28, 2021
Implementing Tower of Hanoi with SID sound on the Commodore 64, inspired by Numberphile’s Ayliean MacDonald video.
October 28, 2021
Testing the Commodore 64’s random number generator by simulating dice rolls and comparing the frequency distribution to theoretical values.
October 8, 2021
A week exploring the Atari 800XL from a Commodore guy’s perspective. Comparing BASIC implementations and discovering the platform’s strengths.
September 3, 2021
Calculating Pi on a Tandy Color Computer 2 with basic (non-Extended) BASIC. Working around the missing exponent function.
August 5, 2021
Solving the classic 100 door problem with visual output on multiple vintage systems: VIC-20, C64, PET, Atari, and Color Maximite.
July 18, 2021
How to load and run Commodore 64 BASIC programs on a PET. Working around the PET’s lack of program relocation.
June 9, 2021
Generating pseudo-random numbers with the Lagged Fibonacci Sequence on the VIC-20. Building reusable BASIC subroutines for the cipher toolbox.
May 19, 2021
Porting Robin’s VIC-20 Super Expander programming challenge to the Commodore 64 using Super Expander 64 and Simon’s BASIC.
May 18, 2021
Documenting oscilloscope readings from working vintage computer chips to help diagnose faulty machines. A collaborative troubleshooting resource.
May 15, 2021
How to perform modulo operations in Commodore BASIC 2 without a cartridge. A one-line solution for VIC-20 and C64.
May 13, 2021
Implementing Pontifex/Solitaire—the playing card cipher from Cryptonomicon designed by Bruce Schneier—on the Commodore 64.
May 10, 2021
Generating one-time pads on a Commodore 64. Probably a bad idea for real security, but it looks cool.
April 28, 2021
Understanding hash collisions by finding them in a simple checksum from a 1984 type-in game. Demonstrating why weak hashes fail.
April 26, 2021
Finding prime numbers on the Commodore 64 for cryptographic purposes. A practical introduction to primes and primality testing.
April 22, 2021
How to display text character by character with delays in 6502 assembly using Turbo Macro Pro. A quick tip for a 12-year-old learning assembly.
April 21, 2021
Building a portable Commodore 64 development rig using a Pelican case, external monitor, and either TheC64 or Ultimate 64 for on-the-go retro computing.
April 19, 2021
Implementing the RC4 stream cipher on the Commodore 64, exploring the algorithm that powered WEP, WPA, and many other encryption protocols.
April 14, 2021
Repairing a Commodore 128 with bad RAM using DIY Chris’s RAM tester to diagnose and replace faulty 4164 memory chips.
April 6, 2021
Exploring pseudo-random number generation on the Commodore 64 using Linear Congruential Generators, a key building block for cryptographic applications.
April 1, 2021
Understanding the XOR operation and its magical properties for data recovery in cryptography and disk storage on the Commodore 64.
March 29, 2021
A deep dive video exploring hidden Easter eggs within an Easter egg on a 35-year-old album discovered using a Commodore 64.
March 29, 2021
A quick tutorial on determining string length in 6510 assembly language, comparing the approach to Python’s simple len() function.
March 18, 2021
Benchmarking BASIC execution speed across various retro computers using jiffy timing, comparing Commodore machines and other vintage systems.
March 18, 2021
How to use the Commodore 64’s jiffy clock for benchmarking in both BASIC and assembly language, measuring time in 1/60th second increments.
March 16, 2021
Recreating the WarGames movie launch code sequence on the Commodore 64, implementing brute-force hash table searching in assembly.
March 13, 2021
Calculating Pi using the Gregory-Leibniz series in BASIC on the VIC-20 for Pi Day, demonstrating the inefficient but educational iterative approach.
March 13, 2021
Comparing two assembly language approaches to counting to 16 million on the Commodore 64, demonstrating significant performance differences.
March 10, 2021
Comparing various video output improvements for vintage Commodore computers including RF modulator replacement, chroma resistor mod, and the c0pperdragon component video mod.
March 8, 2021
Recreating the Terminator 2 ATM PIN cracker scene on the Commodore 64, using SID chip random numbers and 6502 assembly.
March 7, 2021
Building a Caesar cipher encoder and brute-force decoder on the Commodore 64, demonstrating how to crack simple substitution ciphers programmatically.
March 1, 2021
Implementing the shift cipher on the Commodore 64, encoding messages by rotating alphabet positions similar to a physical code wheel.
February 26, 2021
Replacing the RF modulator on a PAL Commodore 64C with an S-Video bypass board to dramatically improve video output quality.
February 24, 2021
Starting a series on implementing ciphers in Commodore assembly language, beginning with a simple string reversal as the first building block.
February 10, 2021
Implementing a one-time pad cipher by hand using dice-generated random numbers, inspired by the encryption methods in Cryptonomicon.
January 26, 2021
A beginner’s guide to learning 6502 assembly programming on the Commodore 64, including recommended tools, resources, and development environment setup.
January 22, 2021
Reviewing Soul Force and Outrage, two modern Commodore 64 games from Protovision being played on a PAL 64C.
December 31, 2020
A defense of using modern conveniences like LCD monitors, SD2IEC devices, and flash cartridges with vintage computers, explaining the practical reasons behind these choices.
December 24, 2020
A Christmas greeting featuring a Commodore 64 holiday demo video.
November 25, 2020
Reflections on getting back into 8-bit computing after building Ben Eater’s breadboard 6502, and why learning vintage assembly language doesn’t need justification.
November 26, 2025
Vibe coding with AI feels productive until it isn’t. Dorothy Vaughan’s team didn’t just operate the IBM—they understood the math behind it. That’s why they succeeded. Here’s why first principles must come before AI assistance.
November 24, 2025
When IBM machines threatened to make her job obsolete, Dorothy Vaughan didn’t retreat—she learned FORTRAN and taught her entire team. Her story offers a blueprint for surviving technological change in any era.
November 26, 2025
Vibe coding with AI feels productive until it isn’t. Dorothy Vaughan’s team didn’t just operate the IBM—they understood the math behind it. That’s why they succeeded. Here’s why first principles must come before AI assistance.
November 26, 2025
Vibe coding with AI feels productive until it isn’t. Dorothy Vaughan’s team didn’t just operate the IBM—they understood the math behind it. That’s why they succeeded. Here’s why first principles must come before AI assistance.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 26, 2025
Vibe coding with AI feels productive until it isn’t. Dorothy Vaughan’s team didn’t just operate the IBM—they understood the math behind it. That’s why they succeeded. Here’s why first principles must come before AI assistance.
November 26, 2025
Vibe coding with AI feels productive until it isn’t. Dorothy Vaughan’s team didn’t just operate the IBM—they understood the math behind it. That’s why they succeeded. Here’s why first principles must come before AI assistance.
November 26, 2025
Vibe coding with AI feels productive until it isn’t. Dorothy Vaughan’s team didn’t just operate the IBM—they understood the math behind it. That’s why they succeeded. Here’s why first principles must come before AI assistance.
November 24, 2025
When IBM machines threatened to make her job obsolete, Dorothy Vaughan didn’t retreat—she learned FORTRAN and taught her entire team. Her story offers a blueprint for surviving technological change in any era.
November 24, 2025
When IBM machines threatened to make her job obsolete, Dorothy Vaughan didn’t retreat—she learned FORTRAN and taught her entire team. Her story offers a blueprint for surviving technological change in any era.
November 24, 2025
When IBM machines threatened to make her job obsolete, Dorothy Vaughan didn’t retreat—she learned FORTRAN and taught her entire team. Her story offers a blueprint for surviving technological change in any era.
November 24, 2025
When IBM machines threatened to make her job obsolete, Dorothy Vaughan didn’t retreat—she learned FORTRAN and taught her entire team. Her story offers a blueprint for surviving technological change in any era.
November 24, 2025
When IBM machines threatened to make her job obsolete, Dorothy Vaughan didn’t retreat—she learned FORTRAN and taught her entire team. Her story offers a blueprint for surviving technological change in any era.
November 24, 2025
When IBM machines threatened to make her job obsolete, Dorothy Vaughan didn’t retreat—she learned FORTRAN and taught her entire team. Her story offers a blueprint for surviving technological change in any era.
November 24, 2025
When IBM machines threatened to make her job obsolete, Dorothy Vaughan didn’t retreat—she learned FORTRAN and taught her entire team. Her story offers a blueprint for surviving technological change in any era.
March 26, 2025
Running 10PRINT and 100 Doors on the Clockwork Pi PicoCalc, a retro-inspired Raspberry Pi Pico handheld running PicoMite BASIC.
March 21, 2024
Solving the classic McNuggets Problem in Commodore BASIC: what’s the largest number of nuggets you can’t buy with 6, 9, and 20 packs?
March 13, 2024
Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.
December 21, 2023
An introduction to Linear Feedback Shift Registers: how they work, building one on a breadboard with shift registers and XOR gates, and implementing them in Python and Rust.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
July 7, 2022
Understanding the MOS paper tape format used by the KIM-1 and other 6502 systems. Breaking down the hex format line by line with checksum verification.
January 11, 2022
Recreating the visual 100 door problem from vintage 8-bit machines in Python using the Asciimatics library for ASCII screen positioning.
December 20, 2021
Generating all 362,880 permutations of 1-9 the hard way: understanding algorithms instead of relying on library functions. Implementations in Python, BASIC, and 6502 assembly.
November 24, 2025
When IBM machines threatened to make her job obsolete, Dorothy Vaughan didn’t retreat—she learned FORTRAN and taught her entire team. Her story offers a blueprint for surviving technological change in any era.
May 30, 2025
Exploring three different maze generation algorithms on the Commodore 64: Depth-First Search, Randomized Prim’s, and the classic 1981 algorithm from Compute! magazine.
May 30, 2025
Exploring three different maze generation algorithms on the Commodore 64: Depth-First Search, Randomized Prim’s, and the classic 1981 algorithm from Compute! magazine.
May 20, 2025
Implementing 16-bit unsigned AND operations in Commodore BASIC using two’s complement to work around the signed integer limitation.
May 20, 2025
Implementing 16-bit unsigned AND operations in Commodore BASIC using two’s complement to work around the signed integer limitation.
May 16, 2025
Implementing 10PRINT on a KIM-1 clone (PAL-II) in both Microsoft BASIC and 6502 assembly, displaying the maze on the 7-segment LED display.
April 19, 2024
Exploring wAx, a native assembler for the VIC-20 that integrates with BASIC. Includes examples implementing 10PRINT and Fibonacci in assembly directly on the machine.
January 11, 2024
Optimizing a simple counting loop on the 6502, progressing from slow BASIC to increasingly faster assembly implementations. A practical guide to 6502 optimization.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
May 20, 2025
Implementing 16-bit unsigned AND operations in Commodore BASIC using two’s complement to work around the signed integer limitation.
May 16, 2025
Implementing 10PRINT on a KIM-1 clone (PAL-II) in both Microsoft BASIC and 6502 assembly, displaying the maze on the 7-segment LED display.
March 26, 2025
Running 10PRINT and 100 Doors on the Clockwork Pi PicoCalc, a retro-inspired Raspberry Pi Pico handheld running PicoMite BASIC.
May 20, 2025
Implementing 16-bit unsigned AND operations in Commodore BASIC using two’s complement to work around the signed integer limitation.
May 20, 2025
Implementing 16-bit unsigned AND operations in Commodore BASIC using two’s complement to work around the signed integer limitation.
May 20, 2025
Implementing 16-bit unsigned AND operations in Commodore BASIC using two’s complement to work around the signed integer limitation.
May 16, 2025
Celebrating the gloriously absurd cover of ‘FORTH on the Atari’—possibly the greatest unintentionally funny book cover ever created.
May 16, 2025
Celebrating the gloriously absurd cover of ‘FORTH on the Atari’—possibly the greatest unintentionally funny book cover ever created.
May 16, 2025
Celebrating the gloriously absurd cover of ‘FORTH on the Atari’—possibly the greatest unintentionally funny book cover ever created.
May 16, 2025
Celebrating the gloriously absurd cover of ‘FORTH on the Atari’—possibly the greatest unintentionally funny book cover ever created.
May 16, 2025
Celebrating the gloriously absurd cover of ‘FORTH on the Atari’—possibly the greatest unintentionally funny book cover ever created.
May 16, 2025
Implementing 10PRINT on a KIM-1 clone (PAL-II) in both Microsoft BASIC and 6502 assembly, displaying the maze on the 7-segment LED display.
May 5, 2023
Modern and retro mix
One of my favorite peices of retro clone hardware is Bob Corsham’s KIM-1 Clone. I’ve featured it many places like the 6502 speed series.
I have the latest model of this board, and he made an interesting design choice. It actually has an FTDI chip on board and you use that via USB to connect via a modern computer with an FTDI driver. This is very convenient for working with a modern computer, but then eliminates the ability to use a real serial port.
March 2, 2023
Driving LEDs from the VIC-20 and KIM-1 USR ports. Binary counting in the real world with vintage hardware.
January 26, 2023
Exploring the elegant maze generator from Compute! magazine (December 1981). A line-by-line breakdown of how this classic BASIC algorithm works.
December 1, 2022
Writing code to validate Pilish text—prose where word lengths match the digits of Pi. Implementations in Julia and Commodore BASIC.
October 21, 2022
Evaluating vintage computers for NaNoWriMo 2022: VIC-20, Plus/4, Commodore 64, and PET. Word processing on 8-bit machines with SpeedScript and other tools.
July 7, 2022
Understanding the MOS paper tape format used by the KIM-1 and other 6502 systems. Breaking down the hex format line by line with checksum verification.
June 22, 2022
Optimizing 6502 memory transfers beyond the general-purpose approach. Testing on a 1MHz KIM-1 clone with precise timing measurements.
June 14, 2022
Testing real-world memory transfer speeds on 6502 machines. Inspired by Apple M2 marketing, let’s see what Commodore hardware can actually do.
May 25, 2022
Finding k-almost-primes using TinyBASIC on a KIM-1 clone. A look at the copyleft origins of TinyBASIC and Bill Gates’ infamous open letter.
May 10, 2022
Implementing 64-bit arithmetic in 6502 assembly to solve the wheat and chessboard problem. Handling numbers too large for standard calculators on 8-bit machines.
March 24, 2022
Computing and displaying the first 10 Fibonacci numbers on a KIM-1’s hex display. Learning 6502 assembly the hard way with pencil and paper.
March 26, 2025
Running 10PRINT and 100 Doors on the Clockwork Pi PicoCalc, a retro-inspired Raspberry Pi Pico handheld running PicoMite BASIC.
January 11, 2022
Recreating the visual 100 door problem from vintage 8-bit machines in Python using the Asciimatics library for ASCII screen positioning.
March 26, 2025
Running 10PRINT and 100 Doors on the Clockwork Pi PicoCalc, a retro-inspired Raspberry Pi Pico handheld running PicoMite BASIC.
March 26, 2025
Running 10PRINT and 100 Doors on the Clockwork Pi PicoCalc, a retro-inspired Raspberry Pi Pico handheld running PicoMite BASIC.
January 16, 2025
A visual exploration of the classic 100 Doors programming problem implemented in PICO-8, featuring animated circles that show the door-toggling pattern in action. This version pays homage to the VIC-20 implementation while leveraging PICO-8’s built-in game loop for smooth animation and visual feedback. Complete with code explanations and comparison to the classic VIC-20 version.
January 16, 2025
A visual exploration of the classic 100 Doors programming problem implemented in PICO-8, featuring animated circles that show the door-toggling pattern in action. This version pays homage to the VIC-20 implementation while leveraging PICO-8’s built-in game loop for smooth animation and visual feedback. Complete with code explanations and comparison to the classic VIC-20 version.
January 10, 2025
Continuing the exploration of 10PRINT, we look at how to implement the 10 Print algorithm on the Pico-8 platform.
January 16, 2025
A visual exploration of the classic 100 Doors programming problem implemented in PICO-8, featuring animated circles that show the door-toggling pattern in action. This version pays homage to the VIC-20 implementation while leveraging PICO-8’s built-in game loop for smooth animation and visual feedback. Complete with code explanations and comparison to the classic VIC-20 version.
January 10, 2025
Continuing the exploration of 10PRINT, we look at how to implement the 10 Print algorithm on the Pico-8 platform.
September 13, 2024
We draw some dragon curves with Logo on the Commodore 64 inspired by Jurassic Park
September 13, 2024
We draw some dragon curves with Logo on the Commodore 64 inspired by Jurassic Park
September 13, 2024
We draw some dragon curves with Logo on the Commodore 64 inspired by Jurassic Park
September 13, 2024
We draw some dragon curves with Logo on the Commodore 64 inspired by Jurassic Park
September 13, 2024
We draw some dragon curves with Logo on the Commodore 64 inspired by Jurassic Park
September 13, 2024
We draw some dragon curves with Logo on the Commodore 64 inspired by Jurassic Park
July 30, 2024
A head-to-head performance comparison of the classic 10PRINT maze algorithm implemented in Rust and C, with benchmarks measuring millions of iterations.
April 19, 2024
Exploring wAx, a native assembler for the VIC-20 that integrates with BASIC. Includes examples implementing 10PRINT and Fibonacci in assembly directly on the machine.
April 5, 2024
Implementing the classic 10PRINT maze algorithm on the HP-42s calculator using RPN programming. Works on SwissMicros DM42 and Free42 emulators too.
March 21, 2024
Solving the classic McNuggets Problem in Commodore BASIC: what’s the largest number of nuggets you can’t buy with 6, 9, and 20 packs?
March 13, 2024
Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.
July 30, 2024
A head-to-head performance comparison of the classic 10PRINT maze algorithm implemented in Rust and C, with benchmarks measuring millions of iterations.
July 30, 2024
A head-to-head performance comparison of the classic 10PRINT maze algorithm implemented in Rust and C, with benchmarks measuring millions of iterations.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
July 30, 2024
A head-to-head performance comparison of the classic 10PRINT maze algorithm implemented in Rust and C, with benchmarks measuring millions of iterations.
December 21, 2023
An introduction to Linear Feedback Shift Registers: how they work, building one on a breadboard with shift registers and XOR gates, and implementing them in Python and Rust.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
April 19, 2024
Exploring wAx, a native assembler for the VIC-20 that integrates with BASIC. Includes examples implementing 10PRINT and Fibonacci in assembly directly on the machine.
December 19, 2023
Commodore BASIC 2.0
A lot of fun with binary numbers can be had by printing them to the screen. This is a quick post to show how to do that with Commodore BASIC 2.0. This is a follow up to Quick Post: XOR in Commodore BASIC 2.0.
We’ll be using both of these in upcoming posts, so it’s good to have them handy.
5 REM PRINT ALL 8 BIT NUMBERS IN BINARY
10 FOR N= 0 TO 255
20 FORI=7 TO 0 STEP-1
25 B=0
30 IF N AND 2^I THEN B=1
40 PRINTMID$(STR$(B),2);
50 NEXT
60 PRINTN
70 NEXT
This prints all the numbers from 0 to 255 in binary. It’s a little slow, but it’s easy to understand and fun to watch.
May 5, 2023
Modern and retro mix
One of my favorite peices of retro clone hardware is Bob Corsham’s KIM-1 Clone. I’ve featured it many places like the 6502 speed series.
I have the latest model of this board, and he made an interesting design choice. It actually has an FTDI chip on board and you use that via USB to connect via a modern computer with an FTDI driver. This is very convenient for working with a modern computer, but then eliminates the ability to use a real serial port.
March 2, 2023
Driving LEDs from the VIC-20 and KIM-1 USR ports. Binary counting in the real world with vintage hardware.
January 26, 2023
Exploring the elegant maze generator from Compute! magazine (December 1981). A line-by-line breakdown of how this classic BASIC algorithm works.
December 1, 2022
Writing code to validate Pilish text—prose where word lengths match the digits of Pi. Implementations in Julia and Commodore BASIC.
October 21, 2022
Evaluating vintage computers for NaNoWriMo 2022: VIC-20, Plus/4, Commodore 64, and PET. Word processing on 8-bit machines with SpeedScript and other tools.
July 15, 2022
Adding integers with hundreds of digits using string manipulation in Commodore BASIC. When your numbers are too big for Wolfram Alpha.
May 15, 2022
Starting a year-long project to reverse engineer and create a drop-in FPGA replacement for the VIC-20’s 6560/6561 video chip.
May 10, 2022
Implementing 64-bit arithmetic in 6502 assembly to solve the wheat and chessboard problem. Handling numbers too large for standard calculators on 8-bit machines.
May 5, 2022
Before and after comparison of S-Video mod results on the Vicky-20 PAL replica board. Dramatic improvement over composite output.
May 4, 2022
Extending Commodore BASIC with a PRINT AT command using machine language, then using it to visualize the 100 door problem.
March 21, 2022
Visualizing the poor randomness of RND() on the Commodore 64 and 128 compared to the PET and Plus/4. Clear patterns emerge when you plot the output.
December 20, 2021
Generating all 362,880 permutations of 1-9 the hard way: understanding algorithms instead of relying on library functions. Implementations in Python, BASIC, and 6502 assembly.
December 14, 2021
Attempting the annual Advent of Code challenge on vintage 8-bit computers. Completing about 60% of puzzles on Commodore hardware.
September 3, 2021
Calculating Pi on a Tandy Color Computer 2 with basic (non-Extended) BASIC. Working around the missing exponent function.
August 5, 2021
Solving the classic 100 door problem with visual output on multiple vintage systems: VIC-20, C64, PET, Atari, and Color Maximite.
July 18, 2021
How to load and run Commodore 64 BASIC programs on a PET. Working around the PET’s lack of program relocation.
June 9, 2021
Generating pseudo-random numbers with the Lagged Fibonacci Sequence on the VIC-20. Building reusable BASIC subroutines for the cipher toolbox.
May 19, 2021
Porting Robin’s VIC-20 Super Expander programming challenge to the Commodore 64 using Super Expander 64 and Simon’s BASIC.
May 15, 2021
How to perform modulo operations in Commodore BASIC 2 without a cartridge. A one-line solution for VIC-20 and C64.
April 19, 2024
Exploring wAx, a native assembler for the VIC-20 that integrates with BASIC. Includes examples implementing 10PRINT and Fibonacci in assembly directly on the machine.
April 5, 2024
Implementing the classic 10PRINT maze algorithm on the HP-42s calculator using RPN programming. Works on SwissMicros DM42 and Free42 emulators too.
November 30, 2023
Implementing 10PRINT on the TI-92 calculator using TI-BASIC. Also covers Python versions on the Numworks and TI-nspire calculators.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
March 27, 2022
Writing a y^x exponent program for the HP-16C calculator, which curiously lacks scientific functions. Building a kit clone and programming in RPN.
April 5, 2024
Implementing the classic 10PRINT maze algorithm on the HP-42s calculator using RPN programming. Works on SwissMicros DM42 and Free42 emulators too.
April 5, 2024
Implementing the classic 10PRINT maze algorithm on the HP-42s calculator using RPN programming. Works on SwissMicros DM42 and Free42 emulators too.
April 5, 2024
Implementing the classic 10PRINT maze algorithm on the HP-42s calculator using RPN programming. Works on SwissMicros DM42 and Free42 emulators too.
March 13, 2024
Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.
March 13, 2024
Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.
March 13, 2024
Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.
January 11, 2024
Optimizing a simple counting loop on the 6502, progressing from slow BASIC to increasingly faster assembly implementations. A practical guide to 6502 optimization.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
September 8, 2023
Implementing the Rail Fence Cipher on the Commodore 64 and TI 99/4A. A fun transposition cipher for secret messages with kids.
May 5, 2023
Modern and retro mix
One of my favorite peices of retro clone hardware is Bob Corsham’s KIM-1 Clone. I’ve featured it many places like the 6502 speed series.
I have the latest model of this board, and he made an interesting design choice. It actually has an FTDI chip on board and you use that via USB to connect via a modern computer with an FTDI driver. This is very convenient for working with a modern computer, but then eliminates the ability to use a real serial port.
January 11, 2024
Optimizing a simple counting loop on the 6502, progressing from slow BASIC to increasingly faster assembly implementations. A practical guide to 6502 optimization.
January 11, 2024
Optimizing a simple counting loop on the 6502, progressing from slow BASIC to increasingly faster assembly implementations. A practical guide to 6502 optimization.
January 3, 2024
Building and verifying the Commodore 64 SID chip’s 23-bit LFSR in hardware on a breadboard and comparing the output against the actual SID chip.
December 21, 2023
An introduction to Linear Feedback Shift Registers: how they work, building one on a breadboard with shift registers and XOR gates, and implementing them in Python and Rust.
January 3, 2024
Building and verifying the Commodore 64 SID chip’s 23-bit LFSR in hardware on a breadboard and comparing the output against the actual SID chip.
December 21, 2023
An introduction to Linear Feedback Shift Registers: how they work, building one on a breadboard with shift registers and XOR gates, and implementing them in Python and Rust.
June 22, 2022
Optimizing 6502 memory transfers beyond the general-purpose approach. Testing on a 1MHz KIM-1 clone with precise timing measurements.
May 25, 2022
Finding k-almost-primes using TinyBASIC on a KIM-1 clone. A look at the copyleft origins of TinyBASIC and Bill Gates’ infamous open letter.
May 15, 2022
Starting a year-long project to reverse engineer and create a drop-in FPGA replacement for the VIC-20’s 6560/6561 video chip.
March 27, 2022
Writing a y^x exponent program for the HP-16C calculator, which curiously lacks scientific functions. Building a kit clone and programming in RPN.
March 24, 2022
Computing and displaying the first 10 Fibonacci numbers on a KIM-1’s hex display. Learning 6502 assembly the hard way with pencil and paper.
March 16, 2022
Adding green and amber screen colors to the MiniPET 40/80 replica using a cheap monochrome VGA color adapter from Tindie.
October 8, 2021
A week exploring the Atari 800XL from a Commodore guy’s perspective. Comparing BASIC implementations and discovering the platform’s strengths.
October 6, 2021
Two weeks with a Tandy Color Computer 2 for SepTandy. Exploring a machine I’ve owned for years but never really used.
September 9, 2021
A simple slot machine game written in BASIC for the Tandy TRS-80 PC-4 pocket computer during SepTandy.
July 9, 2021
Building the CERBERUS 2080, an open-source computer with three processors: ATMega328p, W65C02, and Z80. A project to truly understand how computers work.
May 18, 2021
Documenting oscilloscope readings from working vintage computer chips to help diagnose faulty machines. A collaborative troubleshooting resource.
April 21, 2021
Building a portable Commodore 64 development rig using a Pelican case, external monitor, and either TheC64 or Ultimate 64 for on-the-go retro computing.
April 14, 2021
Repairing a Commodore 128 with bad RAM using DIY Chris’s RAM tester to diagnose and replace faulty 4164 memory chips.
March 29, 2021
A deep dive video exploring hidden Easter eggs within an Easter egg on a 35-year-old album discovered using a Commodore 64.
March 18, 2021
Benchmarking BASIC execution speed across various retro computers using jiffy timing, comparing Commodore machines and other vintage systems.
March 10, 2021
Comparing various video output improvements for vintage Commodore computers including RF modulator replacement, chroma resistor mod, and the c0pperdragon component video mod.
February 26, 2021
Replacing the RF modulator on a PAL Commodore 64C with an S-Video bypass board to dramatically improve video output quality.
January 3, 2024
Building and verifying the Commodore 64 SID chip’s 23-bit LFSR in hardware on a breadboard and comparing the output against the actual SID chip.
December 21, 2023
An introduction to Linear Feedback Shift Registers: how they work, building one on a breadboard with shift registers and XOR gates, and implementing them in Python and Rust.
January 3, 2024
Building and verifying the Commodore 64 SID chip’s 23-bit LFSR in hardware on a breadboard and comparing the output against the actual SID chip.
November 30, 2023
Implementing 10PRINT on the TI-92 calculator using TI-BASIC. Also covers Python versions on the Numworks and TI-nspire calculators.
May 5, 2023
Modern and retro mix
One of my favorite peices of retro clone hardware is Bob Corsham’s KIM-1 Clone. I’ve featured it many places like the 6502 speed series.
I have the latest model of this board, and he made an interesting design choice. It actually has an FTDI chip on board and you use that via USB to connect via a modern computer with an FTDI driver. This is very convenient for working with a modern computer, but then eliminates the ability to use a real serial port.
January 26, 2023
Exploring the elegant maze generator from Compute! magazine (December 1981). A line-by-line breakdown of how this classic BASIC algorithm works.
December 1, 2022
Writing code to validate Pilish text—prose where word lengths match the digits of Pi. Implementations in Julia and Commodore BASIC.
October 21, 2022
Evaluating vintage computers for NaNoWriMo 2022: VIC-20, Plus/4, Commodore 64, and PET. Word processing on 8-bit machines with SpeedScript and other tools.
July 15, 2022
Adding integers with hundreds of digits using string manipulation in Commodore BASIC. When your numbers are too big for Wolfram Alpha.
May 10, 2022
Implementing 64-bit arithmetic in 6502 assembly to solve the wheat and chessboard problem. Handling numbers too large for standard calculators on 8-bit machines.
March 21, 2022
Visualizing the poor randomness of RND() on the Commodore 64 and 128 compared to the PET and Plus/4. Clear patterns emerge when you plot the output.
March 16, 2022
Adding green and amber screen colors to the MiniPET 40/80 replica using a cheap monochrome VGA color adapter from Tindie.
August 5, 2021
Solving the classic 100 door problem with visual output on multiple vintage systems: VIC-20, C64, PET, Atari, and Color Maximite.
July 18, 2021
How to load and run Commodore 64 BASIC programs on a PET. Working around the PET’s lack of program relocation.
November 30, 2023
Implementing 10PRINT on the TI-92 calculator using TI-BASIC. Also covers Python versions on the Numworks and TI-nspire calculators.
November 30, 2023
Implementing 10PRINT on the TI-92 calculator using TI-BASIC. Also covers Python versions on the Numworks and TI-nspire calculators.
November 30, 2023
Implementing 10PRINT on the TI-92 calculator using TI-BASIC. Also covers Python versions on the Numworks and TI-nspire calculators.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
November 21, 2023
Understanding two’s complement: how computers represent negative numbers, why it simplifies hardware design, and how to work with signed integers in assembly and high-level languages.
October 12, 2023
Solving the classic N-Queens puzzle using backtracking. Covers both iterative and recursive approaches with implementations on the Commodore 64.
January 26, 2023
Exploring the elegant maze generator from Compute! magazine (December 1981). A line-by-line breakdown of how this classic BASIC algorithm works.
December 1, 2022
Writing code to validate Pilish text—prose where word lengths match the digits of Pi. Implementations in Julia and Commodore BASIC.
October 21, 2022
Evaluating vintage computers for NaNoWriMo 2022: VIC-20, Plus/4, Commodore 64, and PET. Word processing on 8-bit machines with SpeedScript and other tools.
July 15, 2022
Adding integers with hundreds of digits using string manipulation in Commodore BASIC. When your numbers are too big for Wolfram Alpha.
July 7, 2022
Understanding the MOS paper tape format used by the KIM-1 and other 6502 systems. Breaking down the hex format line by line with checksum verification.
May 10, 2022
Implementing 64-bit arithmetic in 6502 assembly to solve the wheat and chessboard problem. Handling numbers too large for standard calculators on 8-bit machines.
March 21, 2022
Visualizing the poor randomness of RND() on the Commodore 64 and 128 compared to the PET and Plus/4. Clear patterns emerge when you plot the output.
October 28, 2021
Testing the Commodore 64’s random number generator by simulating dice rolls and comparing the frequency distribution to theoretical values.
May 15, 2021
How to perform modulo operations in Commodore BASIC 2 without a cartridge. A one-line solution for VIC-20 and C64.
May 13, 2021
Implementing Pontifex/Solitaire—the playing card cipher from Cryptonomicon designed by Bruce Schneier—on the Commodore 64.
May 10, 2021
Generating one-time pads on a Commodore 64. Probably a bad idea for real security, but it looks cool.
April 28, 2021
Understanding hash collisions by finding them in a simple checksum from a 1984 type-in game. Demonstrating why weak hashes fail.
April 26, 2021
Finding prime numbers on the Commodore 64 for cryptographic purposes. A practical introduction to primes and primality testing.
April 19, 2021
Implementing the RC4 stream cipher on the Commodore 64, exploring the algorithm that powered WEP, WPA, and many other encryption protocols.
April 6, 2021
Exploring pseudo-random number generation on the Commodore 64 using Linear Congruential Generators, a key building block for cryptographic applications.
April 1, 2021
Understanding the XOR operation and its magical properties for data recovery in cryptography and disk storage on the Commodore 64.
March 29, 2021
A quick tutorial on determining string length in 6510 assembly language, comparing the approach to Python’s simple len() function.
March 8, 2021
Recreating the Terminator 2 ATM PIN cracker scene on the Commodore 64, using SID chip random numbers and 6502 assembly.
March 7, 2021
Building a Caesar cipher encoder and brute-force decoder on the Commodore 64, demonstrating how to crack simple substitution ciphers programmatically.
March 1, 2021
Implementing the shift cipher on the Commodore 64, encoding messages by rotating alphabet positions similar to a physical code wheel.
February 24, 2021
Starting a series on implementing ciphers in Commodore assembly language, beginning with a simple string reversal as the first building block.
February 10, 2021
Implementing a one-time pad cipher by hand using dice-generated random numbers, inspired by the encryption methods in Cryptonomicon.
October 12, 2023
Solving the classic N-Queens puzzle using backtracking. Covers both iterative and recursive approaches with implementations on the Commodore 64.
September 8, 2023
Implementing the Rail Fence Cipher on the Commodore 64 and TI 99/4A. A fun transposition cipher for secret messages with kids.
June 28, 2023
Rockwell International was a powerhouse of the 1970s and 80s.
The Rockwell AIM 65 computer, also known as the Advanced Interactive Microcomputer 65, is an early microcomputer produced by Rockwell International in the late 1970s. It was essentially a development system, intended primarily for engineers, educators, and hobbyists, and was named for its built-in alphanumeric keyboard and LED display.

The AIM 65 was built around the 6502 microprocessor, the same chip used in popular systems like the Apple II, Commodore PET, and Atari 2600. The AIM 65 was designed as a single-board computer, with the processor, memory, input, and output all integrated into one circuit board.
June 28, 2023
Rockwell International was a powerhouse of the 1970s and 80s.
The Rockwell AIM 65 computer, also known as the Advanced Interactive Microcomputer 65, is an early microcomputer produced by Rockwell International in the late 1970s. It was essentially a development system, intended primarily for engineers, educators, and hobbyists, and was named for its built-in alphanumeric keyboard and LED display.

The AIM 65 was built around the 6502 microprocessor, the same chip used in popular systems like the Apple II, Commodore PET, and Atari 2600. The AIM 65 was designed as a single-board computer, with the processor, memory, input, and output all integrated into one circuit board.
May 5, 2023
Modern and retro mix
One of my favorite peices of retro clone hardware is Bob Corsham’s KIM-1 Clone. I’ve featured it many places like the 6502 speed series.
I have the latest model of this board, and he made an interesting design choice. It actually has an FTDI chip on board and you use that via USB to connect via a modern computer with an FTDI driver. This is very convenient for working with a modern computer, but then eliminates the ability to use a real serial port.
June 14, 2022
Testing real-world memory transfer speeds on 6502 machines. Inspired by Apple M2 marketing, let’s see what Commodore hardware can actually do.
May 15, 2022
Starting a year-long project to reverse engineer and create a drop-in FPGA replacement for the VIC-20’s 6560/6561 video chip.
May 5, 2022
Before and after comparison of S-Video mod results on the Vicky-20 PAL replica board. Dramatic improvement over composite output.
October 8, 2021
A week exploring the Atari 800XL from a Commodore guy’s perspective. Comparing BASIC implementations and discovering the platform’s strengths.
October 6, 2021
Two weeks with a Tandy Color Computer 2 for SepTandy. Exploring a machine I’ve owned for years but never really used.
July 9, 2021
Building the CERBERUS 2080, an open-source computer with three processors: ATMega328p, W65C02, and Z80. A project to truly understand how computers work.
April 14, 2021
Repairing a Commodore 128 with bad RAM using DIY Chris’s RAM tester to diagnose and replace faulty 4164 memory chips.
March 10, 2021
Comparing various video output improvements for vintage Commodore computers including RF modulator replacement, chroma resistor mod, and the c0pperdragon component video mod.
March 21, 2022
Visualizing the poor randomness of RND() on the Commodore 64 and 128 compared to the PET and Plus/4. Clear patterns emerge when you plot the output.
June 9, 2021
Generating pseudo-random numbers with the Lagged Fibonacci Sequence on the VIC-20. Building reusable BASIC subroutines for the cipher toolbox.
May 13, 2021
Implementing Pontifex/Solitaire—the playing card cipher from Cryptonomicon designed by Bruce Schneier—on the Commodore 64.
May 10, 2021
Generating one-time pads on a Commodore 64. Probably a bad idea for real security, but it looks cool.
April 28, 2021
Understanding hash collisions by finding them in a simple checksum from a 1984 type-in game. Demonstrating why weak hashes fail.
April 26, 2021
Finding prime numbers on the Commodore 64 for cryptographic purposes. A practical introduction to primes and primality testing.
April 19, 2021
Implementing the RC4 stream cipher on the Commodore 64, exploring the algorithm that powered WEP, WPA, and many other encryption protocols.
April 6, 2021
Exploring pseudo-random number generation on the Commodore 64 using Linear Congruential Generators, a key building block for cryptographic applications.
April 1, 2021
Understanding the XOR operation and its magical properties for data recovery in cryptography and disk storage on the Commodore 64.
March 29, 2021
A quick tutorial on determining string length in 6510 assembly language, comparing the approach to Python’s simple len() function.
March 16, 2021
Recreating the WarGames movie launch code sequence on the Commodore 64, implementing brute-force hash table searching in assembly.
March 8, 2021
Recreating the Terminator 2 ATM PIN cracker scene on the Commodore 64, using SID chip random numbers and 6502 assembly.
March 7, 2021
Building a Caesar cipher encoder and brute-force decoder on the Commodore 64, demonstrating how to crack simple substitution ciphers programmatically.
March 1, 2021
Implementing the shift cipher on the Commodore 64, encoding messages by rotating alphabet positions similar to a physical code wheel.
February 24, 2021
Starting a series on implementing ciphers in Commodore assembly language, beginning with a simple string reversal as the first building block.
February 10, 2021
Implementing a one-time pad cipher by hand using dice-generated random numbers, inspired by the encryption methods in Cryptonomicon.
October 8, 2021
A week exploring the Atari 800XL from a Commodore guy’s perspective. Comparing BASIC implementations and discovering the platform’s strengths.
August 5, 2021
Solving the classic 100 door problem with visual output on multiple vintage systems: VIC-20, C64, PET, Atari, and Color Maximite.
October 6, 2021
Two weeks with a Tandy Color Computer 2 for SepTandy. Exploring a machine I’ve owned for years but never really used.
September 9, 2021
A simple slot machine game written in BASIC for the Tandy TRS-80 PC-4 pocket computer during SepTandy.
September 3, 2021
Calculating Pi on a Tandy Color Computer 2 with basic (non-Extended) BASIC. Working around the missing exponent function.
October 6, 2021
Two weeks with a Tandy Color Computer 2 for SepTandy. Exploring a machine I’ve owned for years but never really used.
September 9, 2021
A simple slot machine game written in BASIC for the Tandy TRS-80 PC-4 pocket computer during SepTandy.
September 3, 2021
Calculating Pi on a Tandy Color Computer 2 with basic (non-Extended) BASIC. Working around the missing exponent function.
October 6, 2021
Two weeks with a Tandy Color Computer 2 for SepTandy. Exploring a machine I’ve owned for years but never really used.
September 9, 2021
A simple slot machine game written in BASIC for the Tandy TRS-80 PC-4 pocket computer during SepTandy.
September 3, 2021
Calculating Pi on a Tandy Color Computer 2 with basic (non-Extended) BASIC. Working around the missing exponent function.
January 21, 2021
Quick instructions for switching a Raspberry Pi from 32-bit to 64-bit Raspbian Linux for ARM assembly programming.
November 25, 2020
Reflections on getting back into 8-bit computing after building Ben Eater’s breadboard 6502, and why learning vintage assembly language doesn’t need justification.
December 22, 2020
My favorite DOS software for DOScember: STSPlus by Dave Ransom, a satellite tracking program that was a fixture on my screen for years.
November 25, 2020
Reflections on getting back into 8-bit computing after building Ben Eater’s breadboard 6502, and why learning vintage assembly language doesn’t need justification.