Todd Henderson

Posted on May 22

AiLang: An AI-First Language Focused on Deterministic Execution

#devchallenge #githubchallenge

GitHub “Finish-Up-A-Thon” Challenge Submission

AiLang — GitHub Finish-Up-A-Thon Challenge Submission

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

AiLang — A Deterministic AI-First Programming Language

AiLang Website: https://ailang.codes

AiLangCore GitHub Organization: https://github.com/AiLangCore

AiLang is an experimental AI-first programming language ecosystem focused on deterministic execution, canonical structure, and spec-governed semantics.

The project currently consists of three major components:

AiLang — the language, compiler, and SDK
AiVM — a deterministic virtual machine/runtime
AiVectra — a cross-platform UI framework

Unlike many modern platforms where behavior is partially defined by the runtime or host platform, AiLang keeps semantic authority inside the language specification itself. The host runtime is intentionally thin, mechanical, and replaceable.

The goal is to explore what programming languages and tooling could look like when designed specifically for:

autonomous AI agents
reproducible builds
deterministic execution
canonical formatting
multi-agent development workflows

This project started as a collection of experiments around deterministic execution and AI-assisted development, but evolved into a much larger ecosystem focused on AI-native software engineering.

Demo

Website

https://ailang.codes

GitHub Repositories

Example AiLang Program

Program#p1 {
  Export#e1(name=start)

  Let#l1(name=start) {
    Fn#f1(params=args) {
      Block#b1 {
        Call#c1(target=sys.stdout.writeLine) {
          Lit#s1(value="Hello from AiLang")
        }

        Return#r1 {
          Lit#i1(value=0)
        }
      }
    }
  }
}

Current Focus Areas

Deterministic VM execution
Canonical formatting
Spec-governed semantics
AI-oriented tooling
Multi-file module support
Standard library expansion
NativeAOT runtime work
Future C-based VM portability

The Comeback Story

This project originally began while I was working for a client evaluating AI tools for software development workflows. During that process, I became increasingly interested in the limitations current programming languages present for AI-assisted development, deterministic execution, and autonomous tooling. What started as a small experimental language project gradually evolved into the broader AiLang ecosystem.

Over time, the scope grew into a complete ecosystem:

language
VM/runtime
tooling
UI framework
package system concepts
AI-agent workflows

Like many long-running side projects, parts of the architecture evolved organically and needed substantial cleanup and stabilization before they could realistically move toward public adoption.

For this challenge, I focused heavily on:

improving architectural consistency
refining deterministic execution guarantees
cleaning up repository structure
improving documentation
strengthening the specification-first workflow
hardening VM resource limit handling
improving the overall developer onboarding experience

One major focus was reinforcing a core design principle:

The language defines behavior — not the runtime.

That required revisiting assumptions across the compiler, VM, syscall boundaries, and tooling to ensure the ecosystem remained deterministic and spec-governed.

This challenge helped push the project from “experimental internal architecture work” toward something that is becoming increasingly usable and explainable to outside developers.

My Experience with GitHub Copilot

GitHub Copilot became an extremely valuable accelerator during development, especially while working across multiple repositories and architectural layers simultaneously.

Where it helped the most:

scaffolding repetitive infrastructure
generating test boilerplate
helping iterate on parser/runtime ideas
exploring alternative implementations
accelerating documentation work
reducing friction while refactoring

The biggest benefit was not replacing architectural thinking, but reducing the mechanical overhead around experimentation.

Because AiLang emphasizes deterministic behavior and specification-driven development, I still had to carefully validate generated code against the project’s architectural constraints and invariants.

In many ways, the project itself explores a question closely related to tools like Copilot:

What would a programming language look like if it were designed from the beginning for AI-assisted development?

That exploration became one of the driving motivations behind the entire AiLang ecosystem.

DEV Community