GlitchGuru & GadgetArchivist
Hey, I’ve been digging into the old Commodore 64 and I found a hidden test mode that unlocks a bunch of undocumented routines. I think it’s a neat puzzle for us to crack together—any chance you’ve seen it before?
Sure, that sounds like a classic hunt. Which routine set are you looking at? Let's dig into the memory map and see what oddities pop up.
Sounds like a good plan. I’m staring at the $0100–$02FF region, that old system variable area. The routine I’m hunting for starts with the bytes D9 6D, then a 0A loop that looks like a hidden stack dump. I’ve marked the spots with tiny sticky notes in the old notebook I keep for these finds. Let’s pull up the ROM dump and see if we can cross‑reference the opcodes with the classic docs from the 1985 compuserve archive. That should give us a clue about the hidden test mode. Ready to dive in?
Yeah, let’s load that ROM dump, set a breakpoint at $0100, and watch how the D9 6D bytes start moving that stack pointer. We’ll track the 0A loop and see if the compiler prints any debug output in the hidden mode. Let's get the 1985 archive docs ready so we can cross‑reference the undocumented opcodes and spot any signature patterns. The deeper we go, the more quirks we’ll find. Let's dig!
Okay, I’ve got the ROM loaded and the breakpoint set. I’ll keep a close eye on the stack pointer as those D9 6D bytes shuffle it around. The 0A loop looks like a quick counter, probably part of the hidden diagnostics. Pull the 1985 docs, and I’ll compare the opcode fingerprints to spot any off‑beat patterns. Let’s see what secrets this old machine is hiding.
Got it—loading the docs now. While you watch the stack pointer dance, I'll flag any opcode sequences that don’t match the official list. Those outliers could be the real clue. If the hidden mode triggers a unique routine, we might see a self‑referential jump or a checksum check that never runs in normal mode. Stay ready, the C64 loves to hide its secrets in plain sight. Let's see what weirdness we unearth.
Sounds like we’re about to uncover one of those little buried quirks. I’ll watch the stack pointer’s every move and flag any odd opcodes that pop up. Those hidden routines usually leave a faint breadcrumb trail—maybe a self‑jump or a checksum that never fires. Keep those docs handy; I’m ready to cross‑reference when we hit a suspicious sequence. Let’s unearth the next forgotten treasure.
Alright, first grab the official C64 opcode list from that 1985 archive and copy it to a sheet. Next, while you’re stepping through at $0100, log every byte that gets fetched – pay special attention to any value that isn’t in the standard set (especially those odd 0x6D or 0xD9 bytes). Write down the instruction address each time a weird opcode appears. Then cross‑reference those addresses with the docs; if you see a pattern like “JMP $xxxx” or a checksum routine, you’ve probably found the hidden test mode stub. Don’t forget to note any stack pointer changes that don’t match normal operation – that’s usually the breadcrumb trail you’re after. Keep a clean log and we’ll piece it together step by step.
Got it, I’ve pulled the 1985 opcode list into my notebook and set up a clean log sheet. I’ll start stepping through at $0100, jotting each fetched byte and its address. Any out‑of‑spec opcodes, especially those 0x6D or 0xD9 bytes, will get a note, along with any stack pointer changes that look off. Once I have the list, I’ll line it up with the docs for patterns like “JMP $xxxx” or checksum checks. Ready to dig into the log.
Nice, the log is your map. As you scroll through, look for any address where a 0xD9 is followed immediately by a 0x6D – that’s a 16‑bit absolute load, but in the middle of a routine it could be an address pointer to another hidden routine. Also, if you see a 0x4C (JMP) right after that, check if the target falls outside the normal ROM range – that could be your hidden jump. Keep an eye on the stack pointer; any sudden decrement that isn’t paired with a subroutine call could be a hidden cleanup routine. Once you have a handful of candidates, we can try stepping into one to see what it prints or checks. Let’s see what the C64 keeps buried.
Got it, I’ll scan the log for any 0xD9 0x6D pairs, then look for a 0x4C that jumps outside the ROM. I’ll also keep an eye on any stack pointer drops that don’t match a call. Once I flag a few candidates I’ll step into one and see what it prints. Let’s dig into the hidden routine.
Sounds good. As soon as you hit a suspect address, set a single‑step there and watch the console. If it starts printing something like “TEST MODE OK” or a block of hex, that’s your cue. Keep noting any uninitialized memory reads or self‑modifying code – that C64 loves to hide bugs in the junk. Once you’ve got the dump, we can run a checksum on the routine to verify it hasn’t been tampered. Let’s see what secrets it’ll spill.