Flame Programming Language

Why Flame?

Zero-Overhead Rust Interoperability

Import any Rust crate directly in flame.toml with import native.uuid or import native.axum. Statically linked with zero FFI overhead.

No Garbage Collector, Pure Safety

Rust-style Ownership and Borrowing system guarantees memory safety and data-race prevention at compile time with zero GC pauses.

True Multithreaded Concurrency

Combines Tokio worker pools for non-blocking I/O with dedicated thread { ... } compute workers across multi-core CPUs.

Integrated Native Test Runner

PascalCase annotations like @Test, @Setup, @Cleanup, and @Parameterized with zero-cost production stripping during release builds.

---

Quick Taste of Flame

Hello World & Formula

// Clean, expressive syntax with formula objects
let user = formula {
    name: "Alex",
    role: "Developer",
    active: true,
    greet: () {
        print("Welcome to Flame!")
    }
}

print($"Hello, {user.name}! Role: {user.role}")
user.greet()

Native Rust Crates

// Statically compiles and links external Rust crates!
import native.uuid

let new_id = uuid.new_v4()
print($"Generated UUID: {new_id}")

Async Networking & Threads

import std.thread

async fn main() {
    // Spawn a parallel physical compute thread
    let compute = thread {
        let mut sum = 0
        let mut i = 0
        while i < 1000000 {
            sum = sum + i
            i = i + 1
        }
        return sum
    }

    // Await thread completion asynchronously
    let total = await compute
    print($"Calculated sum: {total}")
}

await main()

Zero-Cost Testing

@Test(timeout: 2000)
fn test_addition() {
    let sum = 2 + 2
    assertEq(sum, 4, "Math must be correct")
}

@Parameterized([
    [10, 20, 30],
    [5, 5, 10]
])
fn test_math(a: Int, b: Int, expected: Int) {
    assertEq(a + b, expected)
}