2^x bits on Imapenguin

Implementing 64-bit arithmetic in 6502 assembly to solve the wheat and chessboard problem.

Before and after comparison of S-Video mod results on the Vicky-20 PAL replica board.

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.

Computing and displaying the first 10 Fibonacci numbers on a KIM-1’s hex display.

Visualizing the poor randomness of RND() on the Commodore 64 and 128 compared to the PET and Plus/4.

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.

Implementing the VIC cipher—used by Soviet spies during the Cold War—on the Commodore VIC-20.

Attempting the annual Advent of Code challenge on vintage 8-bit computers.

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.

Two weeks with a Tandy Color Computer 2 for SepTandy.

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.

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

Solving a graph theory road trip puzzle on 40-year-old computers.

How to load and run Commodore 64 BASIC programs on a PET.

Building the CERBERUS 2080, an open-source computer with three processors: ATMega328p, W65C02, and Z80.

Implementing and understanding the Vigenère cipher on the Commodore 64.

Generating pseudo-random numbers with the Lagged Fibonacci Sequence on the VIC-20.

Two methods for XOR operations in Commodore BASIC 2, which lacks a built-in XOR function.

Porting Robin’s VIC-20 Super Expander programming challenge to the Commodore 64 using Super Expander 64 and Simon’s BASIC.

Documenting oscilloscope readings from working vintage computer chips to help diagnose faulty machines.

How to perform modulo operations in Commodore BASIC 2 without a cartridge.

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.

Understanding hash collisions by finding them in a simple checksum from a 1984 type-in game.

Finding prime numbers on the Commodore 64 for cryptographic purposes.

How to display text character by character with delays in 6502 assembly using Turbo Macro Pro.

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.