Simple Language

🎉 Production Ready (2026-02-14) - 100% test pass rate (4,067/4,067), all critical features complete. Read the announcement

A statically typed programming language with Python-like syntax, modern safety features, and GPU computing support.

Production Ready

Simple Language Compiler v1.0 achieved production ready status on February 14, 2026.

Test Results:

Results: 4,067 total, 4,067 passed, 0 failed
Time:    17.4 seconds
Status:  ✅ Production Ready

What's Complete:

✅ Package Management - Full SemVer, manifest, lockfile support
✅ Effect System - Type-level effect tracking (@pure, @io, @net, @fs, @unsafe, @async)
✅ Parser Error Recovery - Multi-language syntax mistake detection
✅ Platform Abstraction - Cross-platform support (Linux, macOS, Windows)
✅ Process Management - Sync and async execution
✅ File I/O - Text, binary, directory operations
✅ Comprehensive Testing - 4,067 tests, 100% pass rate

Documentation:

AGENTS.md / CLAUDE.md - Development guide, agent definitions
Release Notes - Complete release information
Production Summary - Quick reference
Test Results - Detailed test analysis

Key Features

Self-Hosting Build System - Complete build system written in Simple itself
Python-like syntax - Indentation-based blocks, clean readable code
Static typing with inference - Type safety without verbosity (Hindley-Milner)
Unit types - Type-safe postfix literals (10_cm, 200_kmph, 42_uid)
Multiple memory modes - GC-managed (default), manual, or reference-counted
Actor-based concurrency - Safe concurrent programming with async/await
GPU computing - Cross-platform Vulkan backend with this.index() / gpu.global_id()
Pattern matching - Exhaustiveness checking with strong enums
Contracts - Pre/postconditions, invariants (DbC - Design by Contract)
Parser-friendly macros - Contract-first LL(1) macros with IDE support
AOP & Unified Predicates - Aspect-oriented programming, DI, mocking, architecture rules
SDN configuration - Simple Data Notation for human-readable config files
Doctest - Executable examples in docstrings (>>> prompt style)
BDD Feature Docs - Living documentation generated from passing tests
SMF binary format - Compile once, run anywhere

Quick Start

Installation from Binary (Recommended)

Download the pre-compiled release for your platform - no build required!

What you get:

Pre-compiled runtime (10 MB optimized binary)
Complete Simple compiler (100% Simple source code)
Standard library (100% Simple)
All development tools (MCP server, LSP, debugger - all in Simple)

Available platforms:

Linux x86_64 / ARM64
macOS x86_64 / ARM64
Windows x86_64 / ARM64

# Linux x86_64
wget https://github.com/simple-lang/simple/releases/download/v0.6.1/simple-0.6.1-linux-x86_64.tar.gz
tar -xzf simple-0.6.1-linux-x86_64.tar.gz
cd simple-0.6.1
export PATH="$PWD/bin:$PATH"
simple --version

# macOS ARM64 (Apple Silicon)
curl -LO https://github.com/simple-lang/simple/releases/download/v0.6.1/simple-0.6.1-darwin-aarch64.tar.gz
tar -xzf simple-0.6.1-darwin-aarch64.tar.gz
cd simple-0.6.1
export PATH="$PWD/bin:$PATH"
simple --version

# Windows x86_64 (PowerShell)
Invoke-WebRequest -Uri https://github.com/simple-lang/simple/releases/download/v0.6.1/simple-0.6.1-windows-x86_64.zip -OutFile simple.zip
Expand-Archive simple.zip
cd simple-0.6.1
$env:PATH = "$PWD\bin;$env:PATH"
simple --version

Note: The runtime is pre-compiled for performance, but the entire language implementation (compiler, stdlib, tools) is in Simple source code that you can read and modify!

From Source (Developers Only)

Only needed if you want to modify the runtime:

git clone https://github.com/simple-lang/simple.git
cd simple

# Linux bootstrap verification
scripts/bootstrap/bootstrap-from-scratch.sh --output=bootstrap

Direct commands behind the wrapper:

src/compiler_rust/target/bootstrap/simple --version
bin/release/simple build bootstrap
sha256sum bootstrap/simple_stage2 bootstrap/simple_stage3

See doc/build/bootstrap_multi_platform.md and plan_codex_bootstrap.md for the current bootstrap flow.

Build with GPU Support

simple build --release --features=vulkan

Your First Program

# hello.spl
>>> fn main() -> i64:
...     0  # Entry point, returns exit code

# Run it
simple hello.spl
echo $?  # Prints: 0

CLI Usage

The simple command works like Python:

Usage:
  simple                      Start interactive REPL
  simple <file.spl>           Run source file
  simple <file.smf>           Run compiled binary
  simple -c "code"            Run code string
  simple compile <src> [-o <out>]  Compile to SMF
  simple watch <file.spl>     Watch and auto-recompile

Build System (Self-Hosting):
  simple build                Build the project (debug)
  simple build --release      Release build (optimized)
  simple build --bootstrap    Bootstrap build (minimal 9.3MB)
  simple build test           Run all tests
  simple build coverage       Generate coverage reports
  simple build lint           Run linter (clippy)
  simple build fmt            Format code (rustfmt)
  simple build check          Run all quality checks
  simple build clean          Clean build artifacts
  simple build --help         Show all build options

Options:
  -h, --help     Show help
  -v, --version  Show version
  -c <code>      Run code string
  --gc-log       Enable verbose GC logging
  --gc=off       Disable garbage collection

Examples

# Interactive REPL
simple
>>> 1 + 2
3
>>> x = 10
>>> x * 5
50
>>> exit

# Run a program
echo "main = 42" > hello.spl
simple hello.spl
echo $?  # Exit code: 42

# Compile to binary
simple compile hello.spl
simple hello.smf  # Run the compiled binary

# Watch mode (auto-recompile on changes)
simple watch app.spl

Language Basics

Variables & Types

# Variables - immutable by default, mutable with var
>>> x = 10
>>> x
10
>>> var y = 20
>>> y
20
>>> PI = 3.14159
>>> PI
3.14159

# Type inference works automatically
>>> count = 100
>>> count
100

# Basic types inferred
>>> a = 42
>>> a
42
>>> pi = 3.14159
>>> flag = true
>>> flag
true

# String interpolation default
>>> name = "world"
>>> msg = "Hello, {name}!"
>>> print msg
Hello, world!

Control Flow

# If/else with indentation
>>> var x = 5
>>> if x > 0:
...     print "positive"
... elif x < 0:
...     print "negative"
... else:
...     print "zero"
positive

# Loops
>>> for i in 0..3:
...     print i
0
1
2

>>> while x > 3:
...     x = x - 1
>>> x
3

Functions

>>> fn add(a: i64, b: i64) -> i64:
...     a + b  # Implicit return

>>> fn greet(greeting: text):
...     print "Hello, {greeting}!"

# Function calls
>>> sum = add(1, 2)
>>> sum
3
>>> greet("Alice")
Hello, Alice!

# Lambdas with backslash
>>> double = \x: x * 2
>>> nums = [1, 2, 3, 4, 5]
>>> evens = nums.filter(\x: x % 2 == 0)
>>> evens
[2, 4]

Structs & Classes

# Structs (value types)
struct Point:
    x: f64
    y: f64

p = Point(x: 1.0, y: 2.0)

# Classes (reference types)
class Person:
    name: text
    age: i64

    fn greet():
        print "Hi, {self.name}!"

alice = Person(name: "Alice", age: 30)
alice.greet()

Collections

# Arrays - short form (no val)
>>> nums = [1, 2, 3, 4, 5]
>>> first = nums[0]
>>> first
1

# Collection methods
>>> count = nums.len()
>>> count
5

# Dictionary (short form)
>>> scores = {"alice": 100, "bob": 85}
>>> alice_score = scores["alice"]
>>> alice_score
100

# Filter with lambda
>>> odds = nums.filter(\x: x % 2 == 1)
>>> odds
[1, 3, 5]
>>> big_nums = nums.filter(\x: x > 3)
>>> big_nums
[4, 5]

# Tuples
>>> pair = (1, "hello")
>>> num = pair.0
>>> num
1
>>> msg = pair.1
>>> msg
"hello"

# List comprehensions
>>> squared = [x * x for x in 0..5]
>>> squared
[0, 1, 4, 9, 16]
>>> evens = [x for x in nums if x % 2 == 0]
>>> evens
[2, 4]

Unit Types (Postfix Literals)

Type-safe units prevent mixing incompatible values:

# Define unit types with postfix syntax
unit length(base: f64):
    mm = 0.001, cm = 0.01, m = 1.0, km = 1000.0

unit velocity(base: f64) = length / time:
    mps = 1.0, kmph = 0.277778, mph = 0.44704

unit UserId: i64 as uid
unit OrderId: i64 as oid

# Usage with postfix literals
height = 175_cm              # Length type
width = 10_cm + 5_mm         # Auto-converts to same base
speed = 200_kmph             # Velocity type
distance = 42_km             # Length type

# Type safety - compile error:
# bad = height + speed       # Error: can't add Length + Velocity

# Semantic IDs prevent mix-ups
user = 42_uid                # UserId
order = 100_oid              # OrderId
# wrong: UserId = 100_oid    # Error: OrderId ≠ UserId

# Computed units
travel_time = distance / speed    # Returns Time type
print("ETA: {travel_time.to_min()} minutes")

Pattern Matching

enum Shape:
    Circle(radius: f64)
    Rectangle(width: f64, height: f64)
    Square(side: f64)
    Triangle(base: f64, height: f64)

# Pattern matching with case syntax
fn area(s: Shape) -> f64:
    match s:
        case Circle(r):
            3.14159 * r * r  # Implicit return
        case Rectangle(w, h):
            w * h
        case Square(side):
            side * side
        case Triangle(b, h):
            0.5 * b * h

# Preferred arrow syntax (shorter)
fn perimeter(s: Shape) -> f64:
    match s:
        | Circle(r) -> 2.0 * 3.14159 * r
        | Rectangle(w, h) -> 2.0 * (w + h)
        | Square(side) -> 4.0 * side
        | Triangle(a, b, c) -> a + b + c

# Pattern matching with nil (not None)
fn get_radius(opt: Option<f64>) -> f64:
    match opt:
        | Some(r) -> r
        | nil -> 0.0  # Use nil instead of None

Parser-Friendly Macros

Simple macros are contract-first and LL(1) parseable - the IDE can provide autocomplete without expanding the macro:

# Macro declares what it introduces in the contract header
macro define_counter(NAME: Str const) -> (
  returns result: (init: Int, step: Int),
  intro counter_fn: enclosing.class.fn "{NAME}Counter"(start: Int) -> Int
):
  const_eval:
    const init = 0
    const step = 1

  emit counter_fn:
    fn "{NAME}Counter"(start: Int) -> Int:
      start + step

# Usage - IDE knows about UserCounter before expansion
class Demo:
  define_counter!("User")

  fn run() -> Int:
    self.UserCounter(10)  # Autocomplete works!

Built-in macros:

# Print with formatting
println!("Hello, {name}!")           # Print with newline
print!("Value: {x}")                 # Print without newline

# Debug output with source location
dbg!(expression)                     # Prints: [file:line] expression = value

# Assertions
assert!(condition)                   # Panic if false
assert_eq!(a, b)                     # Panic if a != b
assert_ne!(a, b)                     # Panic if a == b

# Collections
nums = vec![1, 2, 3, 4, 5]           # Create vector
formatted = format!("x={x}")         # Format string without printing

# Panic with message
panic!("Something went wrong: {err}")

Const-unrolled macro (generate multiple functions):

# Generate accessor functions for each axis
macro gen_axes(BASE: Str const, N: Int const) -> (
  intro axes:
    for i in 0 .. N:
      enclosing.class.fn "{BASE}{i}"(v: Vec[N]) -> Int
):
  emit axes:
    for i in 0 .. N:
      fn "{BASE}{i}"(v: Vec[N]) -> Int:
        v[i]

# Usage: generates x(), y(), z() accessors
class Point3D:
  gen_axes!("axis_", 3)  # Creates axis_0, axis_1, axis_2

AOP & Aspect-Oriented Programming

Unified predicate grammar for cross-cutting concerns:

# Pointcut expression syntax: pc{...}
# Applies logging to all service methods
on pc{ execution(services.**.*(..)) } use LoggingInterceptor

# Architecture rules - enforce layer dependencies
forbid pc{ hal.** } -> pc{ services.** }  # HAL cannot depend on services
allow  pc{ services.** } -> pc{ hal.** }  # Services can use HAL

# Dependency Injection with predicates
bind on pc{ attr(Repository) } -> PostgresRepository
  when profile("prod")

bind on pc{ attr(Repository) } -> MockRepository
  when profile("test")

SDN Configuration

Simple Data Notation - a minimal, token-efficient format for config files:

# app.sdn - Application configuration
app:
    name: MyService
    version: 2.1.0

server:
    host: 0.0.0.0
    port: 8080
    workers: 4

# Inline arrays and dicts
features = [auth, logging, metrics]
database = {driver: postgres, host: localhost, port: 5432}

# Named tables - compact tabular data
rate_limits |endpoint, requests, window|
    /api/login, 5, 60
    /api/search, 100, 60
    /api/upload, 10, 300

Load SDN in Simple:

config = sdn::load("app.sdn")
print("Server port: {config.server.port}")

Doctest

Executable examples in docstrings — tests that serve as documentation:

## Computes factorial of n
##
## Example: factorial(5) returns 120
## Example: factorial(0) returns 1
fn factorial(n: i64) -> i64:
    if n <= 1: return 1
    n * factorial(n - 1)

print factorial(5)   # 120
print factorial(0)   # 1

Data structures with doc comments:

## Stack data structure with LIFO semantics
##
## Usage:
##     var s = Stack(items: [])
##     s.items.push(1)
##     s.items.push(2)
##     print s.items.len()  # 2
struct Stack:
    items: [i64]

var s = Stack(items: [])
s.items.push(1)
s.items.push(2)
s.items.push(3)
print s.items.len()  # 3

Planned interactive doctest syntax (under development):

# Future syntax — not yet implemented:
"""
>>> factorial(5)
120
>>> generate_uuid()
"........-....-....-....-............"
"""

Run doctests:

simple doctest src/math.spl      # Run doctests in file
simple doctest doc/tutorial.md   # Run doctests in markdown
simple test --doctest            # Run all doctests
simple test --doctest --tag slow # Run only slow-tagged doctests

Functional Update Operator (`->`)

# The -> operator calls a method and assigns result back
var data = load_data()
data->normalize()        # data = data.normalize()
data->filter(min: 0)     # data = data.filter(min: 0)

# Chaining
data->normalize()->filter(min: 0)->save("out.txt")

GPU Computing

import std.gpu

# GPU kernel style 1: #[gpu] with explicit bounds check
#[gpu]
fn vector_add_kernel(a: []f32, b: []f32, result: []f32):
    idx = gpu.global_id(0)           # Global thread index
    if idx < len(result):
        result[idx] = a[idx] + b[idx]

# GPU kernel style 2: @simd with auto bounds handling
@simd
fn vector_scale(data: []f32, scale: f32):
    val i = this.index()             # Global linear index (same as gpu.global_id())
    data[i] = data[i] * scale        # Bounds auto-handled

# Host function - runs on CPU
fn main():
    device = gpu.Device()

    # Allocate and upload data
    a = [1.0, 2.0, 3.0, 4.0]
    b = [5.0, 6.0, 7.0, 8.0]

    buf_a = device.alloc_buffer(a)
    buf_b = device.alloc_buffer(b)
    buf_result = device.alloc_buffer<f32>(4)

    # Launch kernel
    device.launch_1d(vector_add_kernel, [buf_a, buf_b, buf_result], 4)

    # Download results
    device.sync()
    result = device.download(buf_result)
    # result = [6.0, 8.0, 10.0, 12.0]

GPU Thread Indexers:

#[gpu]
fn matrix_multiply(A: []f32, B: []f32, C: []f32, N: u32):
    # Multi-dimensional indexing
    val row = gpu.global_id(0)       # First dimension
    val col = gpu.global_id(1)       # Second dimension

    # Thread group (workgroup) info
    val local_row = gpu.local_id(0)  # Index within workgroup
    val group_row = gpu.group_id(0)  # Workgroup index

    # Alternative @simd style
    # val(row, col) = this.index()  # Tuple for 2D
    # vallocal_idx = this.thread_index()
    # valgroup_idx = this.group_index()

    if row < N and col < N:
        var sum = 0.0_f32
        for k in 0..N:
            sum += A[row * N + k] * B[k * N + col]
        C[row * N + col] = sum

GPU Examples: See examples/gpu/vulkan/ for vector add, matrix multiply, reduction, and image blur.

Documentation

Quick Links by Topic

Topic	Description	Link
Language Spec	Complete language specification	doc/spec/README.md
Grammar	Parser grammar and syntax rules	doc/spec/parser/
Guides	Practical how-to guides	doc/guides/README.md
Plans	Implementation roadmap	doc/plans/README.md
Research	Design explorations	doc/research/README.md
Architecture	System design principles	doc/architecture/
Features	Feature catalog	doc/features/feature.md
Status	Implementation tracking	doc/status/
Deep Learning	Neural networks & GPU computing	doc/guide/deep_learning_guide.md

Core Documentation

Getting Started:

Language Specification Index - Complete spec organized by topic
Syntax Specification - Lexical structure, literals, operators
Type System - Type system, mutability, inference
Test Policy - Testing framework and best practices

Language Reference:

Core Language - Syntax, types, data structures, functions
Advanced Features - Concurrency, macros, contracts
Standard Library - Standard library specification

GPU Computing:

Deep Learning Guide - Comprehensive DL guide (Pure Simple, PyTorch, CUDA)
Vulkan User Guide - Getting started with GPU kernels
GPU & SIMD Spec - GPU compute and SIMD specification
Vulkan Architecture - Implementation details

Development:

Module System - Import/export, packages, init.spl
Testing Framework - BDD testing with matchers
Build System - Building and testing Simple projects

Advanced Features:

Macro System - Contract-first LL(1) macros
AOP & Unified Predicates - Aspect-oriented programming
SDN Format - Simple Data Notation specification
Doctest - Documentation testing
Feature Documentation - BDD-generated feature docs

Examples

Deep Learning Examples

Simple provides 17 deep learning examples across 4 categories:

Pure Simple Neural Networks (7 examples - 100% working):

# XOR neural network training
bin/simple examples/pure_nn/xor_training_example.spl

# Linear regression (learns y = 2x + 1)
bin/simple examples/pure_nn/simple_regression.spl

# Iris flower classification
bin/simple examples/pure_nn/iris_classification.spl

MedGemma Korean Fine-Tuning (3 phases - 100% working):

# Progressive LoRA training to prevent catastrophic forgetting
bin/simple examples/medgemma_korean/run_all.spl

CUDA Programming (1 example - 100% working):

# Direct CUDA C API - multi-GPU, streams, events
bin/simple examples/cuda/basic.spl

See Deep Learning Guide for complete documentation.

Other Examples

The examples/ directory contains additional working examples:

Example	Description
`cli_demo.spl`	Command-line argument parsing
`file_async_basic.spl`	Async file I/O operations
`ui_todo_app.spl`	Cross-platform UI application
`vulkan_triangle.spl`	GPU rendering with Vulkan
`async_tcp_echo_server.spl`	Async TCP networking

Run an example:

bin/simple examples/cli_demo.spl

BDD Feature Documentation

Feature documentation is auto-generated from BDD spec tests. Each spec defines feature metadata and executable assertions that verify the feature works correctly.

# simple/std_lib/test/features/infrastructure/lexer_spec.spl
import std.spec

feature "Lexer":
    """
    The lexer tokenizes Simple source code into tokens.
    Feature ID: #1
    Category: infrastructure
    """

    scenario "tokenizes keywords":
        given "source code with keywords"
        when "the lexer processes it"
        then "it produces keyword tokens"
        expect tokenize("fn main") to contain Token(Keyword, "fn")

    scenario "handles indentation":
        given "indented code blocks"
        when "the lexer processes it"
        then "it emits INDENT and DEDENT tokens"

Run feature tests:

# Run a specific feature spec
./target/debug/simple simple/std_lib/test/features/infrastructure/lexer_spec.spl

# Generate documentation from tests
./target/debug/simple simple/std_lib/test/features/generate_docs.spl

Generated docs appear in doc/features/{category}/ folders with living documentation that stays in sync with the implementation.

Grammar & Specification

Language Grammar

The Simple language grammar is formally specified in the parser documentation:

Grammar Documents:

Parser Overview - Parser architecture and design
Grammar Definitions - Top-level definitions
Grammar Expressions - Expression grammar
Lexer & Scanner - Tokenization rules
Complete Grammar - Full BNF-style grammar

Quick Grammar Reference:

# Top-level
program ::= statement*

# Statements
statement ::= function_def | class_def | struct_def | enum_def
            | import_stmt | export_stmt | expr_stmt

# Expressions (Pratt parser)
expr ::= literal | identifier | binary_op | unary_op
       | call | index | field_access | lambda
       | if_expr | match_expr | block

# Types
type ::= identifier | array_type | tuple_type | fn_type
       | optional_type | result_type | generic_type

# Literals
literal ::= integer | float | string | bool | array | dict | tuple

Specification Index

The complete language specification is organized in doc/spec/:

Core Language (9 specs):

Syntax - Lexical structure, operators
Types - Type system, mutability
Data Structures - Structs, classes, enums
Functions - Functions, pattern matching
Traits - Traits and implementations
Memory - Ownership, borrowing
Modules - Import/export system
Units - Semantic unit types
Primitive as Object - Primitive methods

Advanced Features (8 specs):

Concurrency - Actors, async/await
Metaprogramming - Macros, decorators
Macro System - Advanced macros
Contracts - Pre/postconditions
Capability Effects - Reference capabilities
FFI & ABI - Foreign function interface
Standard Library - Stdlib organization
File I/O - File operations

Testing & Tooling:

BDD Testing - BDD framework, matchers
Formatter - Code formatting
Linting - Linter rules

GPU & Graphics:

GPU & SIMD - GPU compute specification
3D Graphics - 3D rendering

See doc/spec/README.md for the complete specification index with status indicators.

Project Structure

simple/
├── bin/                      # CLI entry points
│   ├── simple               # Main CLI (shell wrapper)
│   └── release/             # Pre-built release binaries
│       └── simple           # Pre-built runtime (33 MB)
│
├── src/                      # Simple source code (100% Simple)
│   ├── app/                  # Applications
│   │   ├── cli/             # Main CLI dispatcher
│   │   ├── build/           # Self-hosting build system
│   │   ├── mcp/             # MCP server (Model Context Protocol)
│   │   ├── lsp/             # Language server protocol
│   │   ├── io/              # SFFI wrappers (file, process, etc.)
│   │   └── ...              # 50+ tool modules
│   ├── lib/                  # Libraries
│   │   ├── database/        # Unified database (BugDB, TestDB, etc.)
│   │   └── pure/            # Pure Simple DL (tensor, autograd, nn)
│   ├── std/                  # Standard library
│   │   ├── src/             # Library source
│   │   └── test/            # Library tests
│   └── compiler/             # Compiler infrastructure
│       ├── backend/         # Code generation
│       ├── inference/       # Type inference
│       └── parser/          # Parser and treesitter
│
├── examples/                 # Example programs
│   ├── pure_nn/             # Deep learning examples
│   └── gpu/vulkan/          # GPU computing examples
│
├── test/                     # Test suites
│   ├── integration/         # Integration tests
│   ├── system/              # System tests
│   └── intensive/           # Intensive feature tests
│
├── doc/                      # Documentation
│   ├── spec/                # Language specifications
│   ├── guide/               # User guides
│   ├── design/              # Design documents
│   └── report/              # Session reports
│
└── verification/             # Lean 4 formal verification

Development

Building

# Debug build
simple build

# Release build
simple build --release

# With GPU support
simple build --release --features=vulkan

# Bootstrap build (minimal 9.3MB)
simple build --bootstrap

Testing

Production Ready Test Suite: 4,067/4,067 passing (100%)

Simple uses a comprehensive test strategy with 100% pass rate:

# All tests (4,067 tests in 17.4 seconds)
simple test

# Run specific test file
simple test path/to/spec.spl

# With verbose output
simple test --verbose

# Coverage reports
simple build coverage

Test Coverage:

Core interpreter: 227 tests
Compiler: 306 tests
Standard library: 428 tests
Applications: 142 tests
Libraries (ML, Physics, Game): 185 tests
Integration & Coverage: 2,779 tests

Performance:

Total execution: 17.4 seconds
Average per test: 4.3ms
All tests deterministic and fast

See doc/session/full_test_suite_results_2026-02-14.md for detailed test analysis.

Code Quality

# Check before commit (fmt + lint + test)
simple build check

# Full check (includes coverage + duplication)
simple build check --full

# Format code
simple build fmt

# Lint
simple build lint

AI Tooling (MCP, LSP, Plugin)

Simple ships with MCP servers, LSP servers, and Claude Code plugins — all written in Simple.

Install Simple MCP Server

The Simple MCP server currently exposes 68 tools for code diagnostics, VCS, build, test, debug, and more, plus 3 resources and 2 prompts.

# From a repo checkout — register with Claude Code
claude mcp add simple-mcp -- \
  /absolute/path/to/simple/bin/release/simple \
  /absolute/path/to/simple/src/app/mcp/main.spl

# Or use the project .mcp.json (auto-detected by Claude Code)
sh config/mcp/install.shs

Install Simple MCP Plugin

The simple-mcp Claude plugin is a repo-checkout plugin. Install it from a Simple repository checkout; it is not a standalone portable runtime bundle.

claude plugin marketplace add tools/claude-plugin/marketplace
claude plugin install simple-mcp@simple-local

The plugin launches bin/simple_mcp_server from the repository root.

Install Simple LSP Plugin

The Simple language server provides completions, hover, go-to-definition, diagnostics, and semantic tokens for .spl / .shs files.

# From a repo checkout
claude plugin marketplace add tools/claude-plugin/marketplace
claude plugin install simple-lsp@simple-local

Binary full path: bin/release/simple run src/app/lsp/main.spl

Install Both (Quick Setup)

cd /path/to/simple

# 1. MCP server
sh config/mcp/install.shs

# 2. LSP plugin
claude plugin marketplace add tools/claude-plugin/marketplace
claude plugin install simple-lsp@simple-local

Prompt Examples

Once the MCP server and LSP plugin are installed, try these prompts in Claude Code:

> "Run the linter on src/app/cli/main.spl and fix any warnings"

> "Show me all unused variables in the compiler frontend"

> "Run the unit tests for the SDN parser"

> "Build the project in release mode and show the result"

> "What does the function `parse_expression` in the parser do?"

> "Find all TODO items in the codebase"

> "Check the doc coverage for the standard library"

> "Debug why test/unit/lib/common/value_spec.spl is failing"

TRACE32 Tools

MCP servers, CMM language server, and CLI tools for Lauterbach TRACE32 debuggers. See examples/10_tooling/trace32_tools/README.md for full documentation.

Install T32 MCP Servers

cd /path/to/simple

# T32 MCP — controls live TRACE32 debug sessions (23 tools)
claude mcp add t32-mcp -- \
  /absolute/path/to/simple/bin/release/simple \
  /absolute/path/to/simple/examples/10_tooling/trace32_tools/t32_mcp/main.spl

# T32 LSP MCP — CMM script analysis, no hardware needed (6 tools)
claude mcp add t32-lsp-mcp -- \
  /absolute/path/to/simple/bin/release/simple \
  /absolute/path/to/simple/examples/10_tooling/trace32_tools/t32_lsp_mcp/main.spl

Binary full paths:

T32 MCP: bin/release/simple examples/10_tooling/trace32_tools/t32_mcp/main.spl
T32 LSP MCP: bin/release/simple examples/10_tooling/trace32_tools/t32_lsp_mcp/main.spl

Install CMM LSP Plugin

claude plugin marketplace add tools/claude-plugin/marketplace
claude plugin install cmm-lsp@simple-local

Binary full path: bin/release/simple examples/10_tooling/trace32_tools/cmm_lsp/mod.spl --lsp

T32 Prompt Examples

> "Parse this CMM script and check for errors: config/t32/stm32h7_gdb_start.cmm"

> "Connect to TRACE32 on localhost:20000 and read the CPU registers"

> "Show me all labels and macros defined in my CMM script"

> "Convert this GUI PRACTICE script to CLI batch mode"

> "Check if my CMM script has any undefined macros or unreachable code"

> "Set a breakpoint at main, run to it, and show local variables"

> "What TRACE32 commands are available for memory access?"

> "Auto-complete suggestions for 'Data.LOAD' in my CMM script"

Contributing

See CLAUDE.md for development guidelines and AGENTS.md for AI agent instructions.

Documentation Structure:

Specifications go in doc/spec/ (what the language supports)
Guides go in doc/guides/ (how to use features)
Research goes in doc/research/ (why/how decisions were made)
Plans go in doc/plans/ (implementation roadmaps)
Reports go in doc/report/ (session summaries, completion reports)

License

MIT License

Resources

Official Documentation:

Language Specification - Complete spec index
Grammar Reference - Parser grammar
User Guides - Practical tutorials

Quick References:

Development:

Name		Name	Last commit message	Last commit date
Latest commit History 2,319 Commits
.agents/skills		.agents/skills
.claude		.claude
.codex		.codex
.gemini		.gemini
.git-rewrite		.git-rewrite
.github/workflows		.github/workflows
.tmp_codex		.tmp_codex
bin		bin
config		config
doc		doc
docs		docs
examples		examples
resources/boards		resources/boards
scripts		scripts
src		src
test		test
tools		tools
.dockerignore		.dockerignore
.envrc		.envrc
.gitattributes		.gitattributes
.gitignore		.gitignore
.gitmodules		.gitmodules
.jjignore		.jjignore
.jscpd.json		.jscpd.json
.mcp.json		.mcp.json
AGENTS.md		AGENTS.md
CHANGELOG.md		CHANGELOG.md
CLAUDE.md		CLAUDE.md
DO_NOT_MAKE_OTHER_MAIN.md		DO_NOT_MAKE_OTHER_MAIN.md
FILE.md		FILE.md
GEMINI.md		GEMINI.md
MCP.md		MCP.md
PLAN.md		PLAN.md
README.md		README.md
VERSION		VERSION
cc6OpDE1.cdtor.c		cc6OpDE1.cdtor.c
cc8JONBU.res		cc8JONBU.res
gemini-extension.json		gemini-extension.json
install.sh		install.sh
simple.sdn		simple.sdn

Folders and files

Latest commit

History

Repository files navigation

Simple Language

Production Ready

Key Features

Quick Start

Installation from Binary (Recommended)

From Source (Developers Only)

Build with GPU Support

Your First Program

CLI Usage

Examples

Language Basics

Variables & Types

Control Flow

Functions

Structs & Classes

Collections

Unit Types (Postfix Literals)

Pattern Matching

Parser-Friendly Macros

AOP & Aspect-Oriented Programming

SDN Configuration

Doctest

Functional Update Operator (->)

GPU Computing

Documentation

Quick Links by Topic

Core Documentation

Examples

Deep Learning Examples

Other Examples

BDD Feature Documentation

Grammar & Specification

Language Grammar

Specification Index

Project Structure

Development

Building

Testing

Code Quality

AI Tooling (MCP, LSP, Plugin)

Install Simple MCP Server

Install Simple MCP Plugin

Install Simple LSP Plugin

Install Both (Quick Setup)

Prompt Examples

TRACE32 Tools

Install T32 MCP Servers

Install CMM LSP Plugin

T32 Prompt Examples

Contributing

License

Resources

About

Topics

Resources

Uh oh!

Stars

Watchers

Forks

Releases 7

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Functional Update Operator (`->`)

Packages