Projects

Built from first principles.

The engineering behind AntaresOrigin. Chess engines that compete with the world's strongest, a programming language for AI, and an AI coding agent written in it — each built from scratch, tested rigorously and documented openly.

01 · Chess engine

NARC Genesys

An original chess engine, written from scratch and trained on its own data, that competes with engines trained on many times more positions.

NARC Genesys logo

Overview

A chess engine is a program that plays chess. It has two halves: a search that looks ahead through possible moves and replies, and an evaluation that judges how good each resulting position is. NARC Genesys is the latest major release of the NARC project, a complete re-implementation of the original NARC engine, built to be as efficient and strong as possible.

It was developed as an individual project using AI-accelerated research and development. Large language models were used as tools to speed up the work, while every key technical and strategic decision behind the engine's strength was made independently. That combination made it possible to test hundreds of ideas in about three months.

Every idea, tested properly

Each change was measured with SPRT matches, a statistical method that plays games until it's clear whether a change really helps. Most ideas were rejected. The biggest gains came from two places: choosing high-quality training data and optimising the design of the neural network.

An engine that learned from itself

NARC Genesys started with a hand-written evaluation and then improved itself in cycles. Its first neural network (NNUE) was trained on just one million positions from its own games, and it beat the hand-written version by roughly 100 Elo. The process was then repeated, with the dataset growing each time and a stronger version of the engine re-scoring every position.

The final network was trained on a carefully filtered mix of the engine's own games, high-quality positions from the open Lichess database and openly licensed self-play collections. Every position was scored by NARC's own engines, so no other engine's knowledge was copied into it.

The networks of most 3500+ engines are trained on billions of positions. NARC Genesys was trained on about 249 million — and competes with them.

Its estimated strength of about 3608 on the CCRL Blitz scale comes from a gauntlet of 1,980 games against nine CCRL-rated engines. The engine hasn't hit a strength ceiling; progress is currently limited by available computing power.

What's new in 5.1

  • A wider neural network with 1,024 neurons per side instead of 256, trained from scratch on the same 249 million positions. It judges positions more accurately, at the cost of running 25–40% slower.
  • ThreatHist, a smarter way of ordering moves that considers whether a piece's starting and landing squares are under attack, so better moves are tried first. On its own it gained +13.2 Elo.
  • Overall, 5.1 measured +29.9 Elo stronger than 5.0 over 756 games.

Version history

VersionApprox. CCRL BlitzOfficial CCRL 40/15
NARC Engine2950—
NARC NEXT 4.134003320 (rank #168)
NARC Atlas 4.53500Private
NARC Genesys 5.03600Pending
NARC Genesys 5.13608Pending

Under the hood

NARC Genesys is an original engine — not a fork or clone, and containing no code copied from other engines. Like nearly every modern engine, it uses well-known published techniques, written in its own code: alpha-beta search with aspiration windows, late move reductions, null-move and futility pruning, singular extensions, history-based move ordering, multi-threaded Lazy SMP search, magic bitboards, and an NNUE evaluation with king and material buckets stored in its own network format. Two components follow Stockfish's published design and are credited openly.

Quality over quantity

Carefully chosen data beat datasets many times larger.

Measured, not guessed

Every change proved with statistics before it was kept.

02 · Chess engine

CeylonDemon

An experimental chess engine whose neural network looks at every position from both sides of the board — and taught itself entirely from its own games.

CeylonDemon rating dashboard: leaderboard, version progression, rating convergence and score against opponent rating

Overview

CeylonDemon is an experimental engine built on the codebase of NARC. Where NARC focuses on raw efficiency, CeylonDemon explores a different question: what if the engine judged every position from two points of view at once? Its name and identity are inspired by the traditional demon masks of Sri Lanka.

Resonance: a two-perspective neural network

Most engines judge a position from a single point of view. CeylonDemon's evaluator, called Resonance, is a dual-frame NNUE that judges it twice:

AEGIS

Looks from your own king's side and asks: "Am I safe?"

LANCE

Looks from the enemy king's side and asks: "How much pressure is on them?"

The two answers are blended into one score. When they disagree strongly, the position is usually sharp and difficult — exactly where careful judgement matters most.

Self-taught

The network learned chess by studying 400 million positions from games CeylonDemon played against itself. It uses no games and no networks from other engines.

How strong is it?

Across development versions 2.1 to 3.3, the accumulated measured gains add up to around 350 Elo, which translates to roughly 200–250 Elo of real improvement over version 2.0. The current version is estimated at about 3450 in home testing, measured at short time controls. Full results for all of our engines are published in the open engine rating list.

CeylonDemon 3.3 results against each opponent: wins, draws and losses
CeylonDemon 3.3 results against ten reference engines. Home testing, not an official rating list.

Honest about its limits

Good engineering means knowing where a system falls short. Because it reads every position twice, CeylonDemon searches fewer positions per second than the top engines. Its evaluation can be overconfident in balanced positions, it has not yet beaten an engine rated above about 3700, and it has no endgame tablebase support. Most testing so far has run on a single thread on one laptop.

Using it

CeylonDemon has no board of its own. Load it into a chess program such as Arena, Cute Chess, BanksiaGUI or ChessBase to play against it or analyse games. Ready-made Windows versions are available on the 3.3 release page.

03 · Programming language

Antares

The programming language for AI. Train neural networks, talk to language models and build AI agents — in one small, friendly language.

The Antares IDE running a grade book program

Why a new language?

Building with AI today usually means juggling several languages, libraries and frameworks. Antares puts the essentials into the language itself: tensors, automatic differentiation, the building blocks of transformers, and conversations with models like Claude, OpenAI's models or free local models are all built in, not installed. The whole language is a single small program that starts instantly.

Train a model

learn marks what the model may change; descend improves it. Layers, losses and optimisers are built in, and matrix maths uses every CPU core — or the graphics card, with nothing extra to install.

train.antAntares
learn w1 = he(2, 32)
learn w2 = xavier(32, 2)

repeat 500 {
    loss = cross_entropy(gelu(x @ w1) @ w2, labels)
    descend loss by 0.01 using adamw clip 1
}

Ask a model

Answers come back as real values in the shape you ask for, ready to use in the rest of the program.

ask.antAntares
model claude = "anthropic:claude-opus-5-5"

person = ask claude "Who wrote Gitanjali?" as {name: text, born: number}
show person.born + 100

Build an agent

Give a model your own functions as tools, or built-in ones that run commands and read the web, and it decides when to call them. Antares asks for your permission before every command.

agent.antAntares
to percent(amount, rate) = amount * rate / 100

model helper = "ollama:qwen2.5" with {tools: [percent, shell, read_page]}
show ask helper "What is 17% of 2450? And which file here is the biggest?"

What's inside

  • Deep learning: tensors, autodiff, attention, layer norm, cross-entropy and AdamW. A working GPT-style transformer fits in about 100 lines.
  • GPU training: one line, use gpu, sends training to the graphics card — 53 times faster than the CPU on a Tesla T4.
  • Any model: Claude, OpenAI and compatible services, or free and private models on your own computer through Ollama.
  • Graphics and 3D: games in a window, smooth shapes, real fonts, and 3D scenes with lighting, shadows and materials.
  • Friendly by design: it reads like plain verbs — learn, ask, show, repeat — and every error names the line and explains what to do in plain words.

Antares IDE: made for beginners

The Antares IDE, shown above, is a simple place to write and run Antares programs. It colours code as you type, runs programs with one click, marks errors with plain-language hints, and includes a built-in guide to every statement and all 100 built-in functions — plus examples from a times table to a neural network and a Snake game. A free beginner's book, Learn Antares, teaches programming from the very first step, and the complete Antares Language Reference covers every feature. See the Antares IDE on GitHub.

04 · AI coding agent

Antares Code

An AI coding agent for the terminal — written entirely in the Antares language and powered by free AI models.

Antares Code welcome screen asking the user to connect an AI service

Overview

Antares Code is a coding agent you talk to in plain words. Ask for a change and it reads your code, edits files, runs your tests and commands, searches the web, fixes what fails and tells you what it did. It runs on free models from NVIDIA, Google's Gemini and OpenRouter, and you can switch between them at any time.

It's also proof of what the Antares language can do: a complete, real-world AI agent, written entirely in a language built in-house.

Antares Code session: it reads a to-do app, adds a done command and a test, runs the tests and tries the command
A real session: asked to add a "done" command to a small to-do app, Antares Code reads the code, edits it, adds a test, runs the tests and tries the new command.

Built to be safe and in your control

  • Works on its own from start to finish by default, or asks before commands or before every change — your choice.
  • /plan makes it plan first and wait for your approval; /undo takes back what it changed.
  • Your keys stay yours: keys, settings and memory live in your own folder, never inside the program, so the same file can be shared safely.

Easy to start

Antares Code ships as a single file, acode.exe, with nothing to install. The first time it runs, a welcome screen walks you through five short steps: connect an AI service, choose a model, decide how independently it should work, choose whether it should remember your projects between sessions, and optionally enable full web search.

Why it matters

Agents that read, decide, act and check their own work are exactly the kind of systems businesses now want. Building one end to end — in our own language — is how we learned what makes agents reliable in practice.