The Surface of Intent
It has been two months since my last entry here. In April, I wrote about adopting a new operating principle: computes only what matters. I had assumed that between managing a startup, family, and creative projects, I would leave this journal dormant for a longer season.
But projects have a way of demanding their own completion. For the past few months—and honestly, the past few years—most of my invisible processing cycles have been occupied by an endeavor close to the metal. Today, I finally pushed it live.
Twenty years ago, as a kid, I dreamt of building my own programming language. I watched Ruby take off out of Japan and wanted to create something meaningful from Korea. I spent two decades tinkering in the dark. Topaz v1 started, strangely enough, as a Lisp dialect, which eventually spun off into a tiny separate language at lispex.com. v2 moved toward a more Python-like expressiveness and ease. Around that time, I fell in love with Rust and realized that "powerful" had to mean Rust-level safety and performance.
Then the AI era hit, and I faced a sudden existential crisis. If machines are writing the code, why would anyone bother learning a new language? What is the point of building Topaz?
The answer forced a complete re-engineering of the project, steering it directly into the philosophy of subtraction. In a world where software is a collaboration between humans and AI agents, a massive, shifting language surface is a liability. It creates friction, ambiguity, and hallucinated logic. Topaz v5.2 solves this by enforcing a small, completely fixed, and predictable language surface. It reads roughly like Python or TypeScript, runs on a reference interpreter (topaz run), and builds self-contained native binaries by lowering the code to Rust and handing it off to the Rust toolchain (topaz build).
This was not built in a vacuum. During the v3 and v4 cycles, Topaz became the internal workhorse for our team at Studio Haze. We used it to power the core application logic in our upcoming services—specifically, a deterministic code translation platform and Atlas, the Korean typesetting application I mentioned here back in April. It survived the practical friction of production before we ever thought about showing it to the world.
Architecturally, Topaz is designed to be an unyielding contract:
- Zero Dependencies & No Unsafe: The entire toolchain—lexer, parser, checker, interpreter, and emitter—is written in pure Rust with zero external
crates.iodependencies. The workspace strictly enforcesforbid(unsafe_code). - Differential Testing: To eliminate semantic drift, every single fixture runs through both the interpreter and the Rust-emitting compiler. The stdout and exit status have to agree. Right now, our testing harness runs 635 test functions cleanly.
- Literal Unicode Identity: Identifiers can be written in native Unicode scripts (Korean, Russian, English) classified directly from the UCD. We do no implicit normalization; names compare strictly by scalar sequence. To protect against environmental variance, the module resolver rejects path collisions caused by platform-specific case or normalization differences, keeping imports unambiguous across Linux, macOS, and Windows.
- Intent-Driven Templates: Strings for
sql,sh, andpathlower to typed template nodes that keep interpolations structurally separate from literal text. Because raw textual splicing into a query or command is simply not the default string operation, an entire class of injection bugs is prevented by construction rather than human discipline.
Even our CI gates reflect this rigidity. They run natively across Linux, macOS, and Windows because the platform-specific filesystem behaviors exercise our module resolution in ways Linux alone cannot. Every commit must pass clippy warnings, formatting checks, our 635-test suite, and standalone build smokes before it ever touches the main branch.
I did use substantial AI assistance during the private incubation phase, especially for rapid implementation and rigorous review. I see no reason to hide that; it was the ultimate test of the language's core design. But I am not publishing private prompts or orchestration logs. The public contract is the boring, inspectable part: the source code, the locked spec, the fixtures, and the cross-checks.
The toolchain is live today at topaz.ooo. It is early, and there is no ecosystem to speak of yet. It is not "easy Rust"—it is a small application-language surface that compiles through Rust.
Building a language taught me that true power does not come from trying to do everything. It comes from fixing the surface, securing the boundaries, and letting the core execute flawlessly. It is, after all, the only code worth running.