Dim Programming Language

Dim is a next-generation, statically-compiled programming language designed to bridge ergonomic developer experience with systems-level control — with AI/ML, memory safety, and security as first-class language features.

Status: v1.0 Production — Fully self-hosting compiler

Features

| Feature | Status | | --------------------------- | ---------------------------------------------- | | Tree-Walking Interpreter | ✅ Production (dim_interpreter.py) | | REPL | ✅ Production (dim_repl.py) | | AI prompt type | ✅ Production (dim_ai.py) | | String Interpolation | ✅ Production (dim_lexer.py, dim_interpreter.py) | | ? Operator (Result) | ✅ Production (dim_parser.py, dim_interpreter.py) | | Primitive Methods | ✅ Production (dim_interpreter.py) | | VS Code Extension | ✅ (editors/vscode/) | | Lexer with INDENT/DEDENT | ✅ Production (dim_lexer.py) | | EBNF Grammar | ✅ Formal spec (dim_grammar.ebnf) | | Span-annotated AST | ✅ v0.5 (dim_ast.py) | | Algebraic Type System | ✅ (dim_types.py) | | Hindley-Milner Type Checker | ✅ (dim_type_checker.py) | | Structured Diagnostics | ✅ (dim_diagnostic.py) | | Mid-Level IR (MIR / CFG) | ✅ (dim_mir.py) | | AST → MIR Lowering | ✅ (dim_mir_lowering.py) | | Borrow Checker (MIR-level) | ✅ Polonius-inspired (dim_borrow_checker.py) | | LLVM IR Codegen | ✅ (dim_mir_to_llvm.py) | | Module Import Resolution | ✅ (dim_module_resolver.py) | | First-class prompt type | ✅ AST + type system | | actor / message-passing | ✅ AST + parser | | @tool decorator | ✅ Parser + semantic analysis | | Error handling (try/catch) | ✅ Parser + type checker | | Closures & lambdas | ✅ |x, y| -> expr syntax | | Generics & Traits | ✅ (dim_type_checker.py, dim_types.py) | | FFI (foreign/use) | ✅ Parser + type checker | | Standard library | ✅ Full working stdlib | | WASM compilation | ✅ (dim_wasm_codegen.py) | | Package Manager | ✅ (dim_pkg.py) | | LSP Server | ✅ (dim_lsp.py) | | REPL | ✅ (dim_repl.py) | | Debugger | ✅ (dim_debugger.py) | | Test Framework | ✅ (dim_test.py) | | Build System | ✅ (dim_build.py) | | Macro System | ✅ (dim_macro.py) | | Memory Management (RC + GC)| ✅ Reference counting + GC | | Concurrency (Threads/Future)| ✅ Thread pool + async/futures | | Test Suite | ✅ 79 tests (dim_tests.py) |

Interactive Demo

Try Dim without installing! Download and open dim_language_demo.html in your browser:

Hello World - Run Dim programs
REPL - Interactive console
AI Prompt - Real AI integration
VS Code - Syntax highlighting demo

Or run locally:

# Run a Dim file
python dim_cli.py run hello.dim

# Start REPL
python dim_repl.py

# Type check
python dim_cli.py check hello.dim

Syntax Preview

# Functions with return types
fn add(x: i32, y: i32) -> i32:
    return x + y

# Ownership — immutable by default, move semantics
fn process(data: Buffer) -> Result[str, Error]:
    let view = &data          # shared borrow
    return Ok(view.to_string())

# Async / Await
async fn fetch(url: String) -> Result[Data, Error]:
    let resp = await http::get(url)
    return parse(resp.body)

# Actors — isolated state via message passing
actor Counter:
    state: i32 = 0
    receive Increment():
        self.state += 1
    receive GetCount() -> i32:
        return self.state

# AI as a first-class type
prompt Classify:
    role system: "You are a text classifier."
    role user:   "Classify: {input}"
    output: ClassLabel

# Pattern matching
fn describe(x: i32) -> str:
    match x:
        0: return "zero"
        n if n > 0: return "positive"
        _: return "negative"

# Generics + Traits
trait Summable[T]:
    fn add(a: T, b: T) -> T

fn generic_sum[T: Summable](a: T, b: T) -> T:
    return T.add(a, b)

# Error handling
fn safe_div(a: i32, b: i32):
    try:
        if b == 0:
            throw Error()
        return a / b
    catch e:
        print("Error!")
    finally:
        cleanup()

# Closures and tuples
fn use_closure():
    let add = |x, y| -> x + y
    let point = (1, 2, 3)
    let len = point.len

# Standard library
fn demo_std():
    let x = abs(-5)
    let m = min(1, 2)
    let mx = max(1, 2)
    let s = sin(3.14159)
    let root = sqrt(144.0)

# Module imports
import std.io
import std.vec
import std.math
import std.str

fn demo_io():
    print("Hello, World!")
    let content = read_file("test.txt")
    if file_exists("test.txt"):
        println("File exists!")

fn demo_vec():
    let arr = [1, 2, 3]
    push(arr, 4)
    let x = pop(arr)

# FFI - call C functions
foreign "libc.so" [
    fn puts(msg: str) -> i32
    fn rand() -> i32
]

Compiler Pipeline

Source (.dim)
    ↓  dim_lexer.py           — Tokenisation + INDENT/DEDENT
    ↓  dim_parser.py          — AST construction (Pratt + recursive descent)
    ↓  dim_module_resolver.py — Module import resolution
    ↓  dim_type_checker.py    — HM type inference, scope resolution
    ↓  dim_mir_lowering.py   — AST → MIR (SSA Control Flow Graph)
    ↓  dim_borrow_checker.py — Ownership & borrow validation (Polonius)
    ↓  dim_mir_to_llvm.py     — MIR → LLVM IR (x86_64, wasm32, wasm64)
    ↓  clang                  — Native binary / WASM

Usage

# Initialize a new project
dim new myproject
cd myproject

# Build and run
dim run main.dim
dim run main.dim arg1 arg2

# Just type-check
dim check hello.dim

# Print AST
dim parse hello.dim

# Print MIR (SSA/CFG)
dim mir hello.dim

# Run borrow checker
dim borrow hello.dim

# Run full build pipeline
dim build hello.dim

# Run test suite
dim test
dim test --tag lexer   # filter by category

# Package manager
dim pkg init mypkg
dim pkg add http 1.0.0
dim pkg remove http
dim pkg install
dim pkg list

# Format code
dim fmt hello.dim

# LSP server (for IDEs)
python dim_lsp.py

# REPL
python dim_repl.py

# Debugger
python dim_debugger.py hello.dim

Project Structure

dim/                      — Dim source root
├── Compiler Core
│   ├── dim_token.py          — Token and Span definitions
│   ├── dim_lexer.py          — Lexer with INDENT/DEDENT
│   ├── dim_parser.py         — Recursive descent parser
│   ├── dim_ast.py            — AST node definitions
│   ├── dim_types.py          — Type system
│   ├── dim_type_checker.py   — Hindley-Milner type inference
│   ├── dim_semantic.py       — Semantic analysis
│   ├── dim_borrow_checker.py — Borrow checking
│   └── dim_module_resolver.py — Module resolution
├── IR & Codegen
│   ├── dim_mir.py            — Mid-Level IR
│   ├── dim_mir_lowering.py   — AST → MIR lowering
│   ├── dim_mir_to_llvm.py    — MIR → LLVM IR
│   ├── dim_native_codegen.py — Native binary generation
│   └── dim_wasm_codegen.py   — WASM compilation
├── Tools
│   ├── dim_cli.py            — CLI interface
│   ├── dim_diagnostic.py     — Error/warning system
│   ├── dim_lsp.py            — LSP server (IDE support)
│   ├── dim_repl.py           — Interactive REPL
│   ├── dim_debugger.py       — Debugger
│   ├── dim_test.py           — Test framework
│   ├── dim_pkg.py            — Package manager
│   ├── dim_build.py          — Build system
│   ├── dim_formatter.py      — Code formatter
│   └── dim_macro.py         — Macro system
├── Runtime
│   ├── runtime/dim_runtime.c         — C runtime (native)
│   └── runtime/dim_runtime_wasm.c   — C runtime (WASM)
├── Stdlib
│   ├── std/io.dim    — I/O utilities
│   ├── std/vec.dim   — Vector/array utilities
│   ├── std/math.dim  — Math functions
│   ├── std/str.dim   — String utilities
│   ├── std/file.dim  — File I/O
│   └── std/json.dim  — JSON utilities
├── Tests & Docs
│   ├── dim_tests.py          — 70 test cases
│   └── examples/             — Example .dim files
│       ├── functions.dim
│       ├── control_flow.dim
│       ├── ai_tools.dim
│       ├── types.dim
│       ├── ownership.dim
│       ├── traits.dim
│       ├── ffi.dim
│       └── test_example.dim
└── Documentation
    ├── README.md             — This file
    ├── CHANGELOG.md          — Version history
    ├── CONTRIBUTING.md       — Contribution guide
    ├── LICENSE.md            — MIT License
    ├── COMPILER_INTERNALS.md — Compiler internals
    ├── QUICK_REFERENCE.md    — Language quick reference
    └── dim_specification.md   — Language specification

Roadmap

| Phase | Milestone | Status | | ----- | -------------------------------------------------------- | ------ | | 0 | Lexer, Parser, AST prototype | ✅ Done | | 1 | Types, MIR, Borrow Checker, Diagnostics | ✅ Done | | 2 | LLVM IR codegen, function calls, @tool parsing | ✅ Done | | 3 | Native binaries, WASM, full LLVM backend | ✅ Done | | 4 | Package manager, LSP,

Dim

Install / Use

README