The Surface I Present
It's been barely a week since my last entry. I wrote about pushing the source repository for Topaz live, marking the end of a twenty-year journey in the dark. It felt like a clean conclusion, the ultimate act of sharing a minimalist, opinionated application surface with the world.
But seven days later, the source repository is private again.
If that looks like severe whiplash from the outside, I understand. To watch a developer open a two-decade-old passion project and then abruptly pull the codebase back within a week suggests a sudden crisis or a failure of nerve. But this is neither an apology nor a retreat. It is simply the next logical move in the same game of subtraction. If last week was about subtracting from the language surface itself, this week is about subtracting the surface I present to the world.
When you make a programming language's source code repository public, you aren't just sharing a tool. You are implicitly signing an open-ended contract. A public codebase is an invitation that says, Audit this, trust this, use this to build your things. And with that invitation comes an unwritten ledger of debts, from code reviews and ecosystem maintenance to backward compatibility and the endless triage of GitHub issues.
I am one person. I run STUDIO HAZE, balance a startup, care for my family, and navigate a handful of other creative projects. Long before I thought about showing Topaz to anyone, it had already survived the ordinary friction of production, quietly anchoring the core application logic for our deterministic code translation platform and Atlas, our Korean typesetting app. It worked beautifully for us. But looking at that public repository, I realized I had inadvertently signed my name to a lifetime of open-source codebase maintenance in exchange for a few passing stars. I have neither the desire nor the capacity to manage a public ecosystem for a compiler.
So what, exactly, did I close? Only the source. The Rust implementation of the compiler, the repository I had opened a week earlier, is private again. Everything you need to actually use Topaz stays completely in the open at topaz.ooo, from the grammar you read and write to a WebAssembly playground that runs it in the browser and the binaries you can download. You can still learn the language, and you can still build with it. What I withdrew wasn't the tool. It was the blueprint of how the tool is made.
There was also a deeper miscalculation in the kind of proof I was trying to offer. Opening the entire compiler source code proves reproducibility. It proves that the toolchain is indeed plain Rust with no external crates, and that forbid(unsafe_code) is strictly enforced across the workspace. It proves the internal mechanics are real.
But reproducibility is not the same thing as utility. Opening the kitchen to show the copper pots and the knife skills doesn't prove that the meal tastes good. I realized that the README of a language compiler is an inherently boastful surface. It asks you to believe in a spec. I don't want people to merely believe in a spec. I want them to see what the tool can actually produce. Output speaks with a clarity that source code never can.
So the strategy shifted from the recipe to the dish.
Years ago, I ran a small mini-app platform called jeniapp on the domain jeni.kr. It was originally just a handful of simple apps stitched together in Streamlit. It aged badly, I archived it, and for a long time the domain pointed at nothing but an empty page. This week I pulled it out of retirement for a new purpose.
The single-purpose, self-contained WebAssembly mini-apps I build with Topaz will live there, with their application code completely open, and topaz.ooo will point the way. Anyone can build with the language. I'm simply going to go first, and show my work. I want to showcase programs where a Korean word stays a Korean word as a first-class identifier, and where typed templates make a whole class of injection bug something the grammar won't let you write.
It is a philosophy of an open surface and a closed core. The language's surface stays public and fixed. The playground and the binaries stay free to use. What stays private is the source beneath them, the parser, the checker, the Rust lowering, all the moving parts I no longer have to defend in the open. You can read the language, run the language, and read every program I make with it. You just don't get to walk through the engine room.
I spent twenty years tinkering with this language in the dark, held it out in the bright sunlight for a single week, and then drew the curtains half-shut again. Only this time, I am entirely at peace with which window stays open.
Building a language taught me that power isn't trying to do everything. It's deciding what the language's surface will never do, and holding that line. This week taught me that publishing a language follows the exact same rule. True control isn't about exposing everything to the world. It is about deciding what the surface I present will never show, and having the resolve to keep it hidden.