Repo description (the one-line tagline)

A programming language that reads like plain sentences. Compiles to C.

---

---

README.md

Vision

A small systems programming language that reads like plain sentences.

Vision is built on one idea: code should be legible. Not clever, not terse — legible. The kind of thing you can read a year later, or hand to someone who's never seen it, and still understand. It spells things out in words instead of symbols, marks the lines that do something dangerous, refuses to let a failure go unhandled, and compiles down to plain C. It's new, it's mine, and it's built in the open.

Here's a whole program:

to begin:
    say "hello"

to begin: is the entry point. say writes a line. Indentation makes the block — no braces, no semicolons, no ceremony. That's real Vision; it compiles and runs.

What it looks like

A verb that takes inputs and gives something back:

to greet, given a name:
    answer "hello, {name} — good to see you"

Text is built by writing it out, with values dropped into the holes. Numbers go in the same way, no conversion:

to describe a basket, given the count:
    answer "you have {the count} items, {the count} too many"

A loop over a list, doing real work:

to total the prices, given the prices:
    the running total is 0
    for each price in the prices:
        the running total is the running total plus the price
    answer the running total

Danger is visible

Vision marks every line that reaches outside your program, and every line that can't be undone — by law, checked by the compiler. An unmarked line is provably calm.

to save the note, given the words and the path:
    the temp path is "{the path}.tmp"
    >> write the words to the file at the temp path
    >> make sure the file at the temp path is saved
    >> rename the file at the temp path to the path

>> means the line touches the world — disk, network, the clock. !! means it can't be undone. You can see, at a glance, exactly which lines have weight. The safe lines and the dangerous ones never look the same.

Failure is never ignored

If something can fail, the compiler won't let you walk past it. You handle it, or it doesn't build:

read the file at the path giving the contents
    but if it isn't there, say "nothing to read there" and stop
    but if it can't be read, explain why and hand it on

No hidden surprises

Arithmetic and logic are never silently precedence-ordered. If two different operations meet, you group them, so the order is always on the page:

a plus b times c        // won't compile — group it
a plus (b times c)      // the order is visible, and meant

A wrong order silently corrupting a value is the kind of bug Vision refuses to allow.

Reaching C libraries

C has forty years of good libraries. Vision reaches them by describing what a function does — in Vision, never in C. No pointers, no length parameters. For libraries that hold state across calls, the description reads as three plain steps:

this program understands blake3

to begin a blake3 hash giving a hasher is blake3_hasher_init
    it gives back a hasher
to feed some bytes to a hasher is blake3_hasher_update
    it takes a hasher and some bytes, changing the hasher
to finish a hasher giving some bytes is blake3_hasher_finalize
    it takes a hasher
    it gives back 32 bytes

to fingerprint, given the contents:
    begin a blake3 hash giving the hasher
    feed the contents to the hasher
    finish the hasher giving the result
    answer the result

begin, feed, finish — make the thing, feed it, finish it. The C struct is managed for you; you never see a pointer.

The shape of it

• Reads like sentences: words, not symbols. Indentation makes blocks.
• Compiles to C. Memory is automatic by default — and can be managed by hand when you

need the control.

• Effects are visible (>>), the irreversible is marked (!!).
• Every failure is handled, or it doesn't compile.
• No hidden precedence — order is always written down.
• C libraries reached by plain description, no C written.

Source files end in .vis.

What it leaves out, on purpose

The absences are deliberate — each one is a choice, not a gap:

• No garbage collector. Memory is deterministic: automatic by default, manual when you

need the control. Nothing pauses your program to clean up behind you.

• No hidden control flow. No exceptions unwinding invisibly up the stack. A failure is

handled where it happens, in plain sight, or the program doesn't compile.

• No hidden precedence. No operator-precedence rules to memorize — when operations

mix, the order is written down.

• No heavy runtime. It compiles to C. There's no VM or interpreter sitting underneath

your program at runtime.

• No symbols to decode. Words, not punctuation. Nothing you need to be initiated into.
• No telemetry, nothing phoning home. Owned end to end; the compiler does what it says

and nothing else.

Status

Vision is new and under active development. It works — there's a real compiler and a large test suite behind it — but it's early, the surface is still settling, and it's being built one careful decision at a time. If you're reading this, you're early.

Why it exists

The wall between "people who write code" and "people who don't" was mostly a pile of symbols nobody ever explained. Vision is one attempt to take it down — to make a language that's legible by law, owned end to end, with zero telemetry and nothing hidden. It's part of a larger ecosystem (Koh, Kepr, and the rest) built on the same belief: software you can read, own, and trust.

Built by June · Asha Software. Read more at visionlang.dev.

License: GPL — use it, change it, build on it; if you share your version, keep it open too.