Introduction to Flame

What is Flame?

Flame is a fast, safe, and modern systems programming language powered by the Blaze compiler and VM. It combines the ergonomics, expressive syntax, and developer velocity of modern scripting languages with the raw performance, deterministic memory management, and static safety of Rust.

---

Core Philosophy

Flame was built around the principle: “Don’t reinvent the wheel; just use Rust’s.”

Instead of creating an isolated language ecosystem from scratch, Flame treats Rust crates as a second source language. When you add a crate in your project manifest (flame.toml), the compiler parses the crate, generates static type bridges, and compiles them directly into a single native binary with zero runtime FFI overhead.

---

Key Highlights

Ahead-of-Time (AOT) Compilation

Compiles directly to native machine code. No heavy VM interpreter runtime required in production.

No Garbage Collector

Compile-time ownership and borrow checking guarantees memory safety with zero runtime stutters or GC pause spikes.

Native Tokio & Multi-Core Threads

Combines asynchronous non-blocking I/O (async/await) with dedicated multi-core OS worker threads (thread { ... }).

First-Class IDE Intellisense

Automatic .fmi metadata generation powers VS Code autocomplete and hover documentation directly from docs.rs.

Execution Model: Top-Level Execution

No Automatic main() Invocation

Like JavaScript and Python, Flame executes code sequentially from top to bottom. There is no automatic main() function magic!

• If you write statements directly at the top level, they execute immediately when the script runs.
• If you define a fn main() { ... }, the compiler will not automatically invoke it. You must explicitly call main() or run statements at the top level.

---

Language at a Glance

Here is a quick overview of Flame’s syntax and core features:

import std.fs
import native.uuid

// 1. Struct and Impl definition
struct ServerConfig {
    host: String,
    port: Int,
    enabled: Bool
}

impl ServerConfig {
    fn new(host: String, port: Int) -> ServerConfig {
        return ServerConfig {
            host: host,
            port: port,
            enabled: true
        }
    }

    fn describe(&self) -> String {
        return $"Server listening on {self.host}:{self.port}"
    }
}

// 2. Direct Top-Level Execution
let config = ServerConfig.new("127.0.0.1", 8080)
print(config.describe())

// Direct Rust crate usage
let session_id = uuid.new_v4()
print($"Session ID: {session_id}")

// Map-like formula literals
let response = formula {
    status: 200,
    ok: true,
    data: ["items", "users"]
}
print(response.toString())

---

Next Steps

• Follow the Installation & Toolchain Guide to setup Flame on your machine.
• Read Architecture & Analysis to learn how Flame achieves native speed and safety.
• Explore Language Basics to start coding.