Hi all,
I want to share a language experiment, and the one question it keeps
raising: what if ownership were a runtime diagnostic instead of a
compile-time gate?
The context in one sentence: HolyRust lives inside a tiny TempleOS-inspired
kernel (repo below) that boots in ~2 seconds and drops you straight into a
REPL. But this post is about the language, not the OS.
The language
-
Everything is JIT-compiled. A line at the prompt becomes native code the
moment you press Enter. There is no separate compiler binary, no build
step, no AOT pass — the compiler, the shell and the build system are the
same process. That's the TempleOS idea, transplanted onto Rust-flavored
syntax. -
Ownership as runtime diagnostics — the flagship experiment. In Rust,
borrowck stops you before the program exists. In HolyRust, the check runs
when the line executes: a violation prints an explanation, and the system
keeps running. On a REPL-first system this feels natural — you find out
the instant you press Enter, with the offending values right in front of
you. To be crystal clear about the tradeoff: it is a diagnostic, not a
guarantee. Guest code can still reach for raw pointers (Str *p) and take
the kernel down. -
Self-hosting end-to-end. The system's own source is .HR files that the
kernel compiles at boot; the running system can open, edit, and re-include
them. The language's first real user is the OS itself. -
Zero crates, no LLVM. Parser, codegen and diagnostics are plain Rust — no
syn, no inkwell, no external toolchain. This wasn't a stunt: the same
compiler must also build for a no_std kernel target, so the host compiler
and the in-kernel compiler are one body of code.
Where it's proven
- 110 host tests on the compiler and the language
- CI boots the real kernel in QEMU and asserts on screendump pixels
- ~250 lines of guest code fly a wireframe flight sim over pyramids —
floats, drawing and input, all through the language
The question for this community
Treating ownership as a runtime reporter rather than a compile-time gate:
from a language-design view, is that an interesting tradeoff for REPL-first
systems, or heresy? Both answers welcome — and if you see a hole in the
idea bigger than Str *p, I'd genuinely like to hear it before v0.2.
Repo: GitHub - salehdev-ux/holyrust: os using holyrust · GitHub
Honest limitations: HolyRust is a dialect inspired by Rust, not Rust; the
JIT uses RWX memory (a TempleOS-style choice); QEMU only, no real hardware
tested.
1 post - 1 participant
