Adding integers with hundreds of digits using string manipulation in Commodore BASIC. When your numbers are too big for Wolfram Alpha.

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.

Optimizing 6502 memory transfers beyond the general-purpose approach. Testing on a 1MHz KIM-1 clone with precise timing measurements.

Testing real-world memory transfer speeds on 6502 machines. Inspired by Apple M2 marketing, let’s see what Commodore hardware can actually do.

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.

Starting a year-long project to reverse engineer and create a drop-in FPGA replacement for the VIC-20’s 6560/6561 video chip.

Before and after comparison of S-Video mod results on the Vicky-20 PAL replica board. Dramatic improvement over composite output.

Extending Commodore BASIC with a PRINT AT command using machine language, then using it to visualize the 100 door problem.

Writing a y^x exponent program for the HP-16C calculator, which curiously lacks scientific functions. Building a kit clone and programming in RPN.

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.

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.

Adding green and amber screen colors to the MiniPET 40/80 replica using a cheap monochrome VGA color adapter from Tindie.

A quick technique for splitting the Commodore 64 screen into two solid colors by manipulating VIC registers and screen memory.

Recreating the visual 100 door problem from vintage 8-bit machines in Python using the Asciimatics library for ASCII screen positioning.

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.

Attempting the annual Advent of Code challenge on vintage 8-bit computers. Completing about 60% of puzzles on Commodore hardware.

Implementing Tower of Hanoi with SID sound on the Commodore 64, inspired by Numberphile’s Ayliean MacDonald video.

Testing the Commodore 64’s random number generator by simulating dice rolls and comparing the frequency distribution to theoretical values.

A week exploring the Atari 800XL from a Commodore guy’s perspective. Comparing BASIC implementations and discovering the platform’s strengths.

Two weeks with a Tandy Color Computer 2 for SepTandy. Exploring a machine I’ve owned for years but never really used.

A simple slot machine game written in BASIC for the Tandy TRS-80 PC-4 pocket computer during SepTandy.

Calculating Pi on a Tandy Color Computer 2 with basic (non-Extended) BASIC. Working around the missing exponent function.

Solving the classic 100 door problem with visual output on multiple vintage systems: VIC-20, C64, PET, Atari, and Color Maximite.

How to load and run Commodore 64 BASIC programs on a PET. Working around the PET’s lack of program relocation.

Building the CERBERUS 2080, an open-source computer with three processors: ATMega328p, W65C02, and Z80. A project to truly understand how computers work.

Generating pseudo-random numbers with the Lagged Fibonacci Sequence on the VIC-20. Building reusable BASIC subroutines for the cipher toolbox.

Documenting oscilloscope readings from working vintage computer chips to help diagnose faulty machines. A collaborative troubleshooting resource.

How to perform modulo operations in Commodore BASIC 2 without a cartridge. A one-line solution for VIC-20 and C64.

Implementing Pontifex/Solitaire—the playing card cipher from Cryptonomicon designed by Bruce Schneier—on the Commodore 64.

Generating one-time pads on a Commodore 64. Probably a bad idea for real security, but it looks cool.

Understanding hash collisions by finding them in a simple checksum from a 1984 type-in game. Demonstrating why weak hashes fail.

Finding prime numbers on the Commodore 64 for cryptographic purposes. A practical introduction to primes and primality testing.

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.

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.

Implementing the RC4 stream cipher on the Commodore 64, exploring the algorithm that powered WEP, WPA, and many other encryption protocols.

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.

Repairing a Commodore 128 with bad RAM using DIY Chris’s RAM tester to diagnose and replace faulty 4164 memory chips.

Exploring pseudo-random number generation on the Commodore 64 using Linear Congruential Generators, a key building block for cryptographic applications.

Understanding the XOR operation and its magical properties for data recovery in cryptography and disk storage on the Commodore 64.

A deep dive video exploring hidden Easter eggs within an Easter egg on a 35-year-old album discovered using a Commodore 64.

A quick tutorial on determining string length in 6510 assembly language, comparing the approach to Python’s simple len() function.

Benchmarking BASIC execution speed across various retro computers using jiffy timing, comparing Commodore machines and other vintage systems.

How to use the Commodore 64’s jiffy clock for benchmarking in both BASIC and assembly language, measuring time in 1/60th second increments.

Recreating the WarGames movie launch code sequence on the Commodore 64, implementing brute-force hash table searching in assembly.

Calculating Pi using the Gregory-Leibniz series in BASIC on the VIC-20 for Pi Day, demonstrating the inefficient but educational iterative approach.

Comparing two assembly language approaches to counting to 16 million on the Commodore 64, demonstrating significant performance differences.

Comparing various video output improvements for vintage Commodore computers including RF modulator replacement, chroma resistor mod, and the c0pperdragon component video mod.

Recreating the Terminator 2 ATM PIN cracker scene on the Commodore 64, using SID chip random numbers and 6502 assembly.

Building a Caesar cipher encoder and brute-force decoder on the Commodore 64, demonstrating how to crack simple substitution ciphers programmatically.

Implementing the shift cipher on the Commodore 64, encoding messages by rotating alphabet positions similar to a physical code wheel.

Replacing the RF modulator on a PAL Commodore 64C with an S-Video bypass board to dramatically improve video output quality.

Starting a series on implementing ciphers in Commodore assembly language, beginning with a simple string reversal as the first building block.

Implementing a one-time pad cipher by hand using dice-generated random numbers, inspired by the encryption methods in Cryptonomicon.

A beginner’s guide to learning 6502 assembly programming on the Commodore 64, including recommended tools, resources, and development environment setup.

Reviewing Soul Force and Outrage, two modern Commodore 64 games from Protovision being played on a PAL 64C.

A defense of using modern conveniences like LCD monitors, SD2IEC devices, and flash cartridges with vintage computers, explaining the practical reasons behind these choices.

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.