Provides an LSP bridge for the Simple language to enable definitions, references, hover information, symbols, and diagnostics in AI clients.
Also known as ormastes/simple, simple, @simple-lang/lsp-mcp-server, @simple-lang/mcp-server
- Stars
- 2
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- 0.9.8
- Last commit
- Nov 16, 2026
- License
- —
What is Simple Language LSP MCP?
Simple Language LSP provides an LSP bridge for the Simple language to enable definitions, references, hover information, symbols, and diagnostics in AI clients.
Summary generated from the project's README
About Simple Language LSP MCP server
Developers working with the Simple language can use this MCP server to bring advanced language intelligence directly into their AI-driven coding workflows. By acting as a bridge to the Language Server Protocol, it allows AI clients to understand the specific structure and semantics of Simple source files. This connection enables the AI to perform sophisticated code analysis tasks that go beyond simple text manipulation.
Users can integrate this server into their local development environment to provide an AI assistant with the ability to navigate complex codebases. The server facilitates essential programming features such as finding definitions, locating references, viewing hover information, exploring symbols, and receiving real-time diagnostics. Because it relies on the existing Simple toolchain, it ensures that the AI has access to the same semantic truths used by the compiler and interpreter during the development process.
Written from the project's README. Every use case is checked against a quote from it.
How to install Simple Language LSP MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Simple Language LSP MCP in Claude Code
$ claude mcp add simple -- npx -y @simple-lang/lsp-mcp-serverInstall Simple Language LSP MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"simple": {
"command": "npx",
"args": [
"-y",
"@simple-lang/lsp-mcp-server"
]
}
}
}Install Simple Language LSP MCP in VS Code
.vscode/mcp.json
{
"servers": {
"simple": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@simple-lang/lsp-mcp-server"
]
}
}
}Install Simple Language LSP MCP in VS Code CLI
$ code --add-mcp '{"name":"simple","type":"stdio","command":"npx","args":["-y","@simple-lang/lsp-mcp-server"]}'Install Simple Language LSP MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"simple": {
"command": "npx",
"args": [
"-y",
"@simple-lang/lsp-mcp-server"
]
}
}
}Install Simple Language LSP MCP in Codex
$ codex mcp add simple -- npx -y @simple-lang/lsp-mcp-serverInstall Simple Language LSP MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.simple] command = "npx" args = ["-y", "@simple-lang/lsp-mcp-server"]
Install Simple Language LSP MCP in Gemini CLI
$ gemini mcp add -s user simple npx -- -y @simple-lang/lsp-mcp-serverInstall Simple Language LSP MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"simple": {
"command": "npx",
"args": [
"-y",
"@simple-lang/lsp-mcp-server"
]
}
}
}Automated checks
Ran Nov 14, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work · What to fix for more points
- Source repository linked and reachableormastes/simple is public and reachablegithub.com/ormastes/simple ↗Pass
- Package names this repository as its source@simple-lang/lsp-mcp-server, @simple-lang/mcp-server name ormastes/simple as sourcenpmjs.com/package/@simple-lang/lsp-mcp-server ↗Pass
- Build provenance (Sigstore attestation)No build attestation published for this releaseNot checked
- Open source license (OSI)No licenseFinding
- Commit or release in the last yearLast commit or release 2026-11-14github.com/ormastes/simple ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from @simple-lang/lsp-mcp-server, @simple-lang/mcp-serverPass
- No critical advisory in the package or its dependencies1 resolved dependencies checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubSimple Language
Simple 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.
The 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.
Quick Navigation: Distinctive Features | Feature Status | Quick Start | Language Basics | Examples | Editor Plugins | Documentation
Distinctive Features
- Self-hosted staged toolchain: real source layers for frontend, type analysis, borrow checking, backend, driver, interpreter, and loader live in-tree.
- 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.
- MDSOC architecture support: virtual capsules, manifests, and architecture-aware repository structure are first-class concepts.
- Parser-friendly macro system: macro definitions, expansion, validation, and hygiene are compiler features rather than editor-hostile text substitution.
- Math-oriented syntax blocks:
m{},loss{}, andnograd{}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. - SDN-backed textual databases: tests, todos, dashboards, and other project metadata are stored through repo-native SDN data flows.
- Multiple execution paths: interpreter, loader, SMF/module loading, and native/LLVM-oriented compilation paths coexist in one system.
- 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.
- Tooling-aware language rules: Tree-sitter integration, primitive-public-API linting, traceability tooling, and language statistics are part of the platform.
- Shared UI contract across supported surfaces: one HTTP-based test protocol (Protocol V1) with
UITestClientdrives both the web backend and the TUI-web proxy through a sharedhandle_test_requesthandler, verified by a cross-surface contract suite. Contract: doc/04_architecture/shared_ui_contract.md
Feature Status Highlights
Implemented and safe to advertise:
- SSpec tests, SPipe runner/docgen, SDoctest, coverage, traceability checks, and generated spec docs
- SPipe mock policy: system-test mock ban, HAL-only and custom pattern modes
- Self-hosted staged compiler, interpreter, and loader architecture
- MDSOC manifests and architecture-focused project structure
- Parser-friendly macros with validation and hygiene
- Tree-sitter outline/query tooling
- SDN-backed project, test, and todo databases
- Primitive-public-API linting and semantic wrapper/unit-type patterns
- Borrow-checking infrastructure
- Watch mode and auto-build support
- mmap-backed loader support and executable-memory plumbing
- Baremetal build/test plumbing and host-aware remote baremetal flows
- C/C++ bidirectional SFFI for the supported ABI subset: exports, imports, callback trampolines, layout verification, and round-trip proof tests
Implemented, but best described with qualifiers:
- LLVM full-family closure is complete for the declared public matrix: every
llvm-libandllvmbackend row is now explicitlystableorunsupported, with no ambiguous middle states.rust-llvmremains a bootstrap-only seed path outside the public family claim - 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. Report: doc/09_report/lean_verification_complete_2026-04-04.md
- 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 - 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
- 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
Implemented with bounded scope:
m{}/loss{}/nograd{}are complete for the promoted torch-backed C/LLVM scope, including backward, detached-input failure, andnograd{}restore semantics. Other backends remain deferred- 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 - 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. Mailbox protocol: doc/04_architecture/ghdl_rv32_mailbox_protocol.md
Implemented:
- 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.
See doc/report/unique_features.md for the evidence-backed audit.
Runtime Families
Simple organizes its standard library into runtime families based on allocation, mutation, and concurrency requirements:
| Family | Allocation | Mutation | Async | Use Case |
|---|---|---|---|---|
common |
heap (default) | immutable | no | Pure functions, math, text, encoding |
nogc_sync_mut |
heap/arena/pool | mutable | no | File I/O, networking, FFI, databases |
nogc_async_mut |
heap | mutable | yes | Async I/O, threads, actors, generators |
gc_async_mut |
GC-managed | mutable | yes | GPU/CUDA, ML pipelines |
nogc_async_mut_noalloc |
stack only | mutable | yes | Baremetal, embedded, RTOS |
The 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.
For advanced use: nogc_async_immut provides persistent data structures with lock-free concurrency.
See Runtime Family Support Matrix for full contracts, and Known Limitations for current caveats.
Quick Start
Installation
What you get:
- Complete Simple compiler and toolchain source
- Standard library and generated spec manuals
- Development tools, including MCP server, LSP, and debugger surfaces
Use a source checkout for the current beta. It also initializes the example and tooling submodules used by the docs and tests:
git clone --recurse-submodules https://github.com/ormastes/simple.git
cd simple
export PATH="$PWD/bin:$PATH"
simple --version
For an existing checkout:
git submodule sync --recursive
git submodule update --init --recursive
Note: Rust remains present as the bootstrap seed and host substrate. Product compiler, library, and tool work should stay in Simple source wherever the repo can express it; do not read "pure Simple" as "there is no Rust source in this checkout" today.
Source Footprint
Snapshot 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.
| Language | Files | Non-comment LOC | src/ LOC |
examples/ LOC |
test/ LOC |
Other LOC |
|---|---|---|---|---|---|---|
| Simple | 13,286 | 1,780,334 | 887,121 | 158,796 | 712,254 | 22,163 |
| Rust | 1,633 | 411,106 | 409,852 | 11 | 0 | 1,243 |
| C | 158 | 73,854 | 14,953 | 58,859 | 36 | 6 |
| Assembly | 60 | 4,758 | 1,554 | 3,173 | 31 | 0 |
| Total | 15,137 | 2,270,052 | 1,313,480 | 220,839 | 712,321 | 23,412 |
From Source (Developers Only)
Only needed if you want to modify the runtime:
scripts/setup/setup.shs
bin/simple build bootstrap
Direct commands behind the wrapper:
src/compiler_rust/target/bootstrap/simple --version
bin/simple build bootstrap
sha256sum bootstrap/simple_stage2 bootstrap/simple_stage3
See doc/02_requirements/app/build/bootstrap.md and 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.
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; statement snippets print only program output
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 measurement unit families 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.2777777777777778, mph = 0.44704
# The standards-backed catalog records km/h canonically as kilometre / hour
# with exact factor 5/18 relative to m/s.
# Define nominal wrappers with postfix syntax
newunit UserId: i64 as uid
newunit 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
Predicate-based pointcuts with compile-time weaving as the default execution model:
# Before advice — runs before matching functions
on pc{ execution(* handle_request(..)) } use log_entry before priority 10
# After advice — runs after successful return
on pc{ execution(* save(..)) & attr(audited) } use audit_write after_success priority 20
# Around advice — wraps function with proceed() contract
on pc{ within(services.*) } use trace_around around priority 50
# Architecture rules — enforce layer dependencies at compile time
forbid pc{ within(hal.*) } "HAL cannot depend on services"
allow pc{ within(services.*) } "Services can use HAL"
Supported selectors: execution(*), within(*), attr(*) with & (AND), | (OR), ! (NOT) operators.
Advice kinds: before, after_success, after_error, around (proceed exactly-once).
Ordering: priority (descending) > specificity > lexicographic name.
Zero overhead: no weaving metadata when no aspects are defined.
Runtime interception: scoped, opt-in only, disabled in release builds.
See AOP Support Matrix for the full contract.
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}")
SDoctest
Executable 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.
>>> factorial(5)
120
>>> factorial(0)
1
## Stack data structure with LIFO semantics
struct Stack:
items: [i64]
var s = Stack(items: [])
s.items.push(1)
s.items.push(2)
print s.items.len() # 2
Run SDoctest examples:
simple test --sdoctest README.md # Run verified examples in Markdown/docs
simple test --spl-doctest src/math.spl # Run file-local source-comment doctests
simple test --sdoctest --tag slow # Filter by tag
--doctest is still accepted as a compatibility alias, but --sdoctest is the clearer name for the implemented path.
In the canonical release command, the positional test selects the spec tree
only. --whole still discovers Markdown from config/sdoctest.sdn and comment
sdoctests from the production src/lib, src/compiler, and src/app roots.
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
Simple Language LSP MCP questions
How do I add Simple Language LSP MCP to Claude Code?
Run claude mcp add simple -- npx -y @simple-lang/lsp-mcp-server in your terminal. Add --scope user to make it available in every project.
How do I add Simple Language LSP MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What is included in the Simple toolchain installation?
The installation includes the complete Simple compiler and toolchain source, the standard library, generated spec manuals, and development tools like the MCP server, LSP, and debugger surfaces.
How do I install the Simple toolchain?
You can install it by cloning the repository with submodules and adding the bin directory to your PATH.