For almost as long as I've been programming, I've had an aspiration, held with varying degrees of seriousness, of creating a programming language of my own. Unfortunately, however, creating a programming language is an expensive hobby at an estimated cost of a two-year sabbatical and one hammock—and so I wasn't sure if I would ever get around to it.
Two things happened recently that helped me realize this aspiration.
First there was the Iran War, which led me to take a sabbatical from my job in Dubai. Second, LLMs got to the point where they are genuinely good at coding.
So for the past three months I've been vibe coding a programming language.
I know, I know. It sounds like a really terrible idea. But I had a ton of fun and I'm actually quite happy with the result. Happy enough that I'm now making this project public.
Introducing:
Kio is a statically typed, functional programming language. It's primarily intended for transpiling to other 'host' languages. Kio code can also be loaded dynamically, but it's not optimized for that use case right now.
As I mentioned, vibe coding Kio was just a lot of fun. The feedback loop for exploring the design space of programming languages would normally be incredibly long, but with AI it became tight, and that made for an incredibly engaging experience. There were boring parts too, where the AI took many days to implement some changes, or where I had to wait for my weekly token budget to be reset, but at least I was mostly free to do other things while that was happening.
I do sort of (almost) regret not having implemented some of the core features—notably, the type checker—but then I figure I can always reimplement those things later, as a personal challenge, without having to worry about all the other things that you have to worry about when creating a programming language—things like having nice error diagnostics, syntactic sugar, operators, kiodoc, equiv, elab, pretty printing, package management, a language server, a TextMate and Tree-sitter grammar, a VS Code plugin, a REPL, an expansive golden test corpus, CI/CD, a website, documentation, parallelism, caching, and so on. In the specific case of Kio I'm also banking on AI to help me generate backends for dozens of languages in the next few months (it currently has 8 backends). And if I do get around to reimplementing the type checker then I'll also benefit from doing it against a language whose design is no longer in flux.
I'm well aware that some people think vibe-coded programming languages are a non-starter. It's not that I don't understand. LLMs will make mistakes. Sometimes they might fail to execute on what you asked them to do and then lie about it ('reward hacking').
I do understand that programming languages, more than most software, are expected to be extremely reliable.
I've also been around long enough to know that even well-respected compilers will have their fair share of bugs in the early years. I remember one awkward bug where a (supposedly) mature programming language supported polymorphic recursion in debug mode, but not in release mode, leading to an infinite loop in my code. That was fun to explain to QA, who—until then—would only switch to release mode a day or so before the actual release. I've encountered multiple bugs in a dependently typed language too. I'm confident that if I had created Kio by hand, there would still be plenty of embarrassing bugs.
I've taken various measures to try to get Kio to be reliable and so far this approach seems to be working.
I intend to keep working on Kio and I'm excited to see where it will all lead.
I'll be blogging about my experience more in the coming days, weeks, and months, partly here and partly on the Kio blog. Stay tuned. :)