{"slug": "meet-ovis-a-compiler-that-reads-plain-english", "title": "Meet Ovis: a compiler that reads plain English", "summary": "A developer has released Ovis, an experimental programming language whose source code is written in plain English and compiled through LLVM into native executables that can call any C library. A deterministic parser handles every line, with a small local language model invoked only when a line is ambiguous; the model never writes code, instead selecting among readings that already type-check, and each choice is recorded in `@[meaning: …]` annotations and a committed lockfile so subsequent builds run fully offline and reproducibly. The language ships with 171 built-in phrases and lets users define their own, and the model runs locally via llama.cpp so code never leaves the machine.", "body_md": "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?\n\n[Ovis](https://github.com/ovis-lang/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.\n\nThe 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.\n\nThat 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.\n\nOvis is an experiment, and the language is still changing. This post describes it as of October 2026.\n\nHere is a whole Ovis program. It finds the primes below 50, and it defines its own phrase, `(n) is prime`, along the way:\n\n```\n# Finds the prime numbers below 50.\nto (n) is prime:\n    if n < 2:\n        give back false\n    divisor = 2\n    while divisor * divisor <= n:\n        if n is divisible by divisor:\n            give back false\n        divisor = divisor + 1\n    give back true\n\nprimes = empty list of whole numbers\nfor each n in the numbers from 2 to 49:\n    if n is prime:\n        add n to primes\nshow primes\nshow \"Found\", length of primes, \"primes\"\n```\n\nIf 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.\n\nSay 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:\n\n```\n@[meaning: show \"Average:\", average of numbers rounded to 2 decimals]\nshow \"Average:\", mean of numbers rounded to 2 decimals\n```\n\nYou 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:\n\n``` bash\n$ ovis run examples/vague.ovis\nexamples/vague.ovis, line 4: \"show square root of x + 7\" is unclear. Did you\nmean one of these? Write it in the source:\n    show ((square root of x) + 7)\n    show square root of (x + 7)\n```\n\nOvis 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.\n\nPhrases are just templates, so the library is readable and extendable. Here is `average of`, straight from the phrase files:\n\n``` js\nexpr  average of {xs: int[]}   : float  => (/ (float (prelude_sum_int $xs)) (float (len $xs)))\n      alias: average value of {xs}\nstmt  add {x: T} to {xs: T[]}           => (append $xs $x)\n```\n\nThe 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.\n\nAn 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.\n\n`@[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.\nThe 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.\n\nPlain English doesn't mean a small language. Here is a record and some phrases that work on any record's fields:\n\n```\na book has:\n    title (text)\n    pages (whole number)\n    price (decimal, 0)          # a field with a default\n\nemma = a book with title \"Emma\", pages 474, price 8.5\nshow emma's title, title of emma, emma.title\nordered = books sorted by title\nlongest = the book in books with the most pages\n```\n\nAnd a trait, which says what a value can do. A list can mix records, and the right phrase is picked when the program runs:\n\n```\na shape can:\n    area of (it) gives a decimal\n    describe (it)\n\na circle is a shape:\n    area of (it):\n        give back 3.14159 * radius of it * radius of it\n    describe (it):\n        show \"a circle of radius\", radius of it\n```\n\nWhat else is built and tested today:\n\n| Feature | What it looks like | \n|---|---|\n| Generics | `a stack of (item) has:` ,`to push (x: any item) onto (s: stack of item):` | \n| Sized numbers and bits | `byte` ,`int8` …`uint64` ,`0x4F56` ,`shifted left by` ,`a header has, packed:` | \n| Explicit memory, no garbage collector | `with new memory:` ,`free x` ,`keep x` ; use-after-free is a checked error that names the lines | \n| Cleanup | `at the end, fclose(file)` runs however the block ends | \n| Any C library | `use \"sqlite3.h\" from \"sqlite3\"` ; headers read with libclang, tested with zlib and SQLite | \n| Multi-file programs | a folder with `main.ovis` ;`pricing/tax.ovis` is the module`pricing.tax` | \n| Projects and packages | `ovis.toml` ,`ovis add csv --git URL` , versions as git tags,`ovis.lock` ; no central registry | \n| Tooling | `ovis check` ,`ovis fix` ,`ovis fmt` , a language server and a VS Code extension, CMake integration | \n\nThe test suite has 240 cases and 3,063 assertions, and CI runs on Ubuntu and macOS.\n\nThe 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:\n\n```\ncurl --proto '=https' --tlsv1.2 -sSf \\\n  https://raw.githubusercontent.com/ovis-lang/ovis/main/tools/ovisup | sh\n\novis new hello      # a project: ovis.toml and a main.ovis that says hello\ncd hello\novis run\n```\n\nUntil the first tagged release, the installer sets up the `nightly` build. `ovisup check` tells you what is missing, and `ovisup self uninstall` removes everything.\n\nTo 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.\n\nThe `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.\n\nThe 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.\n\nIf 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](https://github.com/ovis-lang/ovis).\n\nProgramming 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.", "url": "https://wpnews.pro/news/meet-ovis-a-compiler-that-reads-plain-english", "canonical_source": "https://dev.to/rechie_kho/meet-ovis-a-compiler-that-reads-plain-english-1oag", "published_at": "2026-10-22 14:10:26+00:00", "updated_at": "2026-10-22 14:14:24.923395+00:00", "lang": "en", "topics": ["large-language-models", "developer-tools", "ai-tools", "artificial-intelligence"], "entities": ["Ovis", "LLVM", "llama.cpp"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/meet-ovis-a-compiler-that-reads-plain-english", "markdown": "https://wpnews.pro/news/meet-ovis-a-compiler-that-reads-plain-english.md", "text": "https://wpnews.pro/news/meet-ovis-a-compiler-that-reads-plain-english.txt", "jsonld": "https://wpnews.pro/news/meet-ovis-a-compiler-that-reads-plain-english.jsonld"}}