(↑)

Languages

I keep writing new programming languages. Not sure why.

◆

It was probably inevitable. After too many years of writing code in programming languages, I gave in to the voices in my head that kept asking "why do we have to do it like this? Isn't there something better?"

Zipper

Zipper is a text-replacement programming language: the way many people think interpreters work. It runs each part of the program, and replaces that part with the result. Eventually, the only thing left is the answer.

It is it's own debugger, as you can see and edit the program at every step.

Vibe coded.

Throff

Throff is my Meisterwerk. Before this, I felt like a tourist in the world of programming, now I feel like I have a good grasp of how programming languages work.

Throff is a dynamically typed, late binding, homoiconic, concatenative programming language. It was an attempt to take languages like Cat and Joy and update them for the modern world of programming, by building the entire system up from a small foundation of functions, and a tiny simple interpreter.

The implementation allows for things like perfect tail calls, allowing complex control structures to operate without needing to consider stack management.

Hand written

Linc

Linc (in ~/git/racketprogs/linc) is my attempt to make a useful systems level language using some very advanced concepts like linear typing and ADTs. In benchmarks, it lands somewhere around the Rust level, which is about right.

The final language is starting to look similar to C, but with more type declarations, and some very different (better) behaviour.

Linc is my attempt to find out whether a linear, concatenative language can be pleasant to write real software in. Surprisingly yes.

Slop level: Vibe coded

xsh

xsh (in ~/git/racketprogs/xsh) is a cross-platform shell and scripting language.

I want my shell to be a real programming language, and I want my programming language to be a real shell. xsh is that experiment.

Slop level: Hand and Vibe coded

Quon (and the Quonverter)

Quonverter (in ~/git/racketprogs/quonverter) is an attempt to make the "unviersal programming language", something that runs everywhere, on every machine. A language that can run on every platform, works with every compiler, and can adapt for new environments.

It turns out, this is possible, so long as you don't try to actually do anything useful with it.

The language is deliberately the lowest common denominator across those targets — functions, structs, conditionals, recursion. No closures, no coroutines, no Hindley-Milner.

There is absolutely no reason for this language to exist, and nothing useful to do with it. But I think it's probably the best thing I have ever written.

Slop level: Hand coded, then handed over to the AI for maintenance

Stalk

Stalk (in ~/git/racketprogs/stalk) is a small prototype-based language inspired by Smalltalk.

Slop level: Hand coded prototype, completed by AI.

ServiceTalk

ServiceTalk (in ~/git/racketprogs/agentic/servicetalk) is a distributed cluster where every object is its own OS process. It works as badly as you would expect, but it does actually work..

ServiceTalk is what happens if you take Smalltalk's "everything is an object, everything is a message send" seriously enough to make it true at the OS level.

Slop level: Entirely vibecoded

Atto

Atto (in ~/git/racketprogs/atto) is a minimal functional language in Go. It's a re-implementation of zesterer/atto.

I really admire the way it's possible to make a complete language in 500-1000 lines of host code.

Slop level: Hand coded

PerlTalk

PerlTalk (in ~/git/racketprogs/PerlTalk) is a failed Smalltalk-interpreter-in-Perl experiment, plus several side projects in parser construction (BNF / PEG / ANTLR / brag).

Slop level: Hand coded

Smaller language-shaped things

These aren't full languages but they have some interest.