DEV Community: Techie Kho

Meet Ovis: a compiler that reads plain English

Techie Kho — Thu, 22 Oct 2026 14:10:26 +0000

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>.lock that 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.

Bag: A header-only, simplistic, C++20, zipping & unzipping library.

Techie Kho — Fri, 10 Jan 2025 06:13:39 +0000

Hello! It has been a while since the last time I did something for entertainment and learning purposes. So I take up a fairly simple C++ project that hopefully could be useful for other fellow C++ devs.

Problem Statement

As I play around with raylib, the small, easy, and exceptionally cool game library, I met a small issue. There is no elegant way of packing files together. When I use a texture or audio, or any external resources, I either need to convert it into a C++ header that declares a byte array filled with that resource, or making sure the the user having the resource at the particular place. The first approach is no good when comes to loading new resource after compilation, while the latter approach is kind of awkward and too easy to break.

I'm quite fond of the embedded zip approach. Zip files having a quirky file structure in which the header and metadata is at the end of the file in contrast with other file structure, such as executables, which is at the beginning of the file. This quirk gives a possibility, which is appending the zip file at the end of the executable. This makes the file behave like an executable, and a zip file at the same time.

I believe there is definitely other zip library that did what I requested. But I would like to have some fun in C++20. So let's get started.

Overview of bag

With the aforementioned reasoning in mind, I wrote libbag, a header-only library for simple zipping and unzipping. It also includes the zipping (bag) and unzipping (unbag) utilities.

By itself, it is sort of like a serialiser and deserialiser for key-value pairs, with key being a simple C-style string and value as byte array. The bag file structure is fairly simple:

|------------------------|
| key 0 (C-style string) |
|------------------------|
| Content 0 (Byte array) |
|------------------------|
|       ......           |
|------------------------|
| key N (C-style string) |
|------------------------|
| Content N (Byte array) |
|------------------------|
| indices                |
|------------------------|
| metadata               |
|------------------------|

So the key-value pairs are tightly packed together, and some data is appended at the end of the pack. Metadata specifies the whole bag's byte count (to ignore any excess byte in front), position and length of indices, and lastly some magic bytes to indicate it is a bag.

From the length and position of indices specified in metadata, we can query the memory to get the indices slice in bag. There it resides a list of position and length for each of the key-value pairs saved.

To get the keys, just treat each key-value pairs as a C-style string since there is a null-terminator that marks the end of the key string. To query the content, just skip 'till the first null-terminator (basically the whole key), and then you get the content begin position, with some pointer arithmetic using the position and length from the indices, the end position of the content can be calculated.

Here is some example usage.

#include<libbag.hpp>
#include<sstring>


int main() {
    std::map<libbag::key_type, libbag::content_type> input_map;
    /// Add items into `input_map`.
    std::basic_ostreamstring<libbag::unit_type> packed_stream; // Can be replace with std::basic_ofstream to output to file.
    libbag::pack(input_map, packed_stream); // Pack.

    libbag::unit_string_type packed = packed_stream.str();
    std::map<libbag::key_type, libbag::content_type> result;
    libbag::unpack_all(libbag::bag_type(packed.begin(), packed.end()), std::inserter(result, result.end())); // Unpack.
    /// Do something about the unpacked data.
}

The API depends on iterators, stream and inserters to reduce allocations.

I also wrote a simple CLI to zip and unzip files, which is great for referencing as well:

bag
unbag

React website sample for portfolio

Techie Kho — Thu, 11 Apr 2024 15:18:51 +0000

TL;DR: I make a website about kitties for portfolio, and here is the source code

Introduction

Hello people! So I have been trying to do a little freelance as a front-end web developer. Programming is my passion, but it has yet to feed me. I always heard that front-end web developer is the most common job in the market; many start-ups need a website, right(?). I've realised that I don't really have a web project to show off my web-making skill. My portfolio website doesn't count as it is made using vanilla javascript. So I guess it is time to make a random website using modern and popular framework like React.

The tech stack is very simple:

Vite for project setup and bundling.
React (of course)

I was about to use Material UI as they give a bunch of cool reusable components that is already stylised. But, it feels too "Google" and I am a C programmer (having an obsession over reinvent the wheel).

Setting up the project

Vite projects are VERY easy to setup to the point that I feel like it is too good to be true. The last time I play around with web, vite is yet to exist and configuring webpack took me 30 minutes of scanning through the docs only to be forgotten once the setup is completed.

For vite, it really just these magic word:

npm create vite@latest

Do some command line inputs and it is done, amazing.

Working the design

Alright, I'll going to be honest here: I kind of want to finish this ASAP in the weekend so I made things up along the way instead of planning it in Figma.

I first checking out any good fonts on Google font that fits the theme of the website. I select the Nunito as I could feel the playful vibe behind it.

Then, I get some color palette from this color palette generator. I have been using it since the very beginning of web dev journey, a good color palette could better describe the theme of the website.

CSS

Writing CSS is much a creative process here since I don't have a mockup, thus it is kind of describe it in detail. But I will still share things that I usually do in CSS.

reset.css
I will always use the reset stylesheet. It is because different web browser has its own default stylesheet that could mess up my code. So I just copy the code and put it in the project.
CSS variables
I love CSS variables, I use it to for the color palette.

:root {
  --light: #f5f5f5;
  --grey: #796c9f;
  --dark: #392f5a;
  --primary: #2ea9c4;
  --primary-light: #a1d8eb;
  --secondary: #ff9f1c;
  --secondary-light: #ffbf69;
}

It avoids hardcoding colors. Then, I only need to change the value of the variable instead of searching through the codebase for that particular color code.

Javascript

Since it is React, I need to do something special here.
I decided to use the Cataas API to fetch cat pictures in my code to display the random cats.

But behind the scene, it is just useState and useEffect hook.

  const [catImage, setCatImage] = useState(initialCatImage);

  useEffect(() => {
    const updateCatImage = () =>
      (async () => {
        const response = await fetch(
          `https://cataas.com/cat?width=250&height=250`
        );
        setCatImage(URL.createObjectURL(await response.blob()));
      })();

    const id = setInterval(updateCatImage, 5000);
    return () => {
      clearInterval(id);
    };
  });

And that is all the special stuff in the website...

Deployment

I'm using pgs.sh to host my static site. It uses ssh (secure shell) and rsync (a file transfer protocol) to do all the stuff. It doesn't need to create account or whatsoever. Very quick to setup, very cool.

Conclusion

Well, I got a website to show-off and maybe get a freelance project. And, you get to see all my source code and learn something. It is beneficial to both of us. Thank you for reading this late night posting and have a nice day/night.

Running pre-trained ML models in Godot

Techie Kho — Thu, 18 Jan 2024 12:21:04 +0000

So I have been developing this GDExtension called iree.gd. It is mission to embed IREE, another cool project that compiles and runs ML models, into Godot. It took me quite a while, but finally It has reached alpha.
Hope you guys could check it out the sample.

I can't upload video to here, but you still can watch a small clips of iree.gd doing its magic here

Overview

Currently, it is still having a very thin abstraction layer, and some manual stuff need to be done in prior.

Preparing the ML model

Before doing anything, you'll need to download your trained ML model from the internet. You could find some from Kaggle. Then, you'll need to preprocess them with python via this detailed documentation. You'll need to set the HAL backend following this table depending on your targeted platform. As you generate the .vmfb byte code, you are ready to proceed to the next step.

Use the ML model

.vmfb files are automatically imported into the project as you drag and drop 'em into it. You could then use them in your script by loading them.

var model : IREEModule = preload("res://your_model.vmfb")
@export var model_2 : IREEModule # Drag and drop in editor

Then, you'll need to prepare your inputs with IREETensor, then execute the ML model.

var input := IREETensor.from_bytes(image.get_data(), [1, 50, 50, 3]) # Remember to consider the input type.
var outputs := module.run_module("module.main", [input])
for output in outputs:
    pass # Do something with the `output`.

The input and function name vary models to models. You could inspect the .vmfb file using iree-dump-module from the IREE packages you installed during preparing the ML model.

Here is one section of the dump of the ML model used:

...
Exported Functions:
  [  0] main(!vm.ref<?>) -> (!vm.ref<?>)
        iree.abi.declaration: sync func @main(%input0: tensor<1x50x50x3xf32> {ml_program.identifier = "input_0"}) -> (%output0: tensor<1x200x200x3xf32> {ml_program.identifier = "Identity"})
  [  1] __init() -> ()
...

You could kind of guess it, it has main function that takes a tensor of float32 (1x50x50x3xf32) and outputs another tensor of float32 (1x200x200x3xf32).

Sample

There is a readily available sample of esrgan for you to try in the release page.

The sample only work on windows and linux.

After download and open iree-gd-sample-*.zip with Godot 4.2+, you will need to do these:

set res://scenes/main/main.tscn to be loaded on start.
Drag and drop appropriate byte code in res://bytecodes/esrgan/esrgan.*.vmfb into UI/TextureRect's module export.
Run it.

Afterword

Hopefully, in the future, Godot developer could utilise this piece of technology and create something extraordinary and magical. Thank you for reading this.

Minky scripting language

Techie Kho — Wed, 15 Nov 2023 12:38:29 +0000

Edit: It has been rebranded to Blinklet, here is the repo

So I have written a simple scripting language in Rust, the obscure language for a lot of devs. It is called "Minky".

Here is the link

The whole idea of this language stems from this thought:

What if we remove parentheses from LISP?

Essentially, Minky is my version of WISP.

Syntax

Let's jump into the syntax:
In a typical C-derived language, a function call usually look like this:

function(arg1, arg2, arg3)

In Minky, since we disdain parentheses, we replace all the separating symbols with whitespace

function arg1 arg2 arg3

But... what if I want to inline a function call as an argument like this?

function(arg1, arg2, another_function())

Well, in Minky, you just indent it!

function arg1 arg2
    another_function # This will call

If you don't indent it, another_function will be passed as value.

But! What if I want to pass value after some indents?

function arg1
    another_function 
    arg3 # I don't want this to get call!

Well, you just prefix it with | to cancel out the call

function arg1
    another_function
    | arg3 # Pass as value!

Some features

String interpolation
Closure
Loose Object-Oriented Programming

String interpolation

To do string interpolation:

some-command 'Text `identifier`'

The identifier is the variable name, it will substitute with the variable's string representation.

Closure

All the user-defined functions are closure. It has access to the lexically scoped variable. In simple term, the scope that the closure is declared in lives with the closure until the closure itself dies, and the closure can access the scope.

Here is an example:

var make-counter
    closure
        var counter 0 # counter will live with the returned closure even after `make-counter` complete execution.
        return
            closure
                set counter # access parent counter.
                    add counter 1
                println 'counter: `counter`'

var counter
    make-counter

counter # 1
counter # 2
counter # 3

Loose Object-Oriented Programming

In normal class-based object-oriented programming, we have class and object, in which the object's structure is based on the class. In Minky, all of the classes and objects are table. Tables are not linked together in anyway, but you can make a copy of a table (instancing) and extends on top of it (inheritance). Table is also act as scope, too!

To make a person class:

var Person
    table
        var name 'Bazinga'
        var age 25
        var say-hi
            closure # aka. function but has access to parent scope.
                println 'Hi! I am `name`. Nice to meet you!'

To make an instance:

var peter
    Person
        set name 'Peterson'
        set age 90

# Call the method
peter
    say-hi

# Access values
var peter-age
    peter
        return age

To extend:

var Police
    Person
        set name 'Policeman'
        set age 15
        var gun 'AK15'

Conclusion

It is my attempt on making a scripting language. There are more feature to be discussed, and to be added. You can fetch the code at my GitHub repo. Thank you for reading and have a nice day.

Piko-piko OS. A homemade 16-bit x86 toy operating system for fun.

Techie Kho — Wed, 07 Dec 2022 11:33:18 +0000

So I made a 16-bit x86 toy OS in pure assembly. 3 months ago, I found a very fun tutorial on github that is about Operating system development. I read the first few chapter and from there I made a very simple, extensible (?) toy operating system that could run on hardware (yes, it is madness).

Piko-piko OS overview

As the title stated, it is a toy os so itself doesn't do much. Still, the language is still turing complete. Here is an example that prints Hello world 10 times.

00000 set 0 10
00001 say n "Hello world"
00002 sub 0 $0 1
00003 cmp $0 0
00004 june 1

The language is more or less like an interpreted assembly language without label. It can read user input, print to output, basic arithmetic, save & load data and conditional jumps. Here is all the commands included. I'll write a more user-friendly tutorial to kick start your Piko-piko OS coding journey, but right now you can only

In Piko-piko OS, you can either enter the command to the prompt to run the command directly or using = command to save lines of command to buffer and run it all together with run command. By default, there is 3 buffer. Each buffer can only holds 2560 lines of text.

Piko-piko OS is self-contained, which means that it does not rely on any other code and won't effect other files except itself. When saving & loading data, it does read and write to itself only.

Practicality?

Yes, it is not practical but it is a very educational resource to learn lower-level programming and really knowing how machine work. Still, you can use it to:

Show off
Stop your child from watch too much youtube by locking them up in Piko-piko OS.

It is a very cool experience to be able to make an operating from scratch. I might be able to share the experience of developing Piko-piko OS on the next blog post.

Don't write HTML page, I will tell you why.

Techie Kho — Mon, 11 Oct 2021 10:07:03 +0000

Instead of encourage people, I am here to discourage you a guy, who started / want to start web development.

The start

At the start your journey, you install either sublime or vscode or notepad++, then you start to make a website using HTML and know that HTML is a HyperText Markup Language. You feel proud of yourself as your HTML page is displayed in google chrome. Then, you color your page with CSS and make your page interactive with alert() and document.write().

framework hell

Slowly, you think you are very good, then you heard of React or Angular and you immediately jump into it. In the blink of an eye, you are overwhelmed. What the hell is Webpack? What is JSX? What is Nodejs? What is typescript? What is npm? What is Sass? Why a simple website need so much technology with weird names?

server-side programing

At the verge of giving up, you heard of database and server. You install XAMPP or WAMPP and then start poking around with PHP. You also play around with expressjs. Then, you are once again overwhelmed. What is composer? What is a session? What is phpMyAdmin and MySQL?

game development

After you learn one or two things, you think desktop application and game development is cool, so you install Unity. Oh my, Object-Oriented Programming in C# (pain in general). You think that ElectronJS is easier and want to give it a shot but because everyone critisize that it is less performant so you give up.

linux

Then, you heard that people keep telling you "I use Arch, btw" and "Vim is the best editor". You watch a few shitpost from Mental Outlaw (on youtube) and decided to install gentoo linux. You are once again overwhelmed. Why so much command (cd, touch, ls, emerge, time, ifconfig, vim and etc.)? Systemd called as soystemd? OpenRC? Init system? GNU and Linux is different? Display server? X.org vs Wayland? dwm vs bloated Gnome?

lower-level programming

Then as you get used to the tty and know how to edit some text in vim. You start to do some C and C++ programming. Although the OOP from C# or Java helps, you still feel overwhelmed. CMake, Ninja, gcc, tcc, clang, llvm and etc.
Maybe you also step on some assembly language and suffers.

Ok I will stop now. All these painful learning + failing + imposter syndrome + mental illness is all because of you decided to install sublime / vscode to create a HTML page.

In conclusion, don't create your first HTML page.

Here is my website without fancy stuff like React or Angular or Vue

Techie Kho — Sat, 09 Oct 2021 01:47:46 +0000

A website that I created using only HTML, CSS, and JS : https://rechiekho.github.io/RechieKho/index.html

Yes, its content is really stupid because I can't come out a new one.