{
  "markdown": "# Simple Language\n\n[![Production Ready](https://img.shields.io/badge/status-production%20ready-brightgreen)](doc/archive/release/PRODUCTION_READY_SUMMARY.md)\n[![Tests](https://img.shields.io/badge/tests-4067%2F4067%20passing-brightgreen)](doc/09_report/session/full_test_suite_results_2026-02-14.md)\n[![LLVM Cross](https://github.com/ormastes/simple/actions/workflows/simple-llvm-cross.yml/badge.svg)](.github/workflows/simple-llvm-cross.yml)\n[![License](https://img.shields.io/badge/license-Apache_2.0-blue.svg)](LICENSE)\n\nSimple is a self-hosted language and toolchain that combines a readable Python-like surface with compiler-integrated testing, documentation, architecture rules, and baremetal-oriented execution paths.\n\nThe repo is unusually broad: language, compiler, interpreter, loader, test runner, doc generation, traceability tooling, SDN-backed project databases, editor tooling, and hardware-oriented test flows all live together.\n\n**Quick Navigation:** [Distinctive Features](#distinctive-features) | [Feature Status](#feature-status-highlights) | [Quick Start](#quick-start) | [Language Basics](#language-basics) | [Examples](#examples) | [Editor Plugins](#editor-plugins) | [Documentation](#documentation)\n\n---\n\n## Distinctive Features\n\n- **Self-hosted staged toolchain**: real source layers for frontend, type analysis, borrow checking, backend, driver, interpreter, and loader live in-tree.\n- **Verification-native workflow**: SSpec tests, the SPipe runner/docgen process, SDoctest executable docs, coverage, traceability checks, and generated spec docs are part of the toolchain rather than bolted on.\n- **MDSOC architecture support**: virtual capsules, manifests, and architecture-aware repository structure are first-class concepts.\n- **Parser-friendly macro system**: macro definitions, expansion, validation, and hygiene are compiler features rather than editor-hostile text substitution.\n- **Math-oriented syntax blocks**: `m{}`, `loss{}`, and `nograd{}` are implemented syntax with parsing, evaluation, five rendering backends (text, debug, Unicode, LaTeX, Markdown), and editor integration (query/LSP hover, VSCode highlighting/preview, Neovim inline Unicode preview with conceal). The autograd path is complete for the promoted torch-backed C/LLVM scope.\n- **SDN-backed textual databases**: tests, todos, dashboards, and other project metadata are stored through repo-native SDN data flows.\n- **Multiple execution paths**: interpreter, loader, SMF/module loading, and native/LLVM-oriented compilation paths coexist in one system.\n- **Baremetal-oriented build and test plumbing**: QEMU, semihosting, MMIO mailbox, remote baremetal flows, and adapter-backed hardware lanes (8 authoritative) are built into the repo story.\n- **Tooling-aware language rules**: Tree-sitter integration, primitive-public-API linting, traceability tooling, and language statistics are part of the platform.\n- **Shared UI contract across supported surfaces**: one HTTP-based test protocol (Protocol V1) with `UITestClient` drives both the web backend and the TUI-web proxy through a shared `handle_test_request` handler, verified by a cross-surface contract suite. Contract: [doc/04_architecture/shared_ui_contract.md](doc/04_architecture/shared_ui_contract.md)\n\n## Feature Status Highlights\n\nImplemented and safe to advertise:\n- SSpec tests, SPipe runner/docgen, SDoctest, coverage, traceability checks, and generated spec docs\n- SPipe mock policy: system-test mock ban, HAL-only and custom pattern modes\n- Self-hosted staged compiler, interpreter, and loader architecture\n- MDSOC manifests and architecture-focused project structure\n- Parser-friendly macros with validation and hygiene\n- Tree-sitter outline/query tooling\n- SDN-backed project, test, and todo databases\n- Primitive-public-API linting and semantic wrapper/unit-type patterns\n- Borrow-checking infrastructure\n- Watch mode and auto-build support\n- mmap-backed loader support and executable-memory plumbing\n- Baremetal build/test plumbing and host-aware remote baremetal flows\n- C/C++ bidirectional SFFI for the supported ABI subset: exports, imports, callback trampolines, layout verification, and round-trip proof tests\n\nImplemented, but best described with qualifiers:\n- LLVM full-family closure is complete for the declared public matrix: every `llvm-lib` and `llvm` backend row is now explicitly `stable` or `unsupported`, with no ambiguous middle states. `rust-llvm` remains a bootstrap-only seed path outside the public family claim\n- Lean verification workflow is complete for the supported verification subset: deterministic Lean generation, proof artifact inventory, Lean/Lake checking, cache invalidation, and verification-state reporting. Contract: [doc/04_architecture/lean_verification_contract.md](doc/04_architecture/lean_verification_contract.md). Report: [doc/09_report/lean_verification_complete_2026-04-04.md](doc/09_report/lean_verification_complete_2026-04-04.md)\n- GC and no-GC runtime families: 5 public families (`common`, `nogc_sync_mut`, `nogc_async_mut`, `gc_async_mut`, `nogc_async_mut_noalloc`) with compiler boundary enforcement, interpreter warnings, and target preset mapping. Support matrix: [doc/04_architecture/runtime_family_support_matrix.md](doc/04_architecture/runtime_family_support_matrix.md)\n- Shared UI contract across web backend and TUI-web proxy (Protocol V1): shared handler, structured error model, stable element IDs, cross-surface contract suite — but this is a shared test protocol, not a full unified UI rendering layer\n- Remote baremetal execution has 8 authoritative lanes (3 stable + 5 host-aware including both GHDL semihost and mailbox simulation), but hardware-dependent lanes remain host- and board-aware rather than universally complete. Lane matrix: [doc/08_tracking/lane_matrix.md](doc/08_tracking/lane_matrix.md)\n\nImplemented with bounded scope:\n- `m{}` / `loss{}` / `nograd{}` are complete for the promoted torch-backed C/LLVM scope, including backward, detached-input failure, and `nograd{}` restore semantics. Other backends remain deferred\n- AOP provides predicate-based pointcuts (`execution`, `within`, `attr`), deterministic before/after/around advice, compile-time weaving as the default backend, and scoped runtime interception. Support matrix: [doc/05_design/aop_support_matrix.md](doc/05_design/aop_support_matrix.md)\n- VHDL backend compiles a documented hardware-oriented Simple subset to synthesizable VHDL-2008, validated through GHDL analysis/elaboration. Strict fail-fast on unsupported constructs. Two GHDL RV32 simulation lanes are operational: semihost (GDB-backed, ARM semihosting traps) and mailbox (debugger-independent, MMIO at 0x80FF0000 with ram_sentinel result collection). Support matrix: [doc/04_architecture/vhdl_support_matrix.md](doc/04_architecture/vhdl_support_matrix.md). Mailbox protocol: [doc/04_architecture/ghdl_rv32_mailbox_protocol.md](doc/04_architecture/ghdl_rv32_mailbox_protocol.md)\n\nImplemented:\n- Anti-dummy / anti-stub enforcement is active on the primary source and compiled CLI surfaces (`simple lint`, `simple verify quality`). All public-facing proof suites (SFFI, T32 hardware, compiler/runtime/system) now pass the gate. Remaining debt is only in deferred OS/GPU/experimental areas — all active surfaces are clean.\n\nSee [doc/report/unique_features.md](doc/report/unique_features.md) for the evidence-backed audit.\n\n---\n\n## Runtime Families\n\nSimple organizes its standard library into runtime families based on allocation, mutation, and concurrency requirements:\n\n| Family | Allocation | Mutation | Async | Use Case |\n|--------|-----------|----------|-------|----------|\n| `common` | heap (default) | immutable | no | Pure functions, math, text, encoding |\n| `nogc_sync_mut` | heap/arena/pool | mutable | no | File I/O, networking, FFI, databases |\n| `nogc_async_mut` | heap | mutable | yes | Async I/O, threads, actors, generators |\n| `gc_async_mut` | GC-managed | mutable | yes | GPU/CUDA, ML pipelines |\n| `nogc_async_mut_noalloc` | stack only | mutable | yes | Baremetal, embedded, RTOS |\n\nThe compiler enforces family boundaries: importing a GC module from a no-GC context produces a diagnostic warning. Target presets (`Baremetal`, `Hosted`, `EmbeddedWithHeap`) automatically restrict module resolution to compatible families.\n\nFor advanced use: `nogc_async_immut` provides persistent data structures with lock-free concurrency.\n\nSee [Runtime Family Support Matrix](doc/04_architecture/runtime_family_support_matrix.md) for full contracts, and [Known Limitations](doc/08_tracking/bug/gc_runtime_limitations.md) for current caveats.\n\n---\n\n## Quick Start\n\n### Installation\n\n**What you get:**\n- Complete Simple compiler and toolchain source\n- Standard library and generated spec manuals\n- Development tools, including MCP server, LSP, and debugger surfaces\n\nUse a source checkout for the current beta. It also initializes the example and\ntooling submodules used by the docs and tests:\n\n```bash\ngit clone --recurse-submodules https://github.com/ormastes/simple.git\ncd simple\nexport PATH=\"$PWD/bin:$PATH\"\nsimple --version\n```\n\nFor an existing checkout:\n\n```bash\ngit submodule sync --recursive\ngit submodule update --init --recursive\n```\n\n**Note:** Rust remains present as the bootstrap seed and host substrate. Product\ncompiler, library, and tool work should stay in Simple source wherever the repo\ncan express it; do not read \"pure Simple\" as \"there is no Rust source in this\ncheckout\" today.\n\n### Source Footprint\n\nSnapshot generated 2026-04-23 from existing tracked `.spl`, `.rs`, `.c`, `.h`, `.s`, `.S`, and `.asm` files. Blank lines and comment-only lines are excluded; `examples/` code is included; vendored and third-party source is excluded.\n\n| Language | Files | Non-comment LOC | `src/` LOC | `examples/` LOC | `test/` LOC | Other LOC |\n|---|---:|---:|---:|---:|---:|---:|\n| Simple | 13,286 | 1,780,334 | 887,121 | 158,796 | 712,254 | 22,163 |\n| Rust | 1,633 | 411,106 | 409,852 | 11 | 0 | 1,243 |\n| C | 158 | 73,854 | 14,953 | 58,859 | 36 | 6 |\n| Assembly | 60 | 4,758 | 1,554 | 3,173 | 31 | 0 |\n| Total | 15,137 | 2,270,052 | 1,313,480 | 220,839 | 712,321 | 23,412 |\n\n### From Source (Developers Only)\n\nOnly needed if you want to modify the runtime:\n\n```bash\nscripts/setup/setup.shs\nbin/simple build bootstrap\n```\n\nDirect commands behind the wrapper:\n\n```bash\nsrc/compiler_rust/target/bootstrap/simple --version\nbin/simple build bootstrap\nsha256sum bootstrap/simple_stage2 bootstrap/simple_stage3\n```\n\nSee [doc/02_requirements/app/build/bootstrap.md](doc/02_requirements/app/build/bootstrap.md) and [doc/03_plan/compiler/bootstrap/pure_simple_bootstrap_stage2_remaining_2026-05-04.md](doc/03_plan/compiler/bootstrap/pure_simple_bootstrap_stage2_remaining_2026-05-04.md) for the current bootstrap flow and remaining pure-Simple self-hosting notes.\n\n### Build with GPU Support\n\n```bash\nsimple build --release --features=vulkan\n```\n\n### Your First Program\n\n```sdoctest\n# hello.spl\n>>> fn main() -> i64:\n...     0  # Entry point, returns exit code\n```\n\n```bash\n# Run it\nsimple hello.spl\necho $?  # Prints: 0\n```\n\n---\n\n## CLI Usage\n\nThe `simple` command works like Python:\n\n```\nUsage:\n  simple                      Start interactive REPL\n  simple <file.spl>           Run source file\n  simple <file.smf>           Run compiled binary\n  simple -c \"code\"            Run code string; statement snippets print only program output\n  simple compile <src> [-o <out>]  Compile to SMF\n  simple watch <file.spl>     Watch and auto-recompile\n\nBuild System (Self-Hosting):\n  simple build                Build the project (debug)\n  simple build --release      Release build (optimized)\n  simple build --bootstrap    Bootstrap build (minimal 9.3MB)\n  simple build test           Run all tests\n  simple build coverage       Generate coverage reports\n  simple build lint           Run linter (clippy)\n  simple build fmt            Format code (rustfmt)\n  simple build check          Run all quality checks\n  simple build clean          Clean build artifacts\n  simple build --help         Show all build options\n\nOptions:\n  -h, --help     Show help\n  -v, --version  Show version\n  -c <code>      Run code string\n  --gc-log       Enable verbose GC logging\n  --gc=off       Disable garbage collection\n```\n\n### Examples\n\n```bash\n# Interactive REPL\nsimple\n>>> 1 + 2\n3\n>>> x = 10\n>>> x * 5\n50\n>>> exit\n\n# Run a program\necho \"main = 42\" > hello.spl\nsimple hello.spl\necho $?  # Exit code: 42\n\n# Compile to binary\nsimple compile hello.spl\nsimple hello.smf  # Run the compiled binary\n\n# Watch mode (auto-recompile on changes)\nsimple watch app.spl\n```\n\n---\n\n## Language Basics\n\n### Variables & Types\n\n```sdoctest\n# Variables - immutable by default, mutable with var\n>>> x = 10\n>>> x\n10\n>>> var y = 20\n>>> y\n20\n>>> PI = 3.14159\n>>> PI\n3.14159\n\n# Type inference works automatically\n>>> count = 100\n>>> count\n100\n\n# Basic types inferred\n>>> a = 42\n>>> a\n42\n>>> pi = 3.14159\n>>> flag = true\n>>> flag\ntrue\n\n# String interpolation default\n>>> name = \"world\"\n>>> msg = \"Hello, {name}!\"\n>>> print msg\nHello, world!\n```\n\n### Control Flow\n\n```sdoctest\n# If/else with indentation\n>>> var x = 5\n>>> if x > 0:\n...     print \"positive\"\n... elif x < 0:\n...     print \"negative\"\n... else:\n...     print \"zero\"\npositive\n\n# Loops\n>>> for i in 0..3:\n...     print i\n0\n1\n2\n\n>>> while x > 3:\n...     x = x - 1\n>>> x\n3\n```\n\n### Functions\n\n```sdoctest\n>>> fn add(a: i64, b: i64) -> i64:\n...     a + b  # Implicit return\n\n>>> fn greet(greeting: text):\n...     print \"Hello, {greeting}!\"\n\n# Function calls\n>>> sum = add(1, 2)\n>>> sum\n3\n>>> greet(\"Alice\")\nHello, Alice!\n\n# Lambdas with backslash\n>>> double = \\x: x * 2\n>>> nums = [1, 2, 3, 4, 5]\n>>> evens = nums.filter(\\x: x % 2 == 0)\n>>> evens\n[2, 4]\n```\n\n### Structs & Classes\n\n```simple\n# Structs (value types)\nstruct Point:\n    x: f64\n    y: f64\n\np = Point(x: 1.0, y: 2.0)\n\n# Classes (reference types)\nclass Person:\n    name: text\n    age: i64\n\n    fn greet():\n        print \"Hi, {self.name}!\"\n\nalice = Person(name: \"Alice\", age: 30)\nalice.greet()\n```\n\n### Collections\n\n```sdoctest\n# Arrays - short form (no val)\n>>> nums = [1, 2, 3, 4, 5]\n>>> first = nums[0]\n>>> first\n1\n\n# Collection methods\n>>> count = nums.len()\n>>> count\n5\n\n# Dictionary (short form)\n>>> scores = {\"alice\": 100, \"bob\": 85}\n>>> alice_score = scores[\"alice\"]\n>>> alice_score\n100\n\n# Filter with lambda\n>>> odds = nums.filter(\\x: x % 2 == 1)\n>>> odds\n[1, 3, 5]\n>>> big_nums = nums.filter(\\x: x > 3)\n>>> big_nums\n[4, 5]\n\n# Tuples\n>>> pair = (1, \"hello\")\n>>> num = pair.0\n>>> num\n1\n>>> msg = pair.1\n>>> msg\n\"hello\"\n\n# List comprehensions\n>>> squared = [x * x for x in 0..5]\n>>> squared\n[0, 1, 4, 9, 16]\n>>> evens = [x for x in nums if x % 2 == 0]\n>>> evens\n[2, 4]\n```\n\n### Unit Types (Postfix Literals)\n\nType-safe units prevent mixing incompatible values:\n\n```simple\n# Define measurement unit families with postfix syntax\nunit length(base: f64):\n    mm = 0.001, cm = 0.01, m = 1.0, km = 1000.0\n\nunit velocity(base: f64) = length / time:\n    mps = 1.0, kmph = 0.2777777777777778, mph = 0.44704\n# The standards-backed catalog records km/h canonically as kilometre / hour\n# with exact factor 5/18 relative to m/s.\n\n# Define nominal wrappers with postfix syntax\nnewunit UserId: i64 as uid\nnewunit OrderId: i64 as oid\n\n# Usage with postfix literals\nheight = 175_cm              # Length type\nwidth = 10_cm + 5_mm         # Auto-converts to same base\nspeed = 200_kmph             # Velocity type\ndistance = 42_km             # Length type\n\n# Type safety - compile error:\n# bad = height + speed       # Error: can't add Length + Velocity\n\n# Semantic IDs prevent mix-ups\nuser = 42_uid                # UserId\norder = 100_oid              # OrderId\n# wrong: UserId = 100_oid    # Error: OrderId ≠ UserId\n\n# Computed units\ntravel_time = distance / speed    # Returns Time type\nprint(\"ETA: {travel_time.to_min()} minutes\")\n```\n\n### Pattern Matching\n\n```simple\nenum Shape:\n    Circle(radius: f64)\n    Rectangle(width: f64, height: f64)\n    Square(side: f64)\n    Triangle(base: f64, height: f64)\n\n# Pattern matching with case syntax\nfn area(s: Shape) -> f64:\n    match s:\n        case Circle(r):\n            3.14159 * r * r  # Implicit return\n        case Rectangle(w, h):\n            w * h\n        case Square(side):\n            side * side\n        case Triangle(b, h):\n            0.5 * b * h\n\n# Preferred arrow syntax (shorter)\nfn perimeter(s: Shape) -> f64:\n    match s:\n        | Circle(r) -> 2.0 * 3.14159 * r\n        | Rectangle(w, h) -> 2.0 * (w + h)\n        | Square(side) -> 4.0 * side\n        | Triangle(a, b, c) -> a + b + c\n\n# Pattern matching with nil (not None)\nfn get_radius(opt: Option<f64>) -> f64:\n    match opt:\n        | Some(r) -> r\n        | nil -> 0.0  # Use nil instead of None\n```\n\n### Parser-Friendly Macros\n\nSimple macros are contract-first and LL(1) parseable - the IDE can provide autocomplete without expanding the macro:\n\n```simple\n# Macro declares what it introduces in the contract header\nmacro define_counter(NAME: Str const) -> (\n  returns result: (init: Int, step: Int),\n  intro counter_fn: enclosing.class.fn \"{NAME}Counter\"(start: Int) -> Int\n):\n  const_eval:\n    const init = 0\n    const step = 1\n\n  emit counter_fn:\n    fn \"{NAME}Counter\"(start: Int) -> Int:\n      start + step\n\n# Usage - IDE knows about UserCounter before expansion\nclass Demo:\n  define_counter!(\"User\")\n\n  fn run() -> Int:\n    self.UserCounter(10)  # Autocomplete works!\n```\n\n**Built-in macros:**\n\n```simple\n# Print with formatting\nprintln!(\"Hello, {name}!\")           # Print with newline\nprint!(\"Value: {x}\")                 # Print without newline\n\n# Debug output with source location\ndbg!(expression)                     # Prints: [file:line] expression = value\n\n# Assertions\nassert!(condition)                   # Panic if false\nassert_eq!(a, b)                     # Panic if a != b\nassert_ne!(a, b)                     # Panic if a == b\n\n# Collections\nnums = vec![1, 2, 3, 4, 5]           # Create vector\nformatted = format!(\"x={x}\")         # Format string without printing\n\n# Panic with message\npanic!(\"Something went wrong: {err}\")\n```\n\n**Const-unrolled macro (generate multiple functions):**\n\n```simple\n# Generate accessor functions for each axis\nmacro gen_axes(BASE: Str const, N: Int const) -> (\n  intro axes:\n    for i in 0 .. N:\n      enclosing.class.fn \"{BASE}{i}\"(v: Vec[N]) -> Int\n):\n  emit axes:\n    for i in 0 .. N:\n      fn \"{BASE}{i}\"(v: Vec[N]) -> Int:\n        v[i]\n\n# Usage: generates x(), y(), z() accessors\nclass Point3D:\n  gen_axes!(\"axis_\", 3)  # Creates axis_0, axis_1, axis_2\n```\n\n### AOP & Aspect-Oriented Programming\n\nPredicate-based pointcuts with compile-time weaving as the default execution model:\n\n```simple\n# Before advice — runs before matching functions\non pc{ execution(* handle_request(..)) } use log_entry before priority 10\n\n# After advice — runs after successful return\non pc{ execution(* save(..)) & attr(audited) } use audit_write after_success priority 20\n\n# Around advice — wraps function with proceed() contract\non pc{ within(services.*) } use trace_around around priority 50\n\n# Architecture rules — enforce layer dependencies at compile time\nforbid pc{ within(hal.*) } \"HAL cannot depend on services\"\nallow  pc{ within(services.*) } \"Services can use HAL\"\n```\n\n**Supported selectors:** `execution(*)`, `within(*)`, `attr(*)` with `&` (AND), `|` (OR), `!` (NOT) operators.\n**Advice kinds:** `before`, `after_success`, `after_error`, `around` (proceed exactly-once).\n**Ordering:** priority (descending) > specificity > lexicographic name.\n**Zero overhead:** no weaving metadata when no aspects are defined.\n**Runtime interception:** scoped, opt-in only, disabled in release builds.\n\nSee [AOP Support Matrix](doc/05_design/aop_support_matrix.md) for the full contract.\n\n### SDN Configuration\n\nSimple Data Notation - a minimal, token-efficient format for config files:\n\n```sdn\n# app.sdn - Application configuration\napp:\n    name: MyService\n    version: 2.1.0\n\nserver:\n    host: 0.0.0.0\n    port: 8080\n    workers: 4\n\n# Inline arrays and dicts\nfeatures = [auth, logging, metrics]\ndatabase = {driver: postgres, host: localhost, port: 5432}\n\n# Named tables - compact tabular data\nrate_limits |endpoint, requests, window|\n    /api/login, 5, 60\n    /api/search, 100, 60\n    /api/upload, 10, 300\n```\n\nLoad SDN in Simple:\n\n```simple\nconfig = sdn::load(\"app.sdn\")\nprint(\"Server port: {config.server.port}\")\n```\n\n### SDoctest\n\nExecutable examples are part of the maintained test surface. Simple supports both demonstration blocks and verified `sdoctest` blocks, with `sdoctest` intended for examples that must run and match output.\n\n```sdoctest\n>>> factorial(5)\n120\n>>> factorial(0)\n1\n```\n\n```simple\n## Stack data structure with LIFO semantics\nstruct Stack:\n    items: [i64]\n\nvar s = Stack(items: [])\ns.items.push(1)\ns.items.push(2)\nprint s.items.len()  # 2\n```\n\nRun SDoctest examples:\n```bash\nsimple test --sdoctest README.md      # Run verified examples in Markdown/docs\nsimple test --spl-doctest src/math.spl # Run file-local source-comment doctests\nsimple test --sdoctest --tag slow     # Filter by tag\n```\n\n`--doctest` is still accepted as a compatibility alias, but `--sdoctest` is the clearer name for the implemented path.\nIn the canonical release command, the positional `test` selects the spec tree\nonly. `--whole` still discovers Markdown from `config/sdoctest.sdn` and comment\nsdoctests from the production `src/lib`, `src/compiler`, and `src/app` roots.\n\n### Functional Update Operator (`->`)\n\n```simple\n# The -> operator calls a method and assigns result back\nvar data = load_data()\ndata->normalize()        # data = data.normalize()\ndata->filter(min: 0)     # data = data.filter(min: 0)\n\n# Chaining\ndata->normalize()->filter(min: 0)->save(\"out.txt\")\n```\n\n### GPU Computing\n\n```simple\nimport std.gpu\n\n# GPU kernel style 1: #[gpu] with explicit bounds check\n#[gpu]\nfn vector_add_kernel(a: []f32, b: []f32, result: []f32):\n    idx = gpu.global_id(0)           # Global thread index\n    if idx < len(result):\n        result[idx] = a[idx] + b[idx]\n\n# GPU kernel style 2: @simd with auto bounds handling\n@simd\nfn vector_scale(data: []f32, scale: f32):\n    val i = this.index()             # Global linear index (same as gpu.global_id())\n    data[i] = data[i] * scale        # Bounds auto-handled\n\n# Host function - runs on CPU\nfn main():\n    device = gpu.Device()\n\n    # Allocate and upload data\n    a = [1.0, 2.0, 3.0, 4.0]\n    b = [5.0, 6.0, 7.0, 8.0]\n\n    buf_a = device.alloc_buffer(a)\n    buf_b = device.alloc_buffer(b)\n    buf_result = device.alloc_buffer<f32>(4)\n\n    # Launch kernel\n    device.launch_1d(vector_add_kernel, [buf_a, buf_b, buf_result], 4)\n\n    # Download results\n    device.sync()\n    result = device.download(buf_result)\n    # result = [6.0, 8.0, 10.0, 12.0]\n```\n\n**GPU Thread Indexers:**\n\n```simple\n#[gpu]\nfn matrix_multiply(A: []f32, B: []f32, C: []f32, N: u32):\n    # Multi-dimensional indexing\n    val row = gpu.global_id(0)       # First dimension\n    val col = gpu.global_id(1)       # Second dimension\n\n    # Thread group (workgroup) info\n    val local_row = gpu.local_id(0)  # Index within workgroup\n    val group_row = gpu.group_id(0)  # Workgroup index\n\n    # Alternative @simd style\n    # val(row, col) = this.index()  # Tuple for 2D\n    # vallocal_idx = this.thread_index()\n    # valgroup_idx = this.group_index()\n\n    if row < N and col < N:\n        var sum = 0.0_f32\n        for k in 0..N:\n            sum += A[row * N + k] * B[k * N + col]\n        C[row * N + col] = sum\n```\n\n**GPU Examples:** See `examples/gpu/vulkan/` for vector add, matrix multiply, reduction, and image blur.\n\n---\n\n## Documentation\n\n### Quick Links by Topic\n\n| Topic | Description | Link |\n|-------|-------------|------|\n| **Docs Hub** | Numbered documentation index | [doc/README.md](doc/README.md) |\n| **Language Spec** | Executable and generated specs | [doc/06_spec/README.md](doc/06_spec/README.md) |\n| **Guides** | Practical how-to guides | [doc/07_guide/README.md](doc/07_guide/README.md) |\n| **Plans** | Implementation roadmap | [doc/03_plan/README.md](doc/03_plan/README.md) |\n| **Research** | Design explorations | [doc/01_research/README.md](doc/01_research/README.md) |\n| **Architecture** | System design principles | [doc/04_architecture/README.md](doc/04_architecture/README.md) |\n| **Tracking** | Bugs, tests, and todo tracking | [doc/08_tracking/README.md](doc/08_tracking/README.md) |\n| **Reports** | Session and milestone reports | [doc/09_report/README.md](doc/09_report/README.md) |\n| **Deep Learning** | Neural networks and GPU computing | [doc/07_guide/deep_learning/deep_learning.md](doc/07_guide/deep_learning/deep_learning.md) |\n\n### Core Documentation\n\n**Getting Started:**\n- [Documentation Hub](doc/README.md) - Current entry point for the numbered doc tree\n- [Getting Started](doc/07_guide/getting_started.md) - Project setup and first steps\n- [Syntax Quick Reference](doc/07_guide/quick_reference/syntax_quick_reference.md) - Canonical public syntax cheat sheet\n- [Testing Guide](doc/07_guide/testing/testing.md) - Testing workflow and command surface\n\n**Language Reference:**\n- [Syntax Guide](doc/07_guide/language/syntax.md) - Surface syntax and examples\n- [Type System Guide](doc/07_guide/language/type_system.md) - Types, mutability, and usage\n- [Module System Guide](doc/07_guide/language/module_system.md) - Imports, packages, and layout\n- [Standard Library Guide](doc/07_guide/library/stdlib.md) - Stdlib organization and usage\n\n**GPU Computing:**\n- [Deep Learning Guide](doc/07_guide/deep_learning/deep_learning.md) - Pure Simple, model-oriented, and training flows\n- [GPU Programming Guide](doc/07_guide/backend/gpu_programming.md) - Backend and kernel-oriented GPU usage\n- [GPU API](doc/api/gpu_api.md) - API-level GPU reference\n- [LLVM Backend Architecture](doc/04_architecture/LLVM_BACKEND_ARCHITECTURE.md) - Backend implementation details\n\n**Development:**\n- [Build Guide](doc/07_guide/build.md) - Building Simple and common workflows\n- [Testing Guide](doc/07_guide/testing/testing.md) - Test runner behavior and flags\n- [SSpec Scenario Manual Guide](doc/07_guide/infra/sspec_scenario_manual.md) - `step(...)`, inline scenarios, capture, and generated manual style\n- [Mock Policy Guide](doc/07_guide/testing/mock_policy_system_test_ban.md) - System test mock ban and test level enforcement\n- [Coverage Guide](doc/07_guide/testing/coverage.md) - Coverage, SDoctest, and enforcement\n- [MCP Tooling Guide](doc/07_guide/tooling/mcp.md) - MCP registration and usage\n\n**Advanced Features:**\n- [Macro System](doc/06_spec/macro.md) - Executable macro spec and status\n- [AOP Support Matrix](doc/05_design/aop_support_matrix.md) - Supported selectors, advice kinds, backends, and error codes\n- [SDN Format](doc/04_architecture/format/note_sdn_index.md) - Note/SDN storage and indexing format\n- [SDoctest](doc/06_spec/03_system/feature/features/sdoctest/sdoctest_spec.md) - Documentation testing and verified examples\n- [Feature Documentation](doc/06_spec/feature.md) - Generated feature-doc artifact format\n\n---\n\n## Examples\n\n### Deep Learning Examples\n\nSimple ships multiple deep learning examples across pure-Simple, model-training, and GPU-oriented flows:\n\n**Pure Simple Neural Networks:**\n```bash\n# XOR neural network training\nbin/simple examples/pure_nn/xor_training_example.spl\n\n# Linear regression (learns y = 2x + 1)\nbin/simple examples/pure_nn/simple_regression.spl\n\n# Iris flower classification\nbin/simple examples/pure_nn/iris_classification.spl\n```\n\n**MedGemma Korean Fine-Tuning:**\n```bash\n# Progressive LoRA training to prevent catastrophic forgetting\nbin/simple examples/medgemma_korean/run_all.spl\n```\n\n**CUDA Programming:**\n```bash\n# Direct CUDA C API - multi-GPU, streams, events\nbin/simple examples/cuda/basic.spl\n```\n\n**See [Deep Learning Guide](doc/07_guide/deep_learning/deep_learning.md) for current documentation.**\n\n### Other Examples\n\nThe `examples/` directory contains additional working examples:\n\n| Example | Description |\n|---------|-------------|\n| `cli_demo.spl` | Command-line argument parsing |\n| `file_async_basic.spl` | Async file I/O operations |\n| `ui_todo_app.spl` | Cross-platform UI application |\n| `vulkan_triangle.spl` | GPU rendering with Vulkan |\n| `async_tcp_echo_server.spl` | Async TCP networking |\n\nRun an example:\n```bash\nbin/simple examples/cli_demo.spl\n```\n\n---\n\n## SSpec Scenario Manuals\n\nFeature and system documentation is generated from executable SSpec `.spl`\nscenarios. SPipe is the related runner/docgen process; SSpec is the authoring\nstyle: write readable `step(\"...\")` actions, keep executable assertions in the\nsame scenario, and let docgen render compact manual steps with folded source.\n\n```simple\nuse std.spec.*\n\ndescribe \"Dashboard actions\":\n    # @inline\n    it \"operator has an authenticated session\":\n        step(\"Open the sign-in page\")\n        step(\"Submit valid credentials\")\n\n    it \"operator reviews dashboard actions\":\n        # @include(\"operator has an authenticated session\")\n        step(\"Open the actions panel\")\n        expect(\"actions\").to_equal(\"actions\")\n```\n\nGenerated manual:\n\n```md\n1. Open the sign-in page\n2. Submit valid credentials\n3. Open the actions panel\n   - Expected: \"actions\" equals `actions`\n```\n\n`Given_*`, `When_*`, and `Then_*` helper naming is legacy style. Use\n`step(\"...\")` for new SSpec manuals. See the\n[SSpec Scenario Manual Guide](doc/07_guide/infra/sspec_scenario_manual.md).\n\nGenerated docs land in the numbered documentation tree, primarily under `doc/06_spec/`, so the checked examples stay close to the current spec artifacts.\n\n---\n\n## Grammar & Specification\n\n### Language Grammar\n\nSimple’s current language references are split between the guide tree for user-facing explanations and the spec tree for executable or generated reference material.\n\n**Current Reference Documents:**\n- [Syntax Quick Reference](doc/07_guide/quick_reference/syntax_quick_reference.md) - Fast public-language reference\n- [Syntax Guide](doc/07_guide/language/syntax.md) - User-facing language walkthrough\n- [Language Spec Index](doc/06_spec/README.md) - Current generated spec index\n- [Syntax Spec](doc/06_spec/syntax.md) - Spec artifact for syntax coverage\n- [Types Spec](doc/06_spec/types.md) - Spec artifact for type-system coverage\n- [Modules Spec](doc/06_spec/modules.md) - Spec artifact for module-system coverage\n\n**Quick Grammar Reference:**\n\n```\n# Top-level\nprogram ::= statement*\n\n# Statements\nstatement ::= function_def | class_def | struct_def | enum_def\n            | import_stmt | export_stmt | expr_stmt\n\n# Expressions (Pratt parser)\nexpr ::= literal | identifier | binary_op | unary_op\n       | call | index | field_access | lambda\n       | if_expr | match_expr | block\n\n# Types\ntype ::= identifier | array_type | tuple_type | fn_type\n       | optional_type | result_type | generic_type\n\n# Literals\nliteral ::= integer | float | string | bool | array | dict | tuple\n```\n\n### Specification Index\n\nThe current spec and guide material is organized under the numbered documentation tree:\n\n**Core Language:**\n- [Syntax Spec](doc/06_spec/syntax.md) - Syntax-oriented spec material\n- [Types Spec](doc/06_spec/types.md) - Type-system spec material\n- [Data Structures Spec](doc/06_spec/data_structures.md) - Data-structure coverage\n- [Functions Spec](doc/06_spec/functions.md) - Functions and pattern matching\n- [Traits Spec](doc/06_spec/traits.md) - Traits and implementations\n- [Memory Spec](doc/06_spec/memory.md) - Ownership and borrowing\n- [Modules Spec](doc/06_spec/modules.md) - Import/export system\n\n**Advanced Features:**\n- [Concurrency Spec](doc/06_spec/concurrency.md) - Async and concurrency behavior\n- [Metaprogramming Spec](doc/06_spec/metaprogramming.md) - Macros and decorators\n- [Macro Spec](doc/06_spec/macro.md) - Macro-specific executable coverage\n- [Capability Effects](doc/06_spec/capability_effects.md) - Capability/effect system\n- [Standard Library Guide](doc/07_guide/library/stdlib.md) - Stdlib structure and usage\n- [SFFI Guide](doc/07_guide/ffi/sffi.md) - Interop guidance\n- [External Native Libraries](doc/07_guide/ffi/external_native_libraries.md) - Optional host-library integration\n\n**Testing & Tooling:**\n- [Testing Guide](doc/07_guide/testing/testing.md) - Test runner and matchers\n- [SSpec Scenario Manual Guide](doc/07_guide/infra/sspec_scenario_manual.md) - Scenario manuals generated from executable specs\n- [Coverage Guide](doc/07_guide/testing/coverage.md) - Coverage and SDoctest enforcement\n- [Lint Guide](doc/07_guide/tooling/lint.md) - Lint rules and workflow\n- [MCP Guide](doc/07_guide/tooling/mcp.md) - MCP workflow and registration\n\n**GPU & Platform:**\n- [GPU Programming Guide](doc/07_guide/backend/gpu_programming.md) - GPU usage\n- [Deep Learning Guide](doc/07_guide/deep_learning/deep_learning.md) - Model-oriented examples\n- [Baremetal Guide](doc/07_guide/backend/baremetal.md) - Platform and baremetal flows\n\nSee [doc/README.md](doc/README.md), [doc/06_spec/README.md](doc/06_spec/README.md), and [doc/07_guide/README.md](doc/07_guide/README.md) for the current documentation entry points.\n\n---\n\n## Project Structure\n\n```\nsimple/\n├── bin/                      # CLI entry points\n│   ├── simple               # Main CLI (shell wrapper)\n│   └── release/             # Pre-built release binaries\n│       └── simple           # Pre-built runtime (33 MB)\n│\n├── src/                      # Simple source code (100% Simple)\n│   ├── app/                  # Applications\n│   │   ├── cli/             # Main CLI dispatcher\n│   │   ├── build/           # Self-hosting build system\n│   │   ├── mcp/             # MCP server (Model Context Protocol)\n│   │   ├── lsp/             # Language server protocol\n│   │   ├── io/              # SFFI wrappers (file, process, etc.)\n│   │   └── ...              # 50+ tool modules\n│   ├── lib/                  # Libraries\n│   │   ├── database/        # Unified database (BugDB, TestDB, etc.)\n│   │   └── pure/            # Pure Simple DL (tensor, autograd, nn)\n│   ├── std/                  # Standard library\n│   │   ├── src/             # Library source\n│   │   └── test/            # Library tests\n│   └── compiler/             # Compiler infrastructure\n│       ├── backend/         # Code generation\n│       ├── inference/       # Type inference\n│       └── parser/          # Parser and treesitter\n│\n├── examples/                 # Example programs\n│   ├── pure_nn/             # Deep learning examples\n│   └── gpu/vulkan/          # GPU computing examples\n│\n├── test/                     # Test suites\n│   ├── integration/         # Integration tests\n│   ├── system/              # System tests\n│   └── intensive/           # Intensive feature tests\n│\n├── doc/                      # Documentation\n│   ├── spec/                # Language specifications\n│   ├── guide/               # User guides\n│   ├── design/              # Design documents\n│   └── report/              # Session reports\n│\n└── src/verification/             # Lean 4 formal verification\n```\n\n---\n\n## Development\n\n### Building\n\n```bash\n# Debug build\nsimple build\n\n# Release build\nsimple build --release\n\n# With GPU support\nsimple build --release --features=vulkan\n\n# Bootstrap build (minimal 9.3MB)\nsimple build --bootstrap\n```\n\n### Testing\n\n**Full-suite snapshot (2026-02-14): 4,067/4,067 passing**\n\nSimple uses a broad test strategy spanning spec tests, SDoctest, coverage, and system lanes. The counts below are from the linked 2026-02-14 report:\n\n```bash\n# All tests (4,067 tests in 17.4 seconds)\nsimple test\n\n# Run specific test file\nsimple test path/to/spec.spl\n\n# With verbose output\nsimple test --verbose\n\n# Coverage reports\nsimple build coverage\n```\n\n**Test Coverage:**\n- Core interpreter: 227 tests\n- Compiler: 306 tests\n- Standard library: 428 tests\n- Applications: 142 tests\n- Libraries (ML, Physics, Game): 185 tests\n- Integration & Coverage: 2,779 tests\n\n**Performance:**\n- Total execution: 17.4 seconds\n- Average per test: 4.3ms\n- All tests deterministic and fast\n\n**Performance Profiles:**\n- Language profile: [scripts/check/check-cross-language-perf.shs](scripts/check/check-cross-language-perf.shs) generates [doc/09_report/cross_language_perf_2026-06-06.md](doc/09_report/cross_language_perf_2026-06-06.md)\n- GUI profile: [tools/gui_perf_bench/run_all_benchmarks.shs](tools/gui_perf_bench/run_all_benchmarks.shs) generates [doc/09_report/gui_perf_benchmark_2026-06-06.md](doc/09_report/gui_perf_benchmark_2026-06-06.md)\n- Startup/TUI profile: [scripts/check/check-startup-size-performance-audit.shs](scripts/check/check-startup-size-performance-audit.shs) records TUI startup rows in [doc/09_report/startup_size_performance_audit_2026-05-27.md](doc/09_report/startup_size_performance_audit_2026-05-27.md)\n\nSee [doc/09_report/session/full_test_suite_results_2026-02-14.md](doc/09_report/session/full_test_suite_results_2026-02-14.md) for detailed test analysis.\n\n### Code Quality\n\n```bash\n# Check before commit (fmt + lint + test)\nsimple build check\n\n# Full check (includes coverage + duplication)\nsimple build check --full\n\n# Format code\nsimple build fmt\n\n# Lint\nsimple build lint\n```\n\n---\n\n## AI Tooling (MCP, LSP, Plugin)\n\nSimple ships with MCP servers, LSP servers, and Claude Code plugins — all written in Simple.\n\n### Install Simple MCP Server\n\nThe Simple MCP server exposes repo-native tools for code diagnostics, VCS, build, test, debug, and related workflows. For current registration details, use the repo scripts and guide docs rather than relying on hardcoded counts here.\n\n```bash\n# From a repo checkout — register with Claude Code\nclaude mcp add simple-mcp -- \\\n  /absolute/path/to/simple/bin/simple \\\n  /absolute/path/to/simple/src/app/mcp/main.spl\n\n# Or use the project .mcp.json (auto-detected by Claude Code)\nsh config/mcp/install.shs\n```\n\n### Install Simple MCP Plugin\n\nThe `simple-mcp` Claude plugin is a repo-checkout plugin. Install it from a\nSimple repository checkout; it is not a standalone portable runtime bundle.\n\n```bash\nclaude plugin marketplace add tools/claude-plugin/marketplace\nclaude plugin install simple-mcp@simple-local\n```\n\nThe plugin launches `bin/simple_mcp_server` from the repository root.\n\n### Install Simple LSP Plugin\n\nThe Simple language server provides completions, hover, go-to-definition, diagnostics, and semantic tokens for `.spl` / `.shs` files.\n\n```bash\n# From a repo checkout\nclaude plugin marketplace add tools/claude-plugin/marketplace\nclaude plugin install simple-lsp@simple-local\n```\n\n**Binary full path:** `bin/simple run src/app/lsp/main.spl`\n\n### Install Both (Quick Setup)\n\n```bash\ncd /path/to/simple\n\n# 1. MCP server\nsh config/mcp/install.shs\n\n# 2. LSP plugin\nclaude plugin marketplace add tools/claude-plugin/marketplace\nclaude plugin install simple-lsp@simple-local\n```\n\n### Prompt Examples\n\nOnce the MCP server and LSP plugin are installed, try these prompts in Claude Code:\n\n```\n> \"Run the linter on src/app/cli/main.spl and fix any warnings\"\n\n> \"Show me all unused variables in the compiler frontend\"\n\n> \"Run the unit tests for the SDN parser\"\n\n> \"Build the project in release mode and show the result\"\n\n> \"What does the function `parse_expression` in the parser do?\"\n\n> \"Find all TODO items in the codebase\"\n\n> \"Check the doc coverage for the standard library\"\n\n> \"Debug why test/01_unit/lib/common/value_spec.spl is failing\"\n```\n\n---\n\n## Editor Plugins\n\n### VSCode Extension\n\nFull-featured extension with Tree-sitter highlighting, LSP integration, and math block support.\n\n```bash\ncd src/app/vscode_extension\nnpm install && npm run compile && npm run package\ncode --install-extension simple-language-0.1.0.vsix\n```\n\n**Key features:**\n- Semantic syntax highlighting (Tree-sitter powered)\n- LSP: completions, hover, go-to-definition, diagnostics\n- Math block highlighting for `m{}`, `loss{}`, `nograd{}` with nested brace support\n- Test CodeLens: \"Run Test/File/Doctest\" gutter arrows on `describe`/`it`/`context`/`sdoctest` blocks\n- AI-powered completions and chat (requires GitHub Copilot)\n\nSee [`src/app/vscode_extension/README.md`](src/app/vscode_extension/README.md) for full documentation.\n\n### Neovim Plugin\n\n```lua\n-- lazy.nvim\n{ \"nicholasgasior/simple.nvim\", ft = \"simple\", opts = {} }\n\n-- Or from project checkout\nvim.opt.rtp:prepend(\"/path/to/simple/src/app/nvim_plugin\")\nrequire(\"simple\").setup()\n```\n\n**Key features:**\n- LSP integration with auto-detection\n- Math block conceal with inline Unicode preview (`frac(1,2)` -> `(1)/(2)`, `alpha` -> `α`, `sqrt(x)` -> `√(x)`)\n- Test lens: \"Run\" virtual text beside test blocks\n- Tree-sitter queries (highlights, folds, text objects, injections)\n- Brief view (fold to signatures)\n\nSee [`src/app/nvim_plugin/README.md`](src/app/nvim_plugin/README.md) for full documentation.\n\n---\n\n## TRACE32 Tools\n\nMCP servers, CMM language server, and CLI tools for [Lauterbach TRACE32](https://www.lauterbach.com/en/) debuggers. See [`examples/10_tooling/trace32_tools/README.md`](examples/10_tooling/trace32_tools/README.md) for full documentation.\n\nThe repo-managed container flow is headless and uses `t32mciserver`. It does\nnot ship bundled TRACE32 GUI compatibility libraries; vendor runtime files must\ncome from your local `/opt/t32` installation.\n\nPrimary lifecycle wrapper:\n\n```bash\nscripts/t32q.shs build\nscripts/t32q.shs on\nscripts/t32q.shs wait\nscripts/t32q.shs ping\nscripts/t32q.shs reopen\nscripts/t32q.shs off\n```\n\nGUI container reopen path:\n\n```bash\nscripts/t32q.shs gui-on\nscripts/t32q.shs gui-reopen\nscripts/t32q.shs off\n```\n\n`gui-on` uses the Docker/Podman TRACE32 GUI path with host X11 forwarding, so\nit requires a real host X11 session (`DISPLAY`, `/tmp/.X11-unix`, and usually\n`XAUTHORITY`). For quick diagnostics use:\n\n```bash\nscripts/t32q.shs doctor\n```\n\nHello-world firmware smoke:\n\n```bash\nscripts/t32_semihost_hello.shs --board stm32wb\nscripts/t32_semihost_hello.shs --board stm32h7\nscripts/t32_semihost_hello.shs --board stm32wb --build-only\n```\n\n### Optional: Install T32 MCP Servers\n\nThese TRACE32 MCP servers are not installed by the default project MCP setup.\nRegister them manually only if you actively use TRACE32 tooling.\n\n```bash\ncd /path/to/simple\n\n# T32 MCP — controls live TRACE32 debug sessions (23 tools)\nclaude mcp add t32-mcp -- \\\n  /absolute/path/to/simple/bin/simple \\\n  /absolute/path/to/simple/examples/10_tooling/trace32_tools/t32_mcp/main.spl\n\n# T32 LSP MCP — CMM script analysis, no hardware needed (6 tools)\nclaude mcp add t32-lsp-mcp -- \\\n  /absolute/path/to/simple/bin/simple \\\n  /absolute/path/to/simple/examples/10_tooling/trace32_tools/t32_lsp_mcp/main.spl\n```\n\n**Binary full paths:**\n- T32 MCP: `bin/simple run examples/10_tooling/trace32_tools/t32_mcp/main.spl`\n- T32 LSP MCP: `bin/simple run examples/10_tooling/trace32_tools/t32_lsp_mcp/main.spl`\n\n### Install CMM LSP Plugin\n\n```bash\nclaude plugin marketplace add tools/claude-plugin/marketplace\nclaude plugin install cmm-lsp@simple-local\n```\n\n**Binary full path:** `bin/simple run examples/10_tooling/trace32_tools/cmm_lsp/mod.spl --lsp`\n\n### T32 Prompt Examples\n\n```\n> \"Parse this CMM script and check for errors: config/t32/stm32h7_gdb_start.cmm\"\n\n> \"Connect to TRACE32 on localhost:20000 and read the CPU registers\"\n\n> \"Show me all labels and macros defined in my CMM script\"\n\n> \"Convert this GUI PRACTICE script to CLI batch mode\"\n\n> \"Check if my CMM script has any undefined macros or unreachable code\"\n\n> \"Set a breakpoint at main, run to it, and show local variables\"\n\n> \"What TRACE32 commands are available for memory access?\"\n\n> \"Auto-complete suggestions for 'Data.LOAD' in my CMM script\"\n```\n\n---\n\n## Contributing\n\nSee [CLAUDE.md](CLAUDE.md) for development guidelines and [AGENTS.md](AGENTS.md) for AI agent instructions.\n\n**Documentation Structure:**\n- **Specifications** go in [doc/06_spec/](doc/06_spec/) (what the language supports)\n- **Guides** go in [doc/07_guide/](doc/07_guide/) (how to use features)\n- **Research** goes in [doc/01_research/](doc/01_research/) (why/how decisions were made)\n- **Plans** go in [doc/03_plan/](doc/03_plan/) (implementation roadmaps)\n- **Reports** go in [doc/09_report/](doc/09_report/) (session summaries and completion reports)\n\n---\n\n## License\n\nApache License 2.0. See [LICENSE](LICENSE).\n\nBundled third-party runtime components and redistribution notices are listed in\n[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).\n\nRelease packages also include `THIRD_PARTY_NOTICES.md`.\n\n---\n\n## Resources\n\n**Official Documentation:**\n- [Documentation Hub](doc/README.md) - Entry point for the numbered docs tree\n- [Language Specification](doc/06_spec/README.md) - Current spec index\n- [User Guides](doc/07_guide/README.md) - Practical tutorials\n\n**Quick References:**\n- [Syntax Quick Reference](doc/07_guide/quick_reference/syntax_quick_reference.md)\n- [Type System Guide](doc/07_guide/language/type_system.md)\n- [GPU Computing Guide](doc/07_guide/backend/gpu_programming.md)\n\n**Development:**\n- [Architecture Overview](doc/04_architecture/overview.md)\n- [Feature Documentation](doc/06_spec/feature.md)\n- [Implementation Plans](doc/03_plan/README.md)\n",
  "bytes": 45033,
  "sha": "4a7ba01f4f8e7afebe46e01fa0dc8c7b26bc63630798b983147006bc4c6d843b",
  "repo_slug": "ormastes/simple",
  "fonte": "repo",
  "truncated": false,
  "api": "https://agentalog.com/api/listings/mcp_io_github_ormastes_simple_mcp_server_06e60c6c/readme"
}