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.
