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?
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.
Here is a whole Ovis program. It finds the primes below 50, and it defines its own phrase, (n) is prime, along the way:
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.
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)
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.
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.
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.
@[meaning: …] lines and a <file>.lock that you commit with the source. After that, builds never load the model, and building again changes no file.
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.
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 modulepricing.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.
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.
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.