RHYMES WITH FOG  ·  IN DESIGN |> COMING SOON

The language built for AI agents to write.

So the code they ship is code you can trust.

statically typed · immutable by default · no metaprogramming

follow the build on bluesky |>

|> 01   THE COST OF A BUG

Not every failure costs the same.

Three kinds of wrong, in ascending order of what they take from you. The gap between the second and the third is the whole game.

PAY ONCE

Correct code

You pay when it's written, and never again. The baseline.

BOUNDED

Loud failure

It breaks on the spot. You learn it's wrong at once, right where it happened, and you pay there. Annoying, but cheap.

UNBOUNDED

Silent failure

It ships looking correct and bills you later — in production, detached from the cause, compounding the entire way there. The most expensive line of code is the one that looks fine.

AI floods you with the silent rung specifically — plausible-looking wrong code, faster than review catches it. Vog's whole move is to convert silent failures into loud ones.

|> 02   IMPOSSIBLE BY DESIGN

Whole categories of bug that can't happen.

Not lint rules. Not discipline. The language gives you no way to write them.

see all of them →

CAN'T HAPPEN

No null.

A type holds a value or it doesn't — there is no third state to forget. Reaching into an absent value is a compile error, not a 2 a.m. page.

CAN'T HAPPEN

Unhandled errors
will not compile.

every result is Ok/Ng · every case is exhaustive

→ →

CAN'T HAPPEN

Red, green, red.

A test with no assertion passes forever, proving nothing. So Vog breaks your code on purpose and fails any test that doesn't go red — no toothless green.

Injection, de-risked by construction.

dangerous sinks take structured input, not strings

Money never silently rounds.

Decimal by default, arbitrary-precision Int — the rounding error has nowhere to originate.

No NaN. No Infinity.

Float is finite-only. Nothing non-finite to mint or propagate.

No macros. No reflection.

what you read is what executes

No silent overflow, no divide-by-zero.

Int is bignum · division returns Ok/Ng

No truthiness.

Conditions take a Bool and nothing else — no accidental zero, empty string, or null slipping through as “false.”

Statically typed, of course.

|> 03   A GLIMPSE

Real syntax. A taste, on purpose.

Vog code moves through one result shape: Ok or Ng (“no good,” say “nog”) — a typed failure value, never a hidden exception. The full glimpse keeps it brief: enough syntax to show the posture, not a tutorial.

the full glimpse →

profile.vog

display_name(id: UserId) -> Ok(String) | Ng(:missing | :private)
    case find_user(id) {
        Ok(user) -> public_name(user)
        Ng(:missing) as err -> err
        Ng(:private) as err -> err
    }
end

public_name(user: User) -> Ok(String) | Ng(:private)
    case user.public_name {
        Ok(name) -> Ok(name)
        Ng      -> Ng(:private)
    }
end

One visible result shape

Ok keeps going. Ng names the ways this can fail, and every case must say what happens.

clamp_low.vog

pure clamp_low(x: Int, floor: Int) -> Ok(Int)
    Ok(max(x, floor))
end
testrows clamp_low "floor is enforced"
    pass below_floor: 1, floor: 7 -> Ok(7)
    pass above_floor: 9, floor: 7 -> Ok(9)
end

Red, green, red

A test with no assertion fails; vog invert flips the logic and checks green goes red.

a sneak peek, limited on purpose · no runnable playground yet

|> 04   THE ARGUMENT IS THE PROOF

No product to click into. So the rigor stands in for it.

We catalogued twenty-eight ways a language's design lets you fail, banded every one honestly — unrepresentable, caught at compile time, or merely minimized — and benchmarked Vog against fourteen languages without trying to make it win. Read the footgun catalog and judge for yourself.

The repo isn't open yet. The work is out in the open.

Vog is still in design — the repository isn't open yet, but it will be under appropriate open source licenses. No mailing list, no launch date; just the thinking, shared in the open until the code and compiler are ready to share.

LANGUAGE SPEC 85%

COMPILER 60%

follow the build on bluesky |>