Go to file
august kline c0e7f4024c fuzzy's compiler is written in assembly now :) 2024-10-07 01:44:20 -04:00
.gitignore Initial commit 2024-09-03 17:57:28 -04:00
README.md fuzzy's compiler is written in assembly now :) 2024-10-07 01:44:20 -04:00
fuzzy.asm fuzzy's compiler is written in assembly now :) 2024-10-07 01:44:20 -04:00
fuzzy.jpeg Initial commit 2024-09-03 17:57:28 -04:00
george fuzzy's compiler is written in assembly now :) 2024-10-07 01:44:20 -04:00
macro.inc fuzzy compiler v0 rev 0, written in assembly,rrunning on george :) 2024-10-06 22:06:10 -04:00
program.inc fuzzy's compiler is written in assembly now :) 2024-10-07 01:44:20 -04:00
routines.asm Initial commit 2024-09-03 17:57:28 -04:00
run.sh fuzzy's compiler is written in assembly now :) 2024-10-07 01:44:20 -04:00
semantics.md fuzzy spec :) 2024-10-06 21:56:37 -04:00
subroutines.inc fuzzy's compiler is written in assembly now :) 2024-10-07 01:44:20 -04:00
syntax.md fuzzy spec :) 2024-10-06 21:56:37 -04:00

README.md

fuzzy

a concatenative stack based programming language for george <3

design principles

lightweight

fuzzy runs on a 65(c)02 and nothing else

antiportable

fuzzy is part of george, and shouldn't run anywhere else.

low-level

(most of) fuzzy could be written as assembler macros, but that's no fun

reliable

if fuzzy says it can run, george can run it

how to work on fuzzy

edit program.asm and run ./run.sh. the program gets included in the fuzzy compiler fuzzy.asm and is assembled with vasm6502_oldstyle, then george runs the program, reading out her system image when she reaches stp or brk

then the program she compiled gets formatted as a standard 32k rom, and she reads it again, and then shows her system image again when the program finishes (hits stp or brk).

since fuzzy works on a zero-page data stack, it's pretty easy to read the results of a program from the hexdump.

for now this loop only works on apple silicon, but eventually i'll compile a george binary for x86 linux and switch based on the host platform.

reference help

i wrote syntax and semantics docs to keep track of how fuzzy works before starting work on the compiler implementation in assembly. they're the official source of truth for how fuzzy works. assume that the compiler implementation is always in flux :)

a note on implementation

i was writing fuzzy's compiler in rust for a sec, but then i realized that it would be a fun challenge to write it in assembly. it's been wayyy easier! and fun! and so rewarding :) this feels like a flex but i'm genuinely just so happy to see george & fuzzy playing together in this little computer world i've made <3