IRIS Language for Visual Studio Code

Full-featured IDE support for the IRIS programming language — syntax highlighting, Language Server Protocol, debugging, REPL, and more.

Features

Syntax Highlighting

Rich TextMate grammar for .iris files — keywords, types, strings, f-strings, comments, operators, and builtins are all highlighted accurately.

Language Server Protocol (LSP)

Hover — type info and doc comments on any symbol
Completions — context-aware suggestions for functions, types, builtins, and keywords
Diagnostics — real-time error and warning reporting, plus best-practice hints (long functions, missing doc comments, naming conventions)
Go to Definition / Peek Definition
Document Symbols — outline view and breadcrumbs
Signature Help — parameter hints as you type
Formatting — format on save (configurable)
Inlay Hints — inline type annotations on val / var bindings
Code Actions — auto-fix missing semicolons, type casts, naming conventions, and more

Debug Adapter Protocol (DAP)

Step-through debugging with the built-in IRIS debugger:

Breakpoints (line and conditional)
Step In / Step Over / Step Out / Continue
Variables inspector (locals, globals)
Watch expressions
Debug Console evaluation

Commands

Command	Keybinding	Description
IRIS: Run File	`Ctrl+F5`	Run the current `.iris` file
IRIS: Build Binary	—	Compile to a native executable
IRIS: Open REPL	—	Launch an interactive IRIS session
IRIS: Restart Language Server	—	Restart the LSP server
IRIS: Stop Language Server	—	Stop the LSP server
IRIS: Show IR Output	—	Display the compiler's SSA IR
IRIS: Show LLVM IR Output	—	Display the generated LLVM IR
IRIS: Show Version Info	—	Show compiler version, git commit, build date, and target

Snippets

Quickly scaffold common patterns: def, record, choice, val, var, if, while, for, when, bring, error handling, FFI calls, and more.

Code Lens & Status Bar

Status bar shows the active IRIS compiler version with a rich tooltip (git commit, branch, build date, target triple, rustc version).

Requirements

VS Code ≥ 1.85
IRIS compiler installed and available on PATH (or configure iris.executablePath)

Install IRIS from github.com/moon9t/iris/releases or build from source:

git clone https://github.com/moon9t/iris.git
cd iris
cargo build --release

Extension Settings

Setting	Default	Description
`iris.executablePath`	`"iris"`	Path to the `iris` binary
`iris.maxNumberOfProblems`	`100`	Maximum diagnostics shown in the Problems panel
`iris.formatOnSave`	`true`	Auto-format `.iris` files on save
`iris.trace.server`	`"off"`	Trace LSP communication (`off` / `messages` / `verbose`)
`iris.inlayHints.enabled`	`true`	Enable inlay hints
`iris.inlayHints.typeHints`	`true`	Show type hints on `val` / `var` bindings
`iris.showTimingOnRun`	`true`	Show compile + run elapsed time

Quick Start

Install the IRIS compiler and ensure iris is on your PATH.
Install this extension from the VS Code Marketplace.
Open any .iris file — the language server starts automatically.
Press Ctrl+F5 to run, or use F5 to debug.

// hello.iris
def main() -> i64 {
    println("Hello, IRIS!")
    0
}

IRIS Language at a Glance

// Records, generics, and pattern matching
record Point { x: f64, y: f64 }

choice Shape {
    Circle(f64),
    Rect(f64, f64),
}

def area(s: Shape) -> f64 {
    when s {
        Shape.Circle(r) => 3.14159 * r * r,
        Shape.Rect(w, h) => w * h,
    }
}

def main() -> i64 {
    val shapes = [Shape.Circle(5.0), Shape.Rect(3.0, 4.0)]
    for s in shapes {
        println(f"Area: {area(s)}")
    }
    0
}

IRIS features strong static typing, algebraic data types, closures, generics, pattern matching, multi-module projects, an LLVM-backed native compiler, and a growing standard library.

Known Issues

Native concurrency (spawn / channel) is under active development.
Recursion depth in interpreter/eval mode is limited (~100 frames).

Contributing

Contributions welcome! See CONTRIBUTING.md.

License

GPL-2.0-or-later

IRIS Language

Iris-Lang