// 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()

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

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

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()

@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)
}

Flame v0.6.8•Sixth Spark

FlameProgramming Language

A type-safe language built to work alongside Rust — featuring Smart ABI interop, memory safety without GC, and application-specific native runtimes.

Get Started Try Online Playground Explore Standard Library

Why Flame?

Smart ABI Rust Interoperability

Built to work alongside Rust. Import native crates or custom plugins directly with import native.uuid using Flame’s typed Smart ABI.

No Garbage Collector, Pure Safety

Rust-style ownership and borrowing checks provide deterministic memory safety and data-race prevention without garbage collection 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 automatic stripping during release builds.

Flame in Production & Tailored Architecture

Unlike traditional languages that require massive universal runtimes with unused standard libraries and heavy interpreters, Flame generates a specialized native runtime for each application. Blaze analyzes imported modules and .fmi interface contracts, emitting an optimized, purpose-built native binary via Rust, Cargo, and LLVM.

No Rust in Production

The runner container does not need rustc, cargo, or .rs source files. All native plugins and dependencies are statically baked into the executable.

Minimal Image Size (<80MB)

By excluding compilation toolchains and dead standard library subsystems, production container images typically stay under 80MB.

Instant Boot Time

Specialized native runtimes start in milliseconds without JVM warmup, V8 cold-start overhead, or universal interpreter startup lag.

Hardened Security

Radically minimized attack surface with zero package managers, build compilers, or unreferenced native code exposed in production.

Dive Deeper into Flame

Architecture & Compiler Deep-DiveLearn how the Blaze compilation pipeline specializes runtimes, compiles .fmi interfaces, and maintains zero GC overhead.

Production & Docker Deployment GuideExplore multi-stage Docker builds, lean distroless runner setups, and production cloud orchestration with Flame.