Articles on Imapenguin

Matrix Math on a Commodore 64

Mon, 08 Jun 2026 10:00:00 -0400

Matrix fundamentals from the ground up. Definitions, the operations that matter, plain Python, numpy for comparison, and a complete BASIC program on a real C64.

The SID Chip Is a Reservoir Computer

Wed, 03 Jun 2026 00:00:00 +0000

Reservoir computing says don’t train the dynamics, just train the readout. I used the SID’s analog filter as the dynamics and one ridge regression as the readout. It’s not state of the art, but the chip earns its keep exactly where a linear model falls apart.

WOZMON, Eight CPUs, and a Paper Tape

Thu, 14 May 2026 10:00:00 +0000

Eight CPUs from the 1970s and 1980s, sharing one 64K bus, an Apple-1 style monitor on the front, and a paper tape station. Open it in your browser and poke around.

Forty-Three Quintillion on a Commodore 64

Fri, 08 May 2026 14:26:00 -0400

Where the famous 43 quintillion comes from, why a C64 can’t print it the easy way, and a tiny multi-precision multiplier in BASIC that gets every digit right.

Fixing a Timex Sinclair 2068 and Porting the Bond Maze

Thu, 30 Apr 2026 14:24:00 -0400

I picked up a boxed Timex Sinclair 2068 that wouldn’t boot. An oscilloscope, a BackBit tester, and a fresh Z80 later, it was running. Then I ported Charles Bond’s 1981 maze algorithm from the C64 to Sinclair BASIC.

Biological Processing Units and a Commodore 64

Fri, 24 Apr 2026 11:00:00 -0400

The fruit fly has a brain structure that acts like a hash function. I built it in Python, matched the 2017 paper’s MNIST results against a classical baseline, then got the same algorithm running on a Commodore 64.

Breaking Enigma with Index of Coincidence on a Commodore 64

Tue, 31 Mar 2026 07:00:00 -0500

The Bombe needs a crib. What if you don’t have one? Index of coincidence measures how much an output looks like real language vs random noise. We use it to attack Enigma without any known plaintext.

The Wallis Product for Pi on the C64

Sat, 14 Mar 2026 04:00:00 -0500

John Wallis found an infinite product for pi in 1655. Multiply enough fractions together and pi falls out. We run it on the C64 in BASIC and assembly, watching it converge one digit at a time.

Enigma Ring Settings on the Commodore 64

Wed, 25 Feb 2026 07:00:00 -0500

Ring settings multiply Enigma’s keyspace by 17,576. We add them to our C64 emulator, see why brute force alone can’t keep up, and set the stage for smarter attacks.

Breaking Enigma on the Commodore 64

Tue, 24 Feb 2026 07:00:00 -0500

The Commodore 64 searches nearly six million Enigma M3 configurations to find the one that matches a known plaintext crib. First the concept, then BASIC, then 6502 assembly fast enough to crack it in about 22 minutes.

Enigma Emulator on the Commodore 64

Fri, 20 Feb 2026 07:00:00 -0500

A working Enigma M3 emulator on the Commodore 64. First in BASIC for clarity, then in 6502 assembly for speed. Eight rotors with dual notches, plugboard, and the double-step anomaly, all on a 1 MHz machine.

10 PRINT on the Apple II

Thu, 15 Jan 2026 23:00:00 +0000

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.

The Math Behind Enigma

Thu, 08 Jan 2026 07:00:00 -0500

Why German cryptographers believed Enigma was unbreakable, and why Allied codebreakers ultimately proved them wrong.

Sorting Algorithms Visualized on the Commodore 64

Wed, 17 Dec 2025 10:00:00 +0000

Visualizing sorting algorithms in real-time on the Commodore 64 using PETSCII characters. Three classic algorithms rendered as animated bar charts in BASIC.

First Principles: Why You Must Learn Before You Prompt

Wed, 26 Nov 2025 10:00:00 +0000

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.

Dorothy Vaughan: Adapt or Become Obsolete

Mon, 24 Nov 2025 10:00:00 +0000

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.

Three Maze Generators on the Commodore 64

Fri, 30 May 2025 10:06:13 +0000

Exploring three different maze generation algorithms on the Commodore 64: Depth-First Search, Randomized Prim’s, and the classic 1981 algorithm from Compute! magazine.

16-bit Unsigned AND on Commodore 64

Tue, 20 May 2025 11:19:13 +0000

Implementing 16-bit unsigned AND operations in Commodore BASIC using two’s complement to work around the signed integer limitation.

The Best Book Cover of All Time

Fri, 16 May 2025 11:58:13 +0000

Celebrating the gloriously absurd cover of ‘FORTH on the Atari’—possibly the greatest unintentionally funny book cover ever created.

10 PRINT for the KIM-1

Fri, 16 May 2025 11:19:13 +0000

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.

10PRINT and 100 Doors on the PicoCalc from Clockwork Pi

Wed, 26 Mar 2025 10:06:13 +0000

Running 10PRINT and 100 Doors on the Clockwork Pi PicoCalc, a retro-inspired Raspberry Pi Pico handheld running PicoMite BASIC.

PICO-8 100 Doors Problem

Thu, 16 Jan 2025 10:06:13 +0000

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.

10 Print on PICO-8

Fri, 10 Jan 2025 10:06:13 +0000

Continuing the exploration of 10PRINT, we look at how to implement the 10 Print algorithm on the Pico-8 platform.

Dragon Curves

Fri, 13 Sep 2024 10:06:13 +0000

We draw some dragon curves with Logo on the Commodore 64 inspired by Jurassic Park

10 PRINT in Rust vs C

Tue, 30 Jul 2024 10:06:13 +0000

A head-to-head performance comparison of the classic 10PRINT maze algorithm implemented in Rust and C, with benchmarks measuring millions of iterations.

wAx the VIC-20

Fri, 19 Apr 2024 10:06:13 +0000

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.

10 PRINT on the HP-42s

Fri, 05 Apr 2024 11:06:13 +0000

Implementing the classic 10PRINT maze algorithm on the HP-42s calculator using RPN programming. Works on SwissMicros DM42 and Free42 emulators too.

The McNuggets Problem

Thu, 21 Mar 2024 11:06:13 +0000

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?

Back to the basics with BASIC (and Python): Binary Search

Wed, 13 Mar 2024 12:06:13 +0000

Why your algorithm choice matters: comparing linear search O(n) vs binary search O(log n) with implementations in Commodore BASIC and Python.

Machine Language: Count Faster on 6502

Thu, 11 Jan 2024 21:49:13 +0000

Optimizing a simple counting loop on the 6502, progressing from slow BASIC to increasingly faster assembly implementations. A practical guide to 6502 optimization.

Visualize and verify the reverse engineered Commodore 64 SID LFSR

Wed, 03 Jan 2024 10:49:13 +0000

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.

A Gentle Introduction to LFSRs

Thu, 21 Dec 2023 11:49:13 +0000

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.

Quick Post: Printing binary numbers in Commodore BASIC 2.0

Tue, 19 Dec 2023 11:49:13 +0000

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.

10 Print on the TI-92

Thu, 30 Nov 2023 11:49:13 +0000

Implementing 10PRINT on the TI-92 calculator using TI-BASIC. Also covers Python versions on the Numworks and TI-nspire calculators.

A gentle introduction to two's complement

Tue, 21 Nov 2023 16:30:00 +0000

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.

N-Queens problem

Thu, 12 Oct 2023 13:49:13 +0000

Solving the classic N-Queens puzzle using backtracking. Covers both iterative and recursive approaches with implementations on the Commodore 64.

Rail Fence Cipher on Commoodore 64 and TI 99/4A

Fri, 08 Sep 2023 11:49:13 +0000

Implementing the Rail Fence Cipher on the Commodore 64 and TI 99/4A. A fun transposition cipher for secret messages with kids.

A grid drawing rabbit hole

Fri, 11 Aug 2023 06:53:01 -0400

Drawing grids for screen layout planning on the Commodore 64 and VIC-20. Comparing BASIC, Simon’s BASIC, and Super Expander approaches.

10 PRINT on the Rockwell AIM 65

Wed, 28 Jun 2023 11:03:13 +0000

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.

Building a software serial bridge

Fri, 05 May 2023 11:02:13 +0000

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.

Blinkenlights

Thu, 02 Mar 2023 15:58:08 -0500

Driving LEDs from the VIC-20 and KIM-1 USR ports. Binary counting in the real world with vintage hardware.

40 years on, this is still the best maze algorithm

Thu, 26 Jan 2023 15:49:13 +0000

Exploring the elegant maze generator from Compute! magazine (December 1981). A line-by-line breakdown of how this classic BASIC algorithm works.

Validating Pilish

Thu, 01 Dec 2022 00:55:15 +0000

Writing code to validate Pilish text—prose where word lengths match the digits of Pi. Implementations in Julia and Commodore BASIC.

My mostly retro writing platform contenders in National Novel Writing Month for 2022 NaNoWriMo

Fri, 21 Oct 2022 12:10:52 +0000

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.

Adding very large integers in 8 Bit BASIC

Fri, 15 Jul 2022 18:34:30 +0000

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

MOS paper tape format

Thu, 07 Jul 2022 13:20:09 +0000

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.

A little more speed from the 6502

Wed, 22 Jun 2022 14:14:08 +0000

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

How fast can a 6502 transfer memory

Tue, 14 Jun 2022 13:53:13 +0000

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

Almost primes with TinyBASIC on the KIM-1 clone: PAL-1

Wed, 25 May 2022 19:26:44 +0000

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.

VIC’s Revenge, the drop-in replacement for the VIC-20 VIC chip Part 1: Introduction, design goals, and FAQs

Sun, 15 May 2022 16:19:30 +0000

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

64 Bit Addition and Products on Commodore: The Wheat and Chessboard problem

Tue, 10 May 2022 14:18:42 +0000

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.

Vicky-20 S Video Mod Results

Thu, 05 May 2022 10:37:00 +0000

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

Yet another version of the 100 door problem; this time, let's extend Commodore BASIC to add PRINT @, shall we?

Wed, 04 May 2022 16:03:46 +0000

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

Simple exponents on an HP-16c

Sun, 27 Mar 2022 20:48:16 +0000

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

Fibonacci 1-10 on the KIM-1 (and clones)

Thu, 24 Mar 2022 11:20:00 +0000

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.

The terrible random number generation in the Commodore 64 (and 128)

Mon, 21 Mar 2022 14:01:27 +0000

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.

Getting green and amber screens from a MiniPET 40/80

Wed, 16 Mar 2022 10:58:16 +0000

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

Simple splitting the screen with two colors on the Commodore 64

Mon, 28 Feb 2022 14:54:33 +0000

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

A visual 100 Door Problem solution in Python

Tue, 11 Jan 2022 14:54:57 +0000

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

Permutations of 1 to 9 in Python, BASIC, and 6502 Assembly

Mon, 20 Dec 2021 12:54:06 +0000

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.

Making and breaking codes Part 14- VIC Cipher on the Commodore VIC-20

Thu, 16 Dec 2021 18:54:56 +0000

Implementing the VIC cipher—used by Soviet spies during the Cold War—on the Commodore VIC-20. A simplified version using straddling checkerboards.

Can you do Advent of Code on 8-Bit Machines?

Tue, 14 Dec 2021 22:47:39 +0000

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

Quick Tower of Hanoi with Sound on the Commodore 64

Thu, 28 Oct 2021 17:28:00 +0000

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

Dice frequency

Thu, 28 Oct 2021 10:42:27 +0000

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

A week of diving a little deeper into my Atari 800XL

Fri, 08 Oct 2021 00:30:00 +0000

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 Coco 2 in September

Wed, 06 Oct 2021 00:13:22 +0000

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

Slot Game On Tandy TRS-80 Pocket Computer PC-4

Thu, 09 Sep 2021 11:12:54 +0000

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

Calculating Pi via the Gregory-Leibniz series in BASIC on the Tandy Color Computer 2

Fri, 03 Sep 2021 10:29:00 +0000

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

Just for fun, the 100 door problem on several different systems

Thu, 05 Aug 2021 12:35:40 +0000

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

Recreational Math Challenge: Border Crossings - but on 40 year old computers

Mon, 19 Jul 2021 18:30:06 +0000

Solving a graph theory road trip puzzle on 40-year-old computers. Finding routes through eight US states where you cross each border exactly once.

Running Commodore 64 BASIC Programs on a PET

Sun, 18 Jul 2021 12:45:37 +0000

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

The CERBERUS 2080

Fri, 09 Jul 2021 13:03:02 +0000

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

Making and Breaking Ciphers with Commodore 64 - The Vigenère Cipher

Wed, 23 Jun 2021 12:07:22 +0000

Implementing and understanding the Vigenère cipher on the Commodore 64. A polyalphabetic cipher that builds on Caesar with rotating keys.

Making and breaking Ciphers on the Commodore 64, er VIC-20 - Lagged Fibonacci Sequence and a little Monte Carlo while embracing contraints

Wed, 09 Jun 2021 13:11:42 +0000

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

Quick Post: XOR in Commodore BASIC 2

Thu, 03 Jun 2021 20:24:50 +0000

Two methods for XOR operations in Commodore BASIC 2, which lacks a built-in XOR function. Comparing speed of logic operators vs addition with carry.

Running the 8 Bit Show and Tell VIC-20 Super Expander Programming Challenge on the Commodore 64

Wed, 19 May 2021 14:50:56 +0000

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

The retro pinout project

Tue, 18 May 2021 15:03:49 +0000

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

Quick Post: Modulus in BASIC 2 without a cartridge

Sat, 15 May 2021 18:51:00 +0000

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

Making and breaking Ciphers on the Commodore 64 Part 12 - Pontifex - Solitaire from Cryptonomicon

Thu, 13 May 2021 14:26:23 +0000

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

Making and breaking Ciphers on the Commodore 64 Part 11 - One time pads on a Commodore 64, probably a bad idea

Mon, 10 May 2021 14:44:20 +0000

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

Making and breaking Ciphers on the Commodore 64 Part 10 - Finding hash collisions with a type in game from 1984

Wed, 28 Apr 2021 18:19:36 +0000

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

Making and Breaking Ciphers with Commodore 64 Part 9 - Finding Smallish Primes

Mon, 26 Apr 2021 17:48:47 +0000

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

Quick Post: Slow text on the Commodore

Thu, 22 Apr 2021 11:23:01 +0000

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.

The Commodore 64 N.O.O.C.U.L.A.R. futbal project

Wed, 21 Apr 2021 20:10:02 +0000

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.

Making and breaking Ciphers on the Commodore 64 Part 8 - RC4

Mon, 19 Apr 2021 13:49:09 +0000

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

The Nostalgia Files: My all time favorite book

Fri, 16 Apr 2021 16:33:08 +0000

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 and DIY Chris's RAM tester review

Wed, 14 Apr 2021 14:35:50 +0000

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

Making and breaking Ciphers on the Commodore 64 Part 7 - Pseudo Random with Linear Congruential Generators

Tue, 06 Apr 2021 15:51:05 +0000

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

Making and Breaking Ciphers with a Commodore 64 - Part 6: XOR is Magical - Data recovery

Thu, 01 Apr 2021 14:43:43 +0000

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

Finding the Prodigal Easter Egg inside the Easter Egg on a Commodore 64

Mon, 29 Mar 2021 14:38:00 +0000

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

Quick post: Determining length in Commodore Assembly

Mon, 29 Mar 2021 13:15:11 +0000

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

Benchmarking Retro Computers (mostly Commodore) with marginal methods

Thu, 18 Mar 2021 12:11:54 +0000

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

Jiffies in Assembly

Thu, 18 Mar 2021 00:02:20 +0000

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

Making and Breaking Ciphers with a Commodore 64 - Part 5: Wargames

Tue, 16 Mar 2021 15:36:57 +0000

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

Calculating Pi via the Gregory-Leibniz series in BASIC on the VIC-20

Sat, 13 Mar 2021 15:49:58 +0000

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

Quick Post: Commodore 64 Simple Addition Efficiency

Sat, 13 Mar 2021 12:08:25 +0000

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

c0pperdragon verdict

Wed, 10 Mar 2021 14:23:17 +0000

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

Making and Breaking Ciphers with a Commodore 64 - Part 4: The PIN Program from Terminator 2

Mon, 08 Mar 2021 16:44:54 +0000

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

Making and Breaking Ciphers with a Commodore 64 - Part 3: The Caesar Cipher

Sun, 07 Mar 2021 14:48:17 +0000

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

Making and Breaking Ciphers with Python, er Commodore- Part 2: The Shift Cipher

Mon, 01 Mar 2021 11:00:00 +0000

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

Replacing an RF Modulator on a Commodore 64C

Fri, 26 Feb 2021 13:00:24 +0000

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

Making and Breaking Ciphers with Python, er, a Commodore- Part 1: The Reverse Cipher

Wed, 24 Feb 2021 19:11:00 +0000

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

Simple, 'unbreakable' encryption with a pencil

Wed, 10 Feb 2021 17:59:41 +0000

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

Getting started with Native Commodore 64 Assembly

Tue, 26 Jan 2021 18:42:48 +0000

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

Friday fun: Games I'm playing in Jan 2021

Fri, 22 Jan 2021 11:48:00 +0000

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

Switching to 64 bit Raspbian Linux is a snap

Thu, 21 Jan 2021 14:51:00 +0000

Quick instructions for switching a Raspberry Pi from 32-bit to 64-bit Raspbian Linux for ARM assembly programming.

Did you do that on real hardware?

Thu, 31 Dec 2020 11:33:07 +0000

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

Merry Christmas

Thu, 24 Dec 2020 13:00:00 +0000

A Christmas greeting featuring a Commodore 64 holiday demo video.

My DOScember pick for the best DOS Software

Tue, 22 Dec 2020 14:36:33 +0000

My favorite DOS software for DOScember: STSPlus by Dave Ransom, a satellite tracking program that was a fixture on my screen for years.

Why does there have to be a why?

Wed, 25 Nov 2020 13:34:06 +0000

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.

Imapenguin, reborn

Wed, 25 Nov 2020 13:32:27 +0000

The relaunch of imapenguin.com after 20+ years, transitioning from a consulting company site to a tech blog.

Mon, 01 Jan 0001 00:00:00 +0000

This code you’ve provided is a 6502 assembly language program aimed at solving the 8 Queens problem, which is a classic problem in computer science and mathematics. The goal of the problem is to place eight queens on an 8×8 chessboard such that no two queens threaten each other. This means that no two queens can be in the same row, column, or diagonal.

Here’s a step-by-step walkthrough of the program:

Mon, 01 Jan 0001 00:00:00 +0000