Roadmap & Feature Status

This page tracks what Luma supports today, what is being worked on, and what is planned for the future. Features marked with ✔ are implemented and documented.

v0.1.0 — Public Preview

The goal of v0.1.0 is simple: you can build a real web app, CLI tool, or automation script — start to finish — using only Luma. No external packages, no boilerplate, no gaps that force you back to another language halfway through a project.

Core Language

• ✔ Variable declarations with static types (x: int = 5)
• ✔ Constants with lock
• ✔ Type inference with coercion-aware arithmetic
• ✔ Arithmetic expressions with automatic type coercion
• ✔ Function definitions with return values
• ✔ Expression-body functions (=>)
• ✔ Recursion
• ✔ If / else / else if conditionals
• ✔ Interpolated strings with ${} syntax
• ✔ Single-line (//) and multi-line (/* */) comments
• ✔ Optional types with ?T syntax and safe unwrapping
• ✔ Structs with named fields
• ✔ Impl blocks for attaching methods to structs
• ✔ Traits for shared behavior across types
• ✔ Modules and imports with pub visibility
• ✔ Closures and anonymous functions — pass behavior as values, enable callbacks and higher-order patterns
• ✔ Error handling — recover from failures gracefully instead of panicking, with try, match, and result types
• ✔ Pattern matching — match on values, types, and struct fields for expressive control flow

Data Types

• ✔ Primitives: int, float, bool, str, byte
• ✔ Lists with full operations — add, remove, sort, filter, slice, walk, intersect, and more
• ✔ Maps with get, set, has, delete, keys, values, and walk
• ✔ Sets with union, intersect, and difference
• ✔ Optional types (?int, ?str, etc.)
• ✔ Date, Time, and Datetime with arithmetic, formatting, and comparison

Strings

• ✔ Interpolation: "Hello ${name}"
• ✔ Expression evaluation in interpolations: "Total: ${a + b}"
• ✔ Fallback values: "Hi ${name or "Guest"}"
• ✔ 30+ built-in methods — upper, lower, trim, split, replace, contains, starts_with, and more
• ✔ Method chaining: name.trim().upper()
• ✔ Encoding methods: to_hex(), to_base64(), to_base64url() and their decode counterparts
• ✔ Regex — match, find, replace, and validate text with regular expressions

File I/O

• ✔ File operations: read, write, append, copy, move, delete
• ✔ Byte-level read and write
• ✔ File metadata: name, ext, dir, path, size, exists
• ✔ Glob pattern matching: glob("*.txt")
• ✔ Optional file reads — return nil instead of panicking

Core Library

• ✔ JSON — decode, encode, and pretty-print
• ✔ CLI — flags (str, int, float, bool), prompts, args, output recording
• ✔ Env — get, set, has, load from .env files, get all variables
• ✔ TCP — client connections with read, write, and TLS support
• ✔ Buffer — byte buffers for binary data manipulation
• ✔ Crypto — hashing (MD5 through SHA-512), HMAC, secure random, XOR, constant-time comparison
• ✔ Encoding — hex, base64, and base64url as type methods on [byte] and str
• ✔ Database — MySQL driver with queries, execution, transactions, and prepared statements
• HTTP client — make GET, POST, PUT, and DELETE requests with headers, JSON bodies, and response handling. A language that can serve HTTP but not call APIs is half a language.
• Shell execution — run external commands, capture output, and check exit codes. Essential for scripting, automation, and build tools.
• Logging — structured logging with levels (debug, info, warn, error) for real applications that need more than print()
• Sleep/Timers — pause execution, add delays, and build polling loops. Small but essential for scripting and rate limiting.
• TCP server support (tcp.listen())

Web

• ✔ HTTP server with route definitions
• ✔ Request and Response types with JSON support
• ✔ Middleware support

Concurrency

• Spawn/Await — run tasks concurrently using Go’s goroutines with a clean, simple syntax. Luma compiles to Go — this is the single biggest missed opportunity if left out. Fetch three APIs in parallel, process files concurrently, build responsive servers.

Testing

• Built-in test runner — test blocks with assert so you can verify your code works without external tools. Every serious language needs this from day one.

Tooling

• ✔ CLI: luma run, luma compile, luma build, luma repl, luma tokens
• ✔ VS Code extension with syntax highlighting
• ✔ Debugging via compiled Go output
• Language server — hover info, diagnostics, and go-to-definition in VS Code

Planned

Features intended for releases after v0.1.0:

• Queues and additional data structures
• Additional string methods: is_alpha(), is_digit(), pad_left(), pad_right()
• CSV and INI parsing
• Web-based playground
• Code formatter and linter

Wishlist

Longer-term ideas under consideration:

• Memory-mapped file I/O (file.mmap())
• SQLite built-in driver
• Package manager for sharing reusable Luma libraries
• Concurrent file locking

Design Goals

These principles guide every release:

• Minimal but real productivity — enough features to build real tools, no more than needed
• Self-contained — no external dependencies for core functionality
• Familiar syntax — easy to read for anyone who knows a C-style language
• Native performance — compiled to Go, then to a native binary
• Thorough documentation — every feature is documented before it ships