Vision

A Human-readable Systems Language that compiles to C.

Systems programming is hard. The notation is harder than it needs to be. Vision keeps the work and lets the notation fall away — code reads like prose, and you can follow what it’s doing without a glossary.

What it feels like to write

The grammar fits on a few pages, and most of it is plain English: when x is 5, each item in items, answer the result. You describe what should happen, and the language handles the rest. If you can read English, you can read Vision — and once you can read it, you can write it.

What it gives you

• Code you can read. A program in Vision reads like prose. If you can read English, you can read Vision.
• Code you can trust. The compiler stays out of your way until it has something real to say — and when something can go wrong, the language says so on the page, not behind your back.
• Code that runs at the speed of C. Vision compiles to C, then to native binaries. Legible and fast, with no tradeoff.
• Memory that takes care of itself. No manual allocation, no garbage collector, no runtime pauses.
• Every C library, reachable. Declare a library’s face in plain Vision and the compiler handles the rest.

How the language actually behaves

A few of the things that make Vision feel different in practice:

• Decisions read like decisions. You write when x is 5: instead of an if test wrapped in punctuation. Comparisons are words — is greater than, is at least, starts with. The control flow is what you’d say out loud.
• Effects are marked, not hidden. Every line that reaches outside the program — disk, network, the clock, randomness, the environment — carries a visible marker. An unmarked line is, by guarantee, pure. You always know what your program touches.
• Failures have a place to go. When an operation can fail, the line that does it asks how you’d like to handle it. The compiler won’t let that question go unanswered.
• Ambiguous math won’t compile. Mixed operations — adding without grouping — are a compile error, not a silent precedence trap. The line says what it means.
• Concurrency without ceremony. Independent operations can run side by side in a plain block. A slow network call doesn’t block the others, and a failed call is simply absent — no callbacks, no async/await, no runtime scheduler to learn.
• C interop without C vocabulary. You declare a C library’s Vision face — what it takes, what it gives back, when it fails — in pure Vision. The compiler infers the mapping and asks if anything is ambiguous. No pointers, no lengths, no out-parameters.
• Memory on the page, when it matters. Memory is automatic in the common case — most verbs have nothing to audit. When a lifetime genuinely can’t be proven, it surfaces in a dedicated memory: block, in words, so the reader sees what’s happening instead of guessing.

Who it’s for

People who want C-level reach and find dense notation harder than it should be. Anyone who’d rather read their own code than decode it.