Lambda Script

A general-purpose, cross-platform, functional scripting language and document processing engine in a single ~20 MB executable, built from scratch in C/C++.

Lambda is designed for two things at once:

1. an expressive functional language for transforming data and documents, and
2. an end-to-end document pipeline (parse → validate/transform → layout → render/view).

Internally, Lambda treats documents as structured data. Different input formats (Markdown, Wiki, HTML/XML, JSON/YAML/TOML/CSV, LaTeX, PDF, …) are parsed into a unified Lambda/Mark node tree, transformed with Lambda scripts, validated with schemas, and then rendered via the Radiant HTML/CSS/SVG/JS layout engine.

Note: Lambda Script is still evolving — syntax/semantics and implementation details may change. A stable subset of the literal data model is separately formalised and released as Mark Notation.

Demo

See all supported document types in the demo gallery.

Try it: download the Lambda binary from the Releases page, unzip, and run:

lambda demo

Features

Lambda script (pure functional runtime)

• Pure-functional core with immutable data structures (arrays, maps, elements) and first-class functions and types.
• Expressive pipe operator (|>, with the filter stage |:) for fluent set-oriented data transformation pipelines with inline mapping and filtering.
• Vector arithmetic with automatic broadcasting — apply scalar operations to entire collections.
• Powerful for-expressions with where, order by, limit, offset clauses for SQL-like data querying.
• Interactive REPL for exploration and debugging.

Markup input parsing & formatting

• Multi-format parsing: JSON, XML, HTML, Markdown, Wiki, YAML/TOML/INI, CSV, LaTeX, PDF, and more.
• One universal representation: parse disparate syntaxes into a common Lambda/Mark node tree.
• Conversion pipeline: convert between formats using lambda convert (auto-detect input formats when possible).
• DOM-centric tooling: designed to treat "documents as data/objects", not just as text.

Type system & schema validation

• Rich type system with type inference and explicit type annotations, similar to and beyond that of TypeScript.
• Schema-based validation for structured data and document trees (including element schemas for HTML/XML-like structures).

Radiant HTML/CSS/SVG/JS layout, rendering & viewer

• Browser-compatible layout engine supporting html block, inline, flex, grid, and tables.
• Unified interactive viewer via lambda view:
  • HTML/CSS/SVG with JavaScript — the embedded LambdaJS engine covers ES2024 (test262), the browser DOM and a Node.js compatibility layer
  • XML (treated as HTML with CSS styling)
  • Markdown / Wiki (rendered with styling)
  • LaTeX (.tex) via conversion to HTML
  • Lambda script (.ls) evaluated to HTML and rendered (think of PHP)
• Render targets: SVG / PDF / PNG / JPEG output via lambda render.

Language Highlights

Elements (Markup Literals)

First-class markup syntax for document generation:

let card = <div class: "card",
    <h2 "Title">
    <p "Content here.">
>
format(card, 'html')

Vector Arithmetic

Scalar operations automatically broadcast over collections:

1 + [2, 3];          // [3, 4]       — scalar + array
[1, 2] * 2;          // [2, 4]       — array * scalar
[1, 2] + [3, 4];     // [4, 6]       — element-wise
[1, 2] ** 2;         // [1, 4]       — element-wise power
[1, 2, 3] eq 2       // [false, true, false] — element-wise comparison

Pipe Operator & Data Pipelines

The pipe operator |> enables fluent data transformations, and its filter stage |: keeps the items a test accepts. Use ~ to reference the current item:

let users = [{name: "Alice", age: 30}, {name: "Bob", age: 15}, {name: "Carol", age: 41}]

// Map: double each element
[1, 2, 3] |> ~ * 2;                  // [2, 4, 6]

// Extract fields
users |> ~.name;                     // ["Alice", "Bob", "Carol"]

// Filter with '|:'
[1, 2, 3, 4, 5] |: ~ > 3;            // [4, 5]

// Chain operations: filter → map → aggregate
users |: ~.age >= 18 |> ~.name |> len   // 2 — count adult names

For-Expressions with SQL-like Clauses

Powerful comprehensions with let, where, order by,group by, limit, offset:

// Filter and transform
for (x in data where x > 0) x * 2

// With local bindings
for (x in data, let sq = x * x where sq > 10) sq

// Sorting and pagination
for (x in items order by x.price desc limit 5) x.name

Rich Type System

// Type annotations
let x: int = 42
let items: string[] = ["a", "b"]

// Union and optional types
type Result = int | error
type Name = string?

// Element type patterns
type Link = <a href: string; string>
type Article = <article title: string; string, Section*>

// Function types
fn add(a: int, b: int) int => a + b

Pattern-based Matching & Query

Match expressions support value, range, type, and constrained patterns:

fn describe(x) => match x {
    case null:             "nothing"
    case 0:                "zero"              // literal value
    case 1 to 9:           "small number"      // range
    case int that ~ > 9:   "big number"        // type + constraint
    case string:           "text: " ++ ~       // type
    case int[]:            "int array"         // collection type
    default:               "something else"
}

The ? query operator searches data trees by type or structure, similar to jQuery:

html?<img>                    // all <img> descendants
html?<div class: string>      // <div>s with a class attribute
data?{status: "ok"}           // maps where status == "ok"
html[body][div]?<a>           // direct path then recursive search (given type body = <body>, type div = <div>)

Quick Start

Install From Source

1. Clone the repository:

   git clone https://github.com/henry-luo/lambda.git
   cd lambda
   

2. Install dependencies:

   ./setup-mac-deps.sh       # macOS
   ./setup-linux-deps.sh     # Linux
   ./setup-windows-deps.sh   # Windows (under MSYS2)
   

3. Build:

Lambda uses a Premake5-based build system generated from build_lambda_config.json.

make build             # Incremental build (recommended)
make release           # Optimized release build
make test              # Run unit test
make clean-all         # Clean build artifacts

CLI Commands

The build produces lambda.exe at the repo root; release bundles ship it as lambda.

lambda                                          # interactive REPL
lambda <script.ls>                              # run a functional script
lambda run <script.ls>                          # run a procedural script
lambda validate <file> [-s <schema.ls>]         # validate against a schema
lambda convert <input> -t <to> -o <output>      # format conversion
lambda layout <file.html>                       # print the CSS layout tree
lambda render <input> -o <output.svg|pdf|png>   # render to image
lambda view <file.html|file.md|file.ls|...>     # open in interactive viewer
lambda edit <file.md|file.html|file.svg>        # edit a document and save it back
lambda fetch <url> [-o file]                    # download a URL
lambda js <script.js>                           # run JavaScript on LambdaJS
lambda --help                                   # show help

Tip: lambda <command> --help prints detailed options and examples.

Examples

Document Processing

// Parse JSON and convert to Markdown (`^` propagates a read error)
let data = input("data.json", 'json')^
format(data, 'markdown')

// Process CSV data
let csv = input("data.csv", 'csv')^
for (row in csv where row.age > 25) row

Interactive CLI/REPL

λ> let data = input("sample.json", 'json')^
λ> len(data.users)
42
λ> for (u in data.users where u.active) u.name
("Alice", "Bob", "Charlie")

Benchmark Results

The latest run (Result50, 2026-09-30) covers 63 benchmarks across six standard suites (R7RS, AWFY, BENG, KOSTYA, LARCENY, JetStream) plus Text, against Node.js v22.13.0. Ratios are geometric means of JIT-pinned Lambda execution time divided by Node.js time; below 1.0× means Lambda is faster.

See the latest full benchmark report for per-benchmark details, memory profiling, and cross-engine comparisons.

Standards Conformance

Documentation

Language Reference

Developer Documentation

Platform Support

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

• MIR Project: JIT compilation infrastructure
• Tree-sitter: Incremental parsing framework
• ThorVG: SVG vector graphics library