Tiny-4 CPU Reference Sheet

Tiny-4 is a bite-sized 8-bit CPU built for chaos, and nostalgia! With only 256 bytes of RAM and the intellectual capacity of a person watching paint dry, it's perfect for doing crimes (in machine language), teaching people, or moving onto harder things! (time to move to the SFC/SNES now!!!)

Programs are compiled into .t4c files — demons of ones and zeroes that whisper rituals to a CPU that cannot even subtract 2. Execution is fast, fearless, and absolutely guaranteed to HALT eventually. (Don't quote me on this.)

Why I Made This CPU

Retro video game mechanics are the backbone of gaming history.
assembly is fun
256 bytes of dread
Simulating hardware in a virutal environment is good to practice programming!!!
"can it run doom?"
And plenty more reasons why it should of not been made...

Specs at a Glance

RAM: 256 bytes (It'll run DOOM with the Tiny-4 Expansion Pak!)

Registers: A (Accumulator), PC (Program Counter) (More planned) (Not a joke)

Instruction Length: 2 bytes (opcode and operand action!)

Word Size: 8-bit (small but spicy)

Fulfillment: Maybe not...

Memory Map

Address Range	Purpose
0x00–0x07	Reserved for sacred bytes (file metadata)
0x08–0xEF	Your playground. This portion of memory is General Use RAM.
0xF0–0xFF	Reserved / I/O / Divine Intervention

Instruction Set

Opcode	Mnemonic	Format	Description
0x01	LOAD	01 XX	Summon a byte from memory address XX into A
0x02	STORE	02 XX	Calcify A's value into memory address XX
0x03	ADD	03 XX	Absorb byte from address XX into A like it's EXP
0x04	SUB	04 XX	Vaporise byte from address XX into A like it's chalk
0x05	CMP	05 XX	Compare value in reg A with XX, sets the zero flag.
0x08	JMP	08 XX	Dragoon jump to address XX.
0x09	JZ	09 XX	Dragoon jump to address XX, if A is zero
0x0A	JNZ	0A XX	Dragoon jump to address XX, if A isn't zero
0x0B	CALL	0B XX	Carefully store the next instruction at address $F0, then jump to address XX
0x0C	RET	0C XX	Forcefully set the PC to the instruction stored at address $F0
0x0D	OUT	0D XX	Output the data within the byte XX
0xFF	HALT	FF 00	Power nap for your CPU. Execution ends.

How It Works (Internals)

The Tiny-4 CPU is a virtual CPU designed with simplicity in mind. At its core, it fetches 2-byte instructions from memory (opcode + operand), decodes them, and executes the logic in a minimal loop.

Example disassembly output:

00: LOAD $50
02: STORE $30
04: ADD  $04
06: HALT

This means:

LOAD $50: A = RAM[0x50]
STORE $30: RAM[0x30] = A
ADD $04: self.A = (self.A + self.RAM[0x04]) & 0xFF
HALT: Execution stops. Nap time. zzz...

Scripts Explained

tiny4.py — This is the CPU emulator. It defines the RAM, register A, and PC. It fetches, decodes, and executes instructions with step() and loops through the program using run().
tiny4compiler.py — A compiler that takes an input .bin or a test program, attaches the 8-byte Tiny-4 header, and produces a .t4c file. The header contains magic bytes, version, start address, entry point, program size, and a reserved padding byte.
tiny4disassembler.py — A disassembler that reads a .t4c file, checks for the T4C magic, then steps through the instructions 2 bytes at a time and prints a readable disassembly like ADD $04.

This tiny toolchain allows you to write bytecode, compile it, emulate it, and reverse-engineer it — all while giggling like a gremlin.

What It's Based On

Tiny-4 draws inspiration from two iconic bytecode systems: CHIP-8 and Game Boy Assembly. While vastly more limited, Tiny-4 takes cues from their structure, instruction style, and design philosophy — distilling them down into something extremely lean and educational.

Architecture Comparison

Feature	Tiny-4	CHIP-8	Game Boy ASM
Instruction Size	2 bytes (opcode + operand)	2 bytes (single 16-bit opcode)	1–3 bytes (variable)
Memory Size	256 bytes	4 KB (starts at 0x200)	Up to 64 KB
Registers	1 (A)	16 (V0–VF)	AF, BC, DE, HL, SP, PC + flags
Stack Support	No	Yes	Yes
Graphics / Display	No	Yes (64×32 bitmap)	Yes (tile/sprite-based)
Timer / Sound	No	Delay & Sound Timers	Full APU & Timers
Instruction Count	4	~35	~500+

Philosophical Differences

CHIP-8 is a virtual machine built to teach and enable simple games in the 1970s — it abstracts complexity, but includes timers, graphics, and a full stack for subroutines.
Game Boy ASM is real hardware assembly — full control, full chaos. You deal with flags, memory banking, and interrupt vectors like a grown-up.
Tiny-4 says: “What if we tossed out literally everything except memory access and arithmetic?” You get no graphics, no jumps, no stack, no calls. Just raw 8-bit memory, 4 instructions, and one register to rule them all.
Atleast, for now...

Developer Intent

Where CHIP-8 encourages visual creativity and the Game Boy invites full-blown hardware mastery, Tiny-4 is a sandbox for bytecode exploration. It's designed to be as dumb as possible, on purpose. It doesn’t try to be useful — it tries to be understandable. Every instruction is visible, every byte matters, and there's no magic under the hood.

In short: Tiny-4 is what you’d get if a Game Boy and CHIP-8 had a baby… and then left it in a single byte-wide crib with no supervision.

Updates

v0.2 - "THE BIG JMP" (May 2025)

Release v0.2 of Tiny-4!
Added more instructions: JMP, JZ, JNZ, CALL, RET, OUT
Housekeeping, clean up and adjust code
Removed evil entity haunting peoples computers

Download from Github!

Codename: THE BIG JMP - i consider it a big $08 to working on v0.3 :DDD

v0.1 – "ADD $03" (May 2025)

Initial release of Tiny-4!
Added base instruction set: LOAD, STORE, ADD, HALT, NOP
Custom binary format (.t4c)
Compiler and disassembler included
Hex RAM viewer

Download from Github!

Codename: ADD $03 - because i did not implement any other opcodes :DDD