Huemann is a programming language where the whole program is a picture — pixels read in reading order, colours for instructions, more colours for numbers. Click Upload (or the image) to load a program image — colour or black-and-white, auto-detected — then Run for the result, Step through it, or Play to watch it execute. The full reference — where the name comes from, every instruction, the map, and how to build functions with GOTO — is at the bottom of the page.
Huemann = hue + von Neumann. Von Neumann for the architecture: in a von Neumann machine the program and its data live together in one memory — and here that memory is literally the pixels of a single image, instructions and numbers side by side. Hue because every instruction and every number is just a colour. So: a stored-program computer made of hues.
Pixels are read in plain reading order — left to right, top to bottom — and turned into a flat list of instructions. There are 16 colours: a coloured pixel is an instruction (9 of them, HALT being black), and the other 7 colours are base-7 digits that spell out the numbers each instruction needs (digit 0 is white). Black HALT also fills any leftover pixels at the end. Switch the image to Binary to see each colour as its 4-bit code drawn as a 2×2 black/white block.
Operands: k, a, b are register keys (which slot of the map); v is a literal value.
| READ k | read the next input character's code into map(k); gives -1 when the input is exhausted. |
| OUT k | print the character whose code is map(k). |
| SET k v | put the literal number v into map(k). |
| ADD k a b | map(k) = map(a) + map(b). |
| SUB k a b | map(k) = map(a) - map(b). |
| LOOP k … END | while map(k) ≠ 0, run the block between them. At END it jumps back to LOOP, which re-checks; when the slot is 0 it skips past END. This is the only branch. |
| GOTO n | call: jump to instruction number n and remember where you came from on a hidden return stack. |
| GOTO | (no number) return: pop that stack and jump back. |
| HALT | stop the program. (It's black, and also the padding colour.) |
That's the whole language. Everything else — less-than, multiply, modulo, if/else — you build out of these. For example a comparison is a loop that counts two numbers down together; a multiply is repeated addition.
There are no named variables — just one integer→integer map. You pick the numbers you use as keys (0, 20, …) and each holds one integer. The boxes under “Registers” show it live as the program runs.
A function is just a block of instructions you jump into and return from. The convention: agree on some map slots for arguments and the result, GOTO the function's first instruction to call it, and end the function with a bare GOTO to return. Because the return stack is real and hidden, calls can nest and even recurse.
; --- caller ---
SET 20 = 17 ; argument a
SET 21 = 5 ; argument b
GOTO 42 ; call the function that starts at instruction 42
; (execution comes back right here afterwards)
; result is now in map(22)
OUT 22
HALT
; --- function at instruction 42: map(22) = map(20) + map(21) ---
ADD 22 20 21
GOTO ; bare GOTO = return to wherever we were called fromNothing about the function lives in the map — only your arguments and result do. Call it from ten different places and each GOTO remembers its own return point.
Click Upload (or the image) to load a Huemann image — colour or black-and-white, it auto-detects. Then Run, Step, or Play (~30 fps). Download saves whichever view you're in; Copy link gives you a URL with the whole program and input baked in, so you can share it. A random or malformed image is rejected as “not a valid Huemann image”.