jozone

Welcome to my personal website! I may publish stuff here at some point. Who knows what.

If you want to contact me, hit me up at jo@jo.zone.

Projects

• Jolle - Jojo's Luminous Language for Extensions

  2025 - Ongoing

  Etymology: Acronym (or backronym?) inspired by Guile.

  The language to be used for scripting in Neuma. A very dynamic, interpreted language. Scheme-like with algebraic effects. Inspired by Guile and Lua, although I haven't actually used either of them very much. More by their concepts and vibes than any concrete details.

• The Neuma Thought Cabinet - notetaking system / personal knowledge base

  2025 - Ongoing

  Etymology: Pun. "Neume" is basically the precursor of "note" in modern western musical notation.

  I typically use Org-mode for note taking today. It's fine for plain text notes, but it doesn't have the kind of functionality and/or interface I want for a personal knowledge base. I want an application that's a bit more like Obsidian, but not exactly like that. And unlike Obsidian, it has to be fully hackable. Open source. I'll just have to do it myself.

  I haven't gotten very far at all, but the current prototype is a Rust+Dioxus GUI. I forsee lots of fun problems to solve during this project, e.g. storage and synchronization. And a built-in scripting language, for making "live notes" and other cool stuff like that. In fact, I've already begun yak shaving on this.

• FCC, the Featherweight Compiler Collection
  • Lift, a low-level language (early WIP as of 2025-08-23)
  • Drift, a mid-level language (todo)
  • Crest, a high-level language (todo)

  2025 - Ongoing

  Etymology: Birds and Flight.

  I'm a big fan of RISC-V, and I sometimes dream building my own artisinally hand-crafted computing environment from the ground up. Firmware, OS, protocols, services, applications. Everything written by me. Everything written in my own programming languages. Everything written to be introspectable and hackable. My own retro-futuristic Lisp-machine cyberdeck. To enable all of this, I'm building a collection of featherweight compilers, where bootstrappability is at the top of the list.

  Lift will be the first compiler in the collection. At once both a low-level programming language with a compiler written in C, and at the same time compiler backend library intended for reuse in the second stage.

  Drift, then, will be sort of as mrustc is to rustc. A simple, statically typed, functional programming language with Lisp-syntax, using Lift for code generation. This stage will primarily be used as the implementation language for the third stage and star of the collection.

  Crest will be the final stage. A high-level, functional programming language with Lisp-syntax. The details haven't been hammered down yet, but I think I want it to have all that Carth had and more. Immutability-first, functional programming, algebraic effects, algebraic data types, garbage collection, live coding / hot reload / introspection, and more.

• The Kapreolo Programming Language

  2023 - 2025

  Etymology: Esperanto for "roe deer". Wanted something animal-themed, like Hare and Carp.

  Kapreolo wasn't really a new project as much as it was just a rebranding and refocusing of Effem. Algebraic effects are out (or, you know, slightly down-prioritized) and interactivity / on-demand compilation is in! I was really inspired by some recent talk I'd seen on interactive programming, and my head was full of live programming environments. Lisp machines, Emacs, game engines, jupyter notebooks, Smalltalk. All that jazz!

  This time I tried out the Cranelift compiler backend. Worked well enough, but I wanted even more simplicity. I'm a big fan of QBE's motto / sales pitch: "a compiler backend that aims to provide 70% of the performance of industrial optimizing compilers in 10% of the code". Yeah, that's the stuff! But I for some reason, I just thought that QBE (and other similar projects like MIR (no, not the Rust one)) looked like they wouldn't be easy to integrate into my compiler in exactly the way I wanted to. So I decided I'd write my own. That decision had some consequences on how I felt I should structure my project - time for another pivot!

• The Effem programming language

  2023

  Etymology: Algebraic effects + FM radio. Don't remember what the latter was about...

  As a brief intermission, there was Effem. It was yet-another-reboot of my compiler project inheriting from Carth and Kvasir before that. Basically, I didn't vibe with the name Carth anymore, and also I wanted to go back to back to writing in Rust, mostly for the performance and package ecosystem.

  This incarnation of the project didn't last long. I quickly realized that while algebraic effects were interesting, I didn't want to make them the sole focus of the language.

• The Carth programming language

  2018 - 2022

  Etymology: Reference to John McCarthy, author of the original Lisp.

  Carth was really just a rewrite of Kvasir in another language. Haskell temporarily snatched the spot of Jojo's Favorite Programming Language For Daily Use for a few years, so naturally that's what I picked for the implementation language this time around. I was hopeful - I was learning a lot from my courses at Chalmers, and I took a bunch of lessons with me from Kvasir. This time around, it will work. I'll complete my dream language.

  Of course, that didn't end up happening. It was a great hobby project for a few years though. I learned a lot, and implemented some cool stuff like: a proper Damas-Hindley-Milder type checker that adhered closely to theory; efficient pattern matching with completeness and exhaustiveness checking; compatibility with the C calling convention (SysV ABI); JIT interpreter based on LLVM's OrcJIT; working GC based on the Boehm collector; slightly extensive standard library with functions for string manipulation, arrays, TCP comms, etc; tail call optimization;

  Carth actually ended up being more-or-less a real language. I did a year or two of Advent of Code in this language, and I even began implementing a client for the Gemeni internet protocol. Once again: pretty neat actually.

  But at the end of 2022, I pretty suddenly lost all steam. I'd been a working adult for about two years, and I did not like it. I hadn't gotten to work on a single interesting project, and every assignment I'd been on had been either boring or stressful or both. This might've had an impact on my will to work on Carth. Another cause is that my preference for Haskell was fading. Don't get me wrong - I still like Haskell - but I was growing to miss some aspects of Rust, like the performance.

• The Kvasir programming language

  2015 - 2018

  Etymology: The norse god of knowledge. A codename that I never bothered changing.

  While working on scheme-rs had been all good fun, I soon started feeling like it was a dead end. I no longer wanted to work on this language just as a learning exercise, but instead I'd begun to desire being able to use my own programming language for "serious" projects. Specifically, I believe I was thinking about game development. An interpreted language would of course not be fast or powerful enough for that, I presumed. I had to write a compiler.

  Taking a glance at the logs, it looks like I began Kvasir as a transpiler to Rust source. I had completely forgotten about that!

  Pretty soon into the project I started at Chalmers, studying computer science. Kvasir development kept ticking on, but there were frequent pauses as I prioritized other parts of life at uni. I got more into Free Software during this time of my life, switching the project's license over from MIT to GPLv3. With regards to PLT, I got more into both type theory as well as code generation. In late 2015, I got basic codegen to LLVM IR working. In 2017, I added a half-baked implementation of global type inference (Damas-Hindley-Milner). Near the project's eventual "death" in late 2018, I was working on garbage collection. Kvasir was basically a "real" language at this point. Pretty neat actually.

  The whole thing was built on top of somewhat shaky fundamentals, however. At this point in time, during the latter half of my time at Chalmers, I had gotten much into Haskell and theory. I realized that if I rewrote Kvasir now, I could do a much better job. In particular, I could rewrite the type checker to actually be understandable and maintainable, and not just spaghetti. So I did, and that was the end of Kvasir 🪦

• scheme-rs - A toy implementation of a Scheme-like language

  2014 - 2015

  I had been learning to program on-and-off for 4+ years at this point, but during the last year of high school (gymnasium), the ball really got rolling. Maybe a year or so before, I had graduated from doing tutorial projects in Python and had started coming up with ideas for small hobby projects on my own. A bunch of little semi-embedded projects, like using Python or Go or even basic C to blink some LEDs with a Raspberry Pi.

  Near the end of 2014, I found out about this shiny, new language that all the cool kids were talking about. Rust promised to be a faster version of Go, with lots of cool features I had barely even heard of. I decided that I wanted to be one of the cool kids, so off learning Rust I went.

  Also around this time, I'd been inspired by the memes on /g/ to pick up a copy of "the wizard book" i.e SICP. Before finishing the whole thing, my latent Yak Shaving abilities awoke! "I know, I'll write a Scheme interpreter in Rust, and then do all the SICP exercises using my own interpreter! That way, I will learn both Rust and functional programming at the same time, and I'll get tons of street-cred!

  ... but of course, I never actually finished the project. As is the curse of a Yak Shaver, one must always pursue each thread of distraction to start yet another side project. But it was a fun time! A productive distraction during boring high school classes. I got to experience Rust as it went from from pre-alpha to alpha to the full 1.0 release! And I believe I ended up learning a lot about Rust as well as programming languages in general during this time. I don't think I know what a closure was before starting this project, and by the end of it I was comfortable using them in Rust and had even implemented a version of them in my interpreter - presumably with a generous sprinkle of bugs 😸

• ... and many more (including non-PLT stuff like home automation & games)
  in various states of completion and documentation
  all on my sourcehut & github

Writings

• Ray Tracing for Sensor Simulation using Parallel Functional Programming — Master's thesis