Language documentation portal

Slovo ⰔⰎⰑⰂⰑ

Slovo is a small Lisp-family systems language with a public beta compiler, explicit module/package tooling, LLVM-backed native builds, a staged standard library, and a design process documented alongside implementation gates.

Current release: 1.0.0-beta.16 Compiler: Glagol ⰃⰎⰀⰃⰑⰎ Maturity: experimental beta
Runtime Native LLVM IR, hosted C runtime helpers, test runner.
Types Integers, floats, bools, strings, structs, enums, arrays, vectors, options, results.
Tooling check, fmt, test, build, run, doc, symbols, new, clean.
Latest Byte-oriented string scanning and token-boundary helpers.

Start

Clone the monorepo, run the compiler from Cargo, then check or test one of the included projects.

git clone https://git.hermeticum.io/Hermeticum/slovo.git
cd slovo/compiler

cargo run -- --help
cargo run -- check ../examples/projects/std-import-string
cargo run -- test ../examples/projects/std-import-string
cargo run -- doc ../examples/projects/std-import-string
  1. Use project mode for normal Slovo programs.
  2. Import standard modules explicitly, for example std.string or std.fs.
  3. Use result and option helpers for ordinary failure paths.
  4. Read the current release notes before depending on a beta surface.

Language Surface

The beta line is usable for small native command-line and local service experiments, while still reserving stable compatibility promises for later releases.

Core language

Functions, tests, if, while, immutable and mutable locals, structs, enums with payloads, match over options/results, arrays, concrete vectors, and C FFI behind explicit unsafe blocks.

Project model

Single-file, project, and workspace flows with module imports, package dependencies, graph manifests, deterministic diagnostics, and generated Markdown API docs.

Beta boundary

Executable generics, maps, sets, traits, stable ABI/layout, stable diagnostics freeze, broad package registry semantics, and stable stdlib compatibility remain deferred.

Standard Library

The library follows a flat Zig-like source facade shape: staged std/*.slo modules wrap promoted runtime calls and ordinary source helpers.

Modules

std.string, std.num, std.result, std.option, std.math, std.io, std.fs, std.env, std.process, std.cli, std.net, std.json, and concrete vector facades.

1.0.0-beta.16

std.string.byte_at_result, slice_result, starts_with, and ends_with define byte-oriented scanning over current runtime strings without claiming Unicode or language-level slice semantics.

References

Primary documentation lives in the public repository and is versioned with the compiler and standard library.

Language Specification Current beta language semantics and explicit deferrals. Read Standard Library API Generated catalog of exported lib/std helper signatures. Read Standard Runtime Compiler-known runtime calls, contracts, fixtures, and non-scope notes. Read Packages Project and workspace package model for the current beta line. Read Compiler Releases Glagol release history, tooling gates, and runtime changes. Read Slovo Whitepaper Technical whitepaper generated from the current language state. PDF Glagol Whitepaper Compiler architecture, implementation state, and roadmap. PDF

Benchmarks

Benchmarks are local-machine comparison scaffolds, not stable performance claims. They are useful for tracking compiler/runtime changes against C, Rust, Python, Clojure, and SBCL where installed.

python3 benchmarks/math-loop/run.py
python3 benchmarks/branch-loop/run.py
python3 benchmarks/parse-loop/run.py
python3 benchmarks/json-quote-loop/run.py

The benchmark catalog is release-gated. Treat results as machine-local signals until the language defines a stable optimization and benchmark metadata policy.

Roadmap

Next slices should stay connected and release-gated: language feature, compiler/runtime support, docs, examples, diagnostics, review, and publication together.

Tooling

Formatter hardening, language server/watch flows, richer doc generation, install packaging, and tighter diagnostics review remain active directions.

Language

Generics, maps/sets, iterators, stable module reexports, slice/view semantics, and deeper type inference need explicit contracts before stable.

Library

JSON parsing, richer string/token APIs, portable filesystem breadth, networking beyond loopback, and collection families can grow behind beta gates.