Symta

A novel Lisp dialect where one terse line replaces fifty verbose ones — and stays readable.

Symta is a list-processing Lisp inspired by REFAL, POP-11, and MIT PLANNER. Its central bet: the everyday operations that bloat real programs — filtering, mapping, parsing, replacing, destructuring, classifying — should each compress to one short, composable construct. Not a library call. Not a regex. Not a 30-line for-loop.

The same {} operator does map, filter, group, reduce, replace, parse, and pattern-match — because in real programs those are the same idea with different bodies.

FizzBuzz, in full:

[:100]{~?%15=\FizzBuzz; ~?%3=\Fizz; ~?%5=\Buzz}

Quicksort:

qsort@r H,@T = @T{:?<H}^r, H, @T{?<H=}^r

Substitute %vars% in a template from a table, in 18 characters:

Form{@"%[V]%"=Data.V}

Symta has macros, eval, quasiquote, gensyms — the things you'd expect from a Lisp — with a pattern matcher fused into the syntax. It also ships a real entity-component-system integrated into the language, not bolted on as a library, for games and simulations where OOP stops scaling.

Downloads

Symta is distributed as milestone releases -- a source tarball (Linux + portable) and a zip with pre-built Windows binaries. No public git endpoint: the project's source repository is private infrastructure used by the author, and only released snapshots are published here.

• symta-latest-linux.tar.gz — source tarball + Linux binary
• symta-latest-windows.zip — pre-built symta.exe + DLLs + examples

Each release is a self-contained snapshot. No installer, no package manager integration -- unpack and run. See the README inside each archive for invocation.

Implementation

• Self-hosted. The compiler is written in Symta itself — about 28 000 lines of Symta sitting on top of a 10 000-line C runtime.
• AOT compiles to bytecode. Source compiles to a compact SBC ("Symta ByteCode") format that is cached on disk; subsequent runs of a program load instantly without re-compiling.
• x86_64 JIT, default on. About 99% of bytecode opcodes translate to inline native code — typed-int arithmetic, list-array access, immediate compare, struct loads and stores all run as native x86 with no per-opcode helper-call overhead. Hot loops reach C-competitive single-iteration cost.
• AOT-native cached in the bytecode. Each .sbc file carries a pre-translated native-code section in addition to the bytecode, so a program starts running native on the very first invocation, not on a JIT warm-up.
• Generational GC. Small nursery, copying collector, on the order of milliseconds per cycle for typical workloads.
• FFI to C. Hand-rolled bindings; the runtime ships with SDL2 / SDL_mixer plugins for graphics and audio, used by the example games.
• Platforms. x86_64 Windows and Linux get the JIT and the AOT-native cache. ARM (Linux, Apple Silicon) runs the same source through the interpreter — correct and self-hosting, just without the native-code fast path. macOS x86_64 builds from source.

Learning Symta

Type help at the Symta prompt for the built-in reference. An online reference manual is on the roadmap; this page will link to it when it lands.