Xi is a statically-typed, ahead-of-time compiled language with first-class dependency injection, eight function kinds, and refined types that enforce their constraints. It compiles to native binaries through a C99 backend, and its compiler is written in Xi and self-hosting.
import "std/log.xi"
interface Greeter { mapper greet(name: String) -> String }
class Friendly implements Greeter {
deps {}
mapper greet(name: String) -> String {
return "Hello, " + name + "!"
}
}
module App {
id = "greeter" // name of the compiled binary
name = "Greeter"
version = "1.0.0"
license = "Apache 2.0"
// the entry can live inside its module; dependencies are auto-wired.
// `entry` always returns Integer, so `-> Integer` is optional and a body
// without a `return` exits 0.
async entry (logger: Logger, greeter: Greeter) main(args: String[]) {
logger.info(greeter.greet("Ada"))
}
}
A folder can hold several such modules; xc --all builds each into its own
binary (named by its id). The entry may also be written at the top level with a
separate module App { … } block — both forms work.
Why Xi
- Dependency injection & IoC are part of the language, not a framework.
Implementations are discovered and wired automatically;
bindis an optional override. - Eight function kinds name a function's role and intent —
mapper,projector,predicate,consumer,producer,reducer,creator,action— and the compiler enforces purity for the pure ones. - Decision tables (
decisionkind) express business rules aswhen <cond> => <result>arms (or a tabularin/outgrid) — and, being a function kind, they're DI-injectable and can call predicates. - Interrupts — resumable conditions: a function
signals and suspends; an enclosingtry/catchdecides torecover(resume) orskip(abandon). See Interrupts. - Atoms — active-state stores: an immutable
statechanged only viatransitionreducers (Redux-style). See Atoms. - Machines — finite state machines as immutable values: named
states, machine-widedata, transitions with parameters,whereguards andupdateclauses,.can(...), and illegal moves that raise the resumableIllegalTransitioninterrupt. See Machines. - Events — built-in typed publish/subscribe. Producers
publish(topic, dto)any DTO; thelistenerkind subscribes to a topic and receives the typed value (no JSON). The default transport queues in memory with zero serialization; bind your ownPublisherService/ConsumerServiceto go external — producers and listeners are unchanged. Deliver synchronously (Events.run) or on a worker thread (Events.runAsync). See Events. - Web framework — implement
WebRequestHandlerand route by overloadingaction handle(req, res)withwhereguards;res.send(dto)/req.parse(T)auto-(de)serialize via a pluggableWebTransport(JSON by default). No manual JSON. Plain HTTP by default; opt-in HTTPS (web.serveTLS,XC_TLS=1) and HTTP/2 (web.serveHttp2,XC_HTTP2=1). See Web. - Share-nothing threading —
parallel { }blocks run on OS threads and yield aThreadhandle (stop/wait/running); threads talk only over thread-safe channels. See Threading. - Refined types carry constraints (
type Age = Number where value >= 0) that are checked at construction. - Sum / algebraic types (
type Shape = | Circle { r: Number } | Empty) with payload-bindingmatch— lowered to tagged unions. - Result-based error handling (
T!,ok/err,?propagation) — no exceptions. where-guarded overloading,match, optionals (T?), arrays (T[]), and aBytestype for binary data.- C interop — port a C library by declaring it in an
extern "C"block withlink/pkg/cflagsbuild directives;Ptr/cstringtypes,&mutout-params, and astd/ffiString↔cstring bridge. See C interop (e.g. a SQLite binding). - Multi-file projects with
importandnamespace, plus a moduledependenciesfield — list source-archive URLs andxi installfetches them into./modules(auto-compiled in, no manualimport). - A growing standard library — math, text, bytes, convert, serialization (json / yaml / xml), crypto (SHA/HMAC/base64/CSPRNG), fs, path, net (TCP sockets), http (HTTP/1.1 client), web (REST framework), thread (share-nothing threads + channels), process, time, ffi (C interop) — see the standard library and serialization.
- Native, dependency-light output: Xi → C99 → a native binary via your
cc. - Runs on the web too: the same source compiles to WebAssembly with
xc --target wasm(via Emscripten). See the WASM guide.
Full feature matrix: FEATURES.md. Full guide: code-by-sia.github.io/xi.
Quick start
On macOS (Apple Silicon + Intel) and Linux, install with Homebrew:
brew install code-by-sia/xi/xi
brew upgrade xi # later, to updateOr download a prebuilt toolchain for your platform from the
releases page, unpack it, and
put its bin/ on your PATH:
# grab the asset for your platform, e.g. xi-<version>-macos-arm64.tar.gz tar -xzf xi-<version>-<os>-<arch>.tar.gz export PATH="$PWD/xi-<version>-<os>-<arch>/bin:$PATH"
Either way you get xc and xi:
xc hello.xi # compile -> build/hello xc --all # build every module project under the current dir xi hello.xi # compile and run xi # interactive REPL xi version # print the toolchain version xi update # self-update to the latest release (tarball installs) xi skill # print the AI-agent language guide (xi skill > SKILL.md) xt file_test.xi # run tests (also: xt --all) loadtest --bench app.xi # load/perf test (--compile / --bench / --http)
Once installed, xi update upgrades the toolchain in place (downloads the latest
release for your platform and replaces the binaries, runtime, and stdlib).
The bundle ships the xc compiler, the xi REPL / run tool, the runtime, and
the standard library; the bin/ wrappers set XC_RUNTIME / XC_STD for you.
You need a C compiler (cc / clang / gcc) on PATH, since xc produces
native binaries via C. (To build from source instead, run
./compiler/bootstrap.sh — see
github.com/code-by-sia/xi.)
Runs on Linux (x86_64/arm64) and macOS (arm64/x86_64). On Windows, use WSL2 and follow the Linux steps, or run the toolchain in Docker (no native Windows build yet):
docker build -t xi . docker run --rm -v "${PWD}:/work" xi xi hello.xi # compile + run docker run --rm -v "${PWD}:/work" xi xc hello.xi # compile -> build/hello docker run --rm -it -v "${PWD}:/work" xi xi # REPL
The image downloads a published release; pin one with
--build-arg XI_VERSION=v0.0.14. See the Dockerfile.
Documentation
Full documentation — the language guide, dependency injection & IoC, decision tables, interrupts, atoms, state machines, events, serialization, the standard library, and the compiler internals — lives in the repository at github.com/code-by-sia/xi (rendered at code-by-sia.github.io/xi).
Showcase
eXstream is a full real-world app built with Xi — a music-streaming service whose backend is a set of Xi microservices (auth, file storage, playlist) behind an API gateway, with a React front end and Docker deployment. It's a good end-to-end example of structuring a larger project with modules, dependency injection, the web framework, and JWT auth.
Project layout
compiler/ the compiler, written in Xi (lexer, parser, codegen, driver) + xc_helpers.c
plus bootstrap.sh / fetch-seed.sh / selfhost.sh
runtime/ the C runtime (runtime.h, runtime.c) — the Xi equivalent of libc/libcore
std/ standard library (math, text, bytes, convert, json, yaml, xml, crypto, events, web, io, fs, path, net, http, process, time)
examples/ runnable programs, incl. proj/ (multi-file) and showcase/ (full project)
docs/ documentation (Docusaurus site under website/)
editors/ Tree-sitter grammar, Zed extension, Vim plugin
Editor support
A Tree-sitter grammar plus Zed and Vim integrations live in
editors/. The grammar parses every .xi file in this repo.
License
Xi is licensed under the Apache License 2.0 — see LICENSE and NOTICE. It is provided "AS IS", without warranties of any kind, and with no obligation of support (Apache-2.0 §7–§8). It's an experimental personal project — issues/PRs are welcome, but no support or maintenance is guaranteed. See CONTRIBUTING.md and SUPPORT.md.