Every language. One sandboxed runtime.

Every language, in one polyglot WebAssembly runtime: compile a real multi-module project to wasm and run it side by side with your scripts, all on one engine. Sealed by default, deterministic to the last bit, fuel-metered. burn compile turns any program into a single portable artifact; burn run executes it anywhere with no recompile and zero config.

Install Burn

$ Copy
Get started See the languages Package Registry
Every language compiles to WebAssembly Sealed by default · grant net / fs / env
// First-class languages

Write in the language you reach for.
Ship the same WebAssembly.

Each one compiles to WebAssembly with its own native toolchain, and each one has a REPL. Pick a tab.

main.rs 

          

          

        

        

          
Rust

          

          

        

      

    

  


  
  

    

      

        // Sub-millisecond sandbox
        
A sandboxed run in under a millisecond.

        
Firecracker, Daytona, a Docker container: each boots a fresh sandbox for every run. A resident sandbox runtime skips that, so a sandboxed run takes about 500 microseconds and turns around a couple thousand times a second.

      


      

        

          ~500 µs per sandboxed run
          Firecracker, Daytona, E2B and a container each boot a fresh sandbox for every run, paying the startup each time. A resident sandbox runtime does about 2,000 a second per core.
        


        
time to a run (lower is better)

        


        
runs per second (more is better)

        


        

          afterburner measured locally. Published startup figures: Firecracker ~125 ms, Daytona <90 ms, E2B ~150 ms, Docker container ~1-2 s.
        

      

    

  


  
  

    

      

        

          // Live demo
          
One runtime runs
all of them.

          
Point burn at a source file and it picks the toolchain, compiles to wasm, and runs the module,
            in C, Rust, Go, TypeScript, or Python. Point it at a folder and it builds the whole package.

          
Need a sandbox? --sandbox seals every capability; --allow-fs,
            --allow-net, --allow-env grant exactly the surface a program needs. Same run, same
            bytes, every time.

        

        

          

            
            ~/polyglot · zsh
          

          

        

      

    

  


  
  

    

      

        

          // What's in the box
          
A runtime that runs anything,
 and trusts nothing.

        

        

          WebAssembly is the common substrate. Afterburner adds the toolchains, the sandbox, the determinism, and the
          packaging on top.
        

      


      

        

          
01

          
Every language, one engine

          
Every language compiles to WebAssembly and runs side by side.
            One burn binary, one execution model, no per-language runtime to install.

        

        

          
02

          
Native multi-module packages

          
A real cargo project, a go module with sub-packages, a multi-file C/C++ project. Cross-module calls and
            language-native encapsulation (pub, exported caps, static), not one file dressed
            up.

        

        

          
03

          
A REPL for every language

          
burn repl --lang rust, go, c, cpp, ts, or
            js. The compiled languages run evcxr-style: each line recompiles, session state carries
            forward. Toolchain errors are clear, never a crash.

        

        

          
04

          
Deterministic by construction

          
Canonical NaN, relaxed-SIMD pinned to one result, threads off, fuel-metered. The same module returns the
            same bytes on an AVX-512 server and an Arm laptop. Reproducible runs, no flake.

        

        

          
05

          
Sealed by default

          
A program starts with no filesystem, no network, no environment. Grant exactly what it needs with
            --allow-fs, --allow-net, --allow-env. Every capability is denied
            until you say otherwise.

        

        

          
06

          
Fuel, memory, and time caps

          
A deterministic instruction budget bounds every run; a hard memory cap and a wall-clock timeout back it up.
            An infinite loop surfaces as FuelExhausted, not a hung host.

        

        

          
07

          
The .afb package format

          
Content-addressed by SHA-256, byte-reproducible (sorted entries, zeroed timestamps, zstd). A package
            carries its manifest, its sealed capability manifold, its source, and an optional precompiled
            main.wasm.

        

        

          
08

          
A package registry

          
burn publish, burn install, burn add, burn search.
            Dependencies pin by digest in afb.toml; installs land in a shared content-addressed cache.
            Reproducible from the same digest, every time.

        

        

          
09

          
Compile to a portable wasm artifact

          
burn compile turns your program into a single portable artifact burn run executes
            anywhere with no recompile and zero config. Drop it in a container and go. Runtimes auto-fetch on first
            use; deps with only a native build are rejected at compile time with a clear message.

        

      

    

  


  
  

    

      

        

          // One runtime. Every workflow.
          
Whatever the language, the command is burn.

        

        
Run a single file, build a multi-module package, open a REPL, or seal the sandbox. The same controls span
          every language.

      


      

        

          
          
          
          
          
          
          
        


        

          

            
            shell
          

          

            

          

          

            ⟶
            
          

        

      

    

  


  
  

    

      

        // Real packages, not single files
        
A cargo project. A go module.
A C/C++ project. Compiled whole.

        
Afterburner packages are native multi-module projects built by their own toolchain. Exported APIs over
          private helpers, cross-module calls, the encapsulation each language already gives you, compiled into one
          self-contained WebAssembly module.

      


      

        

          

            
            rust-multimodule/
          

          


afb.toml            # name, namespace, version, entry
manifold.json       # sealed capability set
Cargo.toml
source/
├─ main.rs          # calls across both modules
├─ geometry.rs      pub fn rectangle_area(..)
│                    # private fn scale(..) stays internal
└─ stats/
   └─ mod.rs        pub fn mean(..)  # sum(..) private

# Go: capitalized identifiers exported across packages.
# C/C++: all of source/** linked into one WebAssembly module,
#        static helpers encapsulated behind the header.

          

        


        

          

            
Build it, run it, ship it

            
One workflow, every language. Scaffold, build, package, publish.

            
    
              
  1. 1burn new geo --lang rust scaffolds a project with a sealed
                  manifold.
    2. 
              
  2. 2burn run ./geo compiles the whole package and runs the
                  entry.
    3. 
              
  3. 3burn package ./geo -o geo.afb builds a content-addressed
                  .afb, source plus optional precompiled wasm.
    4. 
              
  4. 4burn publish geo.afb uploads it; burn install
                    geo pulls it back, digest-pinned.
    5. 
            

          

          

            
Dependencies pin by digest

            
Declare packages in afb.toml under [dependencies], pinned to a
              sha256: digest. burn add writes the pin; installs resolve and land in a shared
              content-addressed cache, so the same digest always rebuilds the same bytes.

          

        

      

    

  


  
  

    

      

        // You're in control
        
Every limit, every gate,
 configurable.

        
Nothing is hardcoded. Set the budgets that match your workload. Deny every capability by default, then grant
          exactly the surface a program needs. Every knob is on the CLI and in the package manifold.

      


      

        

          

            Fuel
            deterministic
          

          
Instruction budget

          
A deterministic op counter bounds every run. A tight loop trips the gauge regardless of
            host speed and surfaces as FuelExhausted. Set the budget, or disable it.

          
--fuel your_budget

          

            

          

        


        

          

            Memory
            configurable
          

          
Per-run memory cap

          
A hard cap on linear memory, enforced per run. Over-budget growth fails inside the
            module. Your host never gets OOM-killed by a misbehaving guest.

          
--memory your_cap

          

            

          

        


        

          

            Timeout
            configurable
          

          
Wall-clock kill switch

          
A backstop for work that doesn't burn fuel. Independent of fuel and memory. Set it in
            milliseconds, whatever fits the workload.

          
--timeout your_deadline

          

            

          

        


        

          

            Determinism
            always on
          

          
Reproducible execution

          
Canonical NaN, relaxed-SIMD pinned to one result, threads disabled. The same module
            yields byte-identical output across host CPUs. Run it again and get the same answer.

          
canonical NaN · threads off · pinned SIMD

          

            

          

        


        

          

            Filesystem
            scoped
          

          
Read & write roots

          
Sealed until granted. Whitelist exact roots, read-only or read-write. A program reaches
            only the paths you list, and nothing else.

          
--allow-fs=./data,/tmp/jobs

        


        

          

            Network
            scoped
          

          
Hostname allow-list

          
Outbound access gated by host. Use host, host:port,
            *.suffix, or *. The program reaches exactly the services you allow.

          
--allow-net=api.example.com,*.trusted.io

        

      

    

  


  
  

    

      

        

          // Built for
          
Wherever you run code
you can't fully trust.

        

      

      

        

          

            
              
              
            
          

          
Polyglot plugins and extensions

          
Let customers extend your product in the language they know, Rust, Go, C, TypeScript, or Python. One
            sealed runtime gates every one of them the same way, so a plugin's bug stays out of your process.

          
customer codeisolation

        

        

          

            
              
            
          

          
Reproducible data UDFs

          
Ship a transform as a package and pipe rows through burn thrust. Determinism means the same
            input gives the same output on every machine, byte for byte, in whichever language fits the job.

          
deterministictransforms

        

        

          

            
              
            
          

          
Locked-down compute handlers

          
Each request runs sealed by default. Outbound HTTP needs an allow-list; the filesystem stays off until you
            grant it. Production-shaped isolation you can test on your laptop.

          
edge computehandlers

        

        

          

            
              
            
          

          
Scriptable, capability-scoped steps

          
Replace ad-hoc shell with a version-pinned package that gets only the capabilities the step needs.
            burn run --allow-fs=./out --allow-env=CI build.ts beats a brittle 200-line Bash file.

          
automationCI

        

        

          

            
              
              
            
          

          
Ship a portable artifact, not a source tree

          
burn compile produces a single portable artifact any host can burn run with no
            recompile and no config. Drop it in a container, send it over a release pipeline, or cache it by digest.
            One artifact, any supported host.

          
packagingportability

        

        

          

            
              
              
            
          

          
Sandboxed runs for AI agents

          
An agent emits Python, JavaScript, or Go you have never seen. burn run --sandbox runs it sealed,
            no network or filesystem until you grant it, and deterministic every time, so a bad generation hits an empty
            box instead of yours.

          
AI agentsuntrusted code

        

      

    

  


  
  

    

      
One runtime. Every language. Full burn.

      
Install the binary, point it at any source file, and watch it compile to WebAssembly and run,
        sealed and deterministic.

      

        

          
          
          
        

        

          $
          
          Copy
        

        
Pin a version with BURN_VERSION=vX.Y.Z · custom dir with
          BURN_INSTALL=/usr/local/bin
        

      

      

        Read the docs →