Declare your logic.
Let Lumina react.

A statically typed, declarative, and reactive programming language for modeling complex state-driven systems. Define relationships, write rules the runtime handles the rest.

Download Lumina Read Docs
Lumina
security.lum 
entity SecuritySensor {
  is_armed: Boolean
  motion_detected: Boolean
  
  -- Derived: alert only if sensor is armed
  is_breached := is_armed and motion_detected
}

rule "Intrusion Alert"
when any SecuritySensor.is_breached becomes true {
  alert 
    severity: "critical",
    message: "Security Breach: {SecuritySensor.zone}",
    code: "SEC_001"
}
cooldown 1h
Core Principles

Built for correctness.
Designed for clarity.

Lumina inverts the control paradigm. Declare relationships, define constraints the runtime resolves everything deterministically.

Declarative

Define what your state should be, not how to get there. Derived fields (:=) maintain guaranteed relationships through topological evaluation using Kahn's algorithm.

Reactive

Rules fire on edge transitions via becomes. Temporal triggers handle duration-based logic with for and every. The DAG evaluation graph cascades state changes without divergent recursion.

Self-Healing

Before every state mutation, the runtime deep-copy snapshots memory. If an @range invariant is violated or recursion limit is breached, it rolls back instantly - guaranteed stable state.

Why Lumina?

Describe what is true.
Lumina figures out what to do.

Traditional languages make you write the plumbing. Lumina lets you declare intent.

Python

The Imperative Way

You write poll loops, threshold checks, state tracking, cooldown timers, and alerting logic. Every detail is your responsibility.

  • Manual polling for multi-zone security
  • Fragile alert-state dictionaries
  • Time-delta math for cooldown windows
  • No built-in auto-recovery logic
monitor.py 
def check_security(sensors):
    for id, s in sensors.items():
        if s.is_armed and s.motion and not s.alerted:
            if time.time() - s.last_alert > 3600:
                send_alert(f"Intrusion: {id}")
                s.alerted = True
                s.last_alert = time.time()
        elif not s.motion and s.alerted:
            send_clear(f"Zone Clear: {id}")
            s.alerted = False
Lumina

The Declarative Way

You describe the truth the engine handles edge detection, evaluation order, and alerting. No loops. No state tracking. No bugs.

  • Reactive fires on state transition
  • Self-healing with automatic rollback
  • Auto-clear when condition resolves
  • cooldown built into the language
Lumina
monitor.lum 
entity SecuritySensor {
  is_armed: Boolean
  motion_detected: Boolean
  is_breached := is_armed and motion_detected
}

rule "High Priority Breach"
when any SecuritySensor.is_breached becomes true {
  alert 
    severity: "critical",
    message: "Intrusion Detected!",
    code: "SEC_CRIT_001"
  on clear {
    show "Zone Secured"
  }
}
cooldown 1h
Under The Hood

A 5-stage pipeline
engineered in Rust.

Every Lumina program flows through a deterministic compiler pipeline with zero-cost abstractions and strict memory safety.

1

Lexer

High-throughput DFA tokenizer via the logos crate. Handles string interpolation mode-switching.

2

Parser

Hybrid recursive-descent & Pratt parsing with full operator precedence.

3

Module Loader

Resolves import statements with circular dependency detection and AST merging.

4

Analyzer

Dependency graph construction via Kahn's algorithm, static type safety, and @range invariant checks.

5

Runtime

Snapshot VM with state allocation, becomes edge detection, temporal scheduling, and self-healing rollback.

Ecosystem

Integrates everywhere
your systems run.

WebAssembly

Run Lumina programs directly in the browser via wasm-pack and wasm-bindgen.

VS Code Extension

Syntax highlighting, snippets, bracket matching, and LSP (v1.5) for .lum files.

Download VSIX

FFI: C / Python / Go

Stable C ABI via liblumina_ffi.so. Python wrapper via ctypes, Go wrapper via cgo.

External Adapters

MQTT, HTTP Poll, Rust Channel, File Watch, and Static adapters for real-world data sources.

Module System

Multi-file projects with import, dependency resolution, circular import detection, and AST merging.

Language Server (LSP)

Real-time diagnostics, hover tooltips, go-to-definition, completion, and document symbols.

Quick Start

Up and running
in seconds.

Installation

Choose your preferred way to install the Lumina binary.

>
PowerShell (Windows)
Lumina
> irm https://lumina.rw/install.ps1 | iex
$
Shell (macOS)
Lumina
$ curl -fsSL https://lumina.rw/install.sh | sh
$
Shell (Linux)
Lumina
$ curl -fsSL https://lumina.rw/install.sh | sh

Quick Start

Create a hello.lum file and execute it instantly.

Lumina hello.lum
entity App { name: Text }
let app = App { name: "Lumina" }
show "Hello, {app.name}!"
Lumina Terminal
$ lumina run hello.lum
Hello, Lumina!