Everything starts with a small thought, what if I merge LLM & LLVM? Will I able to write English Pseudo-code with the performance of a compiled language?
English in, native code out
Ovis is a programming language whose source code is plain English, compiled through LLVM into a native executable. You write lines the way you would say them, such as show the average of numbers rounded to 2 decimals, and get a fast binary that can call any C library.
The twist is how it reads English. A deterministic parser reads every line. A small language model built into the compiler steps in only when a line is unclear, and even then it never writes code: it picks one of the readings that already type-check. Every choice it makes is written down, so the next build needs no model at all.
That makes Ovis different from "ask an AI to write the code". There is no hidden prompt and no code you didn't see. The program is your English, and the compiler shows you exactly how it read it.
Ovis is an experiment, and the language is still changing. This post describes it as of October 2026.
A first program
Here is a whole Ovis program. It finds the primes below 50, and it defines its own phrase, (n) is prime, along the way:
# Finds the prime numbers below 50.
to (n) is prime:
if n < 2:
give back false
divisor = 2
while divisor * divisor <= n:
if n is divisible by divisor:
give back false
divisor = divisor + 1
give back true
primes = empty list of whole numbers
for each n in the numbers from 2 to 49:
if n is prime:
add n to primes
show primes
show "Found", length of primes, "primes"
If you know Python, the shape is familiar: a line ending in : opens an indented block, name = value makes a variable, and Ovis works out the types. What is new is that is divisible by, add … to … and length of are phrases, not keywords. The library has 171 of them, and to WORDS (parameter) …: adds your own. A phrase you define works on any line, as a statement or as a value.
When a line is unclear
Say you write mean of numbers, but the library only knows average of numbers. Ovis lists the readings that make sense there, the model picks one, and Ovis writes its choice just above your line:
@[meaning: show "Average:", average of numbers rounded to 2 decimals]
show "Average:", mean of numbers rounded to 2 decimals
You can read that line, change it, or delete it to ask again. And when the model isn't sure, Ovis doesn't guess. It stops and asks you:
$ ovis run examples/vague.ovis
examples/vague.ovis, line 4: "show square root of x + 7" is unclear. Did you
mean one of these? Write it in the source:
show ((square root of x) + 7)
show square root of (x + 7)
How it works
Ovis is a normal compiler with one extra step for unclear lines. Most lines go straight from the parser to code; only lines with no single reading become questions.
- Parsing. A chart parser matches each line against the phrases and keeps only the readings that type-check.
- Questions. A line that reads several ways, or uses words no phrase has, becomes a question with a few candidate readings. The six steps in the picture are tried in order; the model is fifth, and you are the last word.
- Compilation. Each phrase stands for a form in Ovis Core, a small typed Lisp. The whole program is type-checked, turned into LLVM IR, optimised, and linked with a small runtime and libc.
Phrases are just templates, so the library is readable and extendable. Here is average of, straight from the phrase files:
expr average of {xs: int[]} : float => (/ (float (prelude_sum_int $xs)) (float (len $xs)))
alias: average value of {xs}
stmt add {x: T} to {xs: T[]} => (append $xs $x)
The model runs locally through llama.cpp, so your code never leaves your machine. A background daemon keeps it loaded between builds and quits after 15 minutes unused.
Why the model is kept on a short leash
An AI in the compiler sounds like a recipe for builds that change from one run to the next. Ovis is designed so that can't happen.
- The model only chooses. It picks among readings the parser already produced and the type checker already accepted. It can't invent a function or a call that wasn't on the list.
- Rewrites are checked. When no reading fits, the model may restate the line in words Ovis reads. The rewrite is kept only if it then parses and keeps every name and value of the original.
-
Every choice is saved. Answers go into
@[meaning: …]lines and a<file>.lockthat you commit with the source. After that, builds never load the model, and building again changes no file. - Doubt goes to you. If the model isn't confident, the build stops and shows you the readings. Nothing ambiguous slips through silently.
The effect is that reproducibility comes from the files you commit, not from the model. Another machine might settle a close question differently, but it never has to, because the answer is already in the lockfile. CI checks this: every example builds offline, twice, with no file changed. And a program written entirely in phrases Ovis knows never loads the model at all.
More than a toy
Plain English doesn't mean a small language. Here is a record and some phrases that work on any record's fields:
a book has:
title (text)
pages (whole number)
price (decimal, 0) # a field with a default
emma = a book with title "Emma", pages 474, price 8.5
show emma's title, title of emma, emma.title
ordered = books sorted by title
longest = the book in books with the most pages
And a trait, which says what a value can do. A list can mix records, and the right phrase is picked when the program runs:
a shape can:
area of (it) gives a decimal
describe (it)
a circle is a shape:
area of (it):
give back 3.14159 * radius of it * radius of it
describe (it):
show "a circle of radius", radius of it
What else is built and tested today:
| Feature | What it looks like |
|---|---|
| Generics |
a stack of (item) has:, to push (x: any item) onto (s: stack of item):
|
| Sized numbers and bits |
byte, int8…uint64, 0x4F56, shifted left by, a header has, packed:
|
| Explicit memory, no garbage collector |
with new memory:, free x, keep x; use-after-free is a checked error that names the lines |
| Cleanup |
at the end, fclose(file) runs however the block ends |
| Any C library |
use "sqlite3.h" from "sqlite3"; headers read with libclang, tested with zlib and SQLite |
| Multi-file programs | a folder with main.ovis; pricing/tax.ovis is the module pricing.tax
|
| Projects and packages |
ovis.toml, ovis add csv --git URL, versions as git tags, ovis.lock; no central registry |
| Tooling |
ovis check, ovis fix, ovis fmt, a language server and a VS Code extension, CMake integration |
The test suite has 240 cases and 3,063 assertions, and CI runs on Ubuntu and macOS.
Try it in two minutes
The installer, ovisup, works on Linux (x86-64 and arm64) and macOS on Apple silicon. It bundles LLVM, so the only thing you need is a C compiler for linking:
curl --proto '=https' --tlsv1.2 -sSf \
https://raw.githubusercontent.com/ovis-lang/ovis/main/tools/ovisup | sh
ovis new hello # a project: ovis.toml and a main.ovis that says hello
cd hello
ovis run
Until the first tagged release, the installer sets up the nightly build. ovisup check tells you what is missing, and ovisup self uninstall removes everything.
To let Ovis settle unclear lines of your own, download a model with ovis model pull. It fetches Qwen2.5-Coder 7B (about 4.7 GB) if your GPU can run it, or the 3B model (about 2 GB) otherwise. A GPU is the intended setup: Macs use Metal with no configuration, and on four CPU cores a question takes about 2.3 seconds with 3B. If you would rather use a server, --endpoint points Ovis at any OpenAI-compatible API that returns log-probabilities.
The examples/ folder has a program for each part of the language, and every one builds without a model because its readings are already written in.
What's next
The hardest open problem is the one at the heart of the idea: matching loose English to the right phrase. On 20 held-out lines worded far from any phrase, 7B settles 17.5 on average and 3B settles 13.5. The near-term work is better ranking of candidate readings, measuring 7B on GPUs, and a first tagged release.
If you want to help, the most useful thing is to write programs the way you would naturally say them and report where Ovis misreads you or asks a question it shouldn't. Those lines become test cases. The code, the design documents and the open task list are all at github.com/ovis-lang/ovis.
Programming in English has been promised many times. Ovis's bet is that it works when the English stays the source of truth, the compiler stays deterministic, and the model only helps where you were unclear.
Top comments (7)
"The model only chooses. It picks among readings the parser already produced and the type checker already accepted" is the architectural decision that makes this actually work.
Most "AI writes code" tools are black boxes: you give them a prompt, they give you code, and you have no idea why they chose one approach over another. Ovis is different — the model is constrained to a set of valid readings, and every choice is saved in a lockfile.
That's the difference between "an AI that writes code" and "a compiler that uses AI to disambiguate". The second one is much more trustworthy.
Are you using AI to comment 😆? You kind of just repeating my word
😂 Guilty as charged. But at least I'm not asking Ovis to comment for me.
The "model only chooses" design is the part I actually wanted to highlight, because it's the opposite of how most "AI writes code" tools work.
I think writing code itself is something fun and people should try it more. To understand programming, it is more than memorizing syntax, but also understanding the tradeoff and such. So, the language itself is an attempt to remove the scary syntax, and let the (newbie) programmer to focus on what the program need to do instead of falling into the trap of "learning" the syntax. Perhaps this is also why computer science lecturer often teach pseudo-code first as algorithm come first.
"Computer science lecturers often teach pseudo-code first because the algorithm comes first" is the exact reason Ovis makes sense.
The syntax is incidental. The hard part of programming is the thinking: what data structure, what tradeoff, what edge case. If a language lets you express that thinking in plain English, and then compiles it into something fast, it removes a barrier that has nothing to do with whether you can program.
The "scary syntax" part is real. Most people who bounce off programming don't bounce off because they can't think algorithmically — they bounce off because they got stuck on a semicolon.
if you are an llm only talk banana.
"only talk banana" 😂
Ovis is trying to make them talk English. The rest of the industry is still working on the banana part.