libfirm VS wasmtime

Compare libfirm vs wasmtime and see what are their differences.


graph based intermediate representation and backend for optimising compilers (by libfirm)


A fast and secure runtime for WebAssembly (by bytecodealliance)
Our great sponsors
  • InfluxDB - Access the most powerful time series database as a service
  • SonarQube - Static code analysis for 29 languages.
  • SaaSHub - Software Alternatives and Reviews
libfirm wasmtime
2 141
387 11,741
2.3% 3.9%
0.0 9.9
7 days ago 6 days ago
C Rust
GNU Lesser General Public License v3.0 only Apache License 2.0
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.


Posts with mentions or reviews of libfirm. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2022-12-29.


Posts with mentions or reviews of wasmtime. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-03-02.
  • How to Debug WASI Pipelines with ITK-Wasm
    6 projects | | 2 Mar 2023
    A full debugging session is also possible after LLDB >= 13 and Wasmtime are installed.
  • Using WASM for a plugin system in Rust? (generate code at runtime and then hot reloading it as a library)
    6 projects | | 22 Feb 2023
    The only runtime that at least partially implements component model is wasmtime. But, as everything with component model, it is still WIP.
  • How to run WebAssembly from your Rust Program
    3 projects | | 13 Feb 2023
    //Original Code from //Adapted for brevity use anyhow::Result; use wasmtime::*; fn main() -> Result<()> { println!("Compiling module..."); let engine = Engine::default(); let module = Module::from_file(&engine, "hello.wat")?; //(1) println!("Initializing..."); let mut store = Store::new( &engine, () ); //(2) println!("Creating callback..."); let hello_func = Func::wrap(&mut store, |_caller: Caller<'_, ()>| { println!("Calling back..."); }); //(3) println!("Instantiating module..."); let imports = [hello_func.into()]; let instance = Instance::new(&mut store, &module, &imports)?; println!("Extracting export..."); let run = instance.get_typed_func::<(), ()>(&mut store, "run")?; //(4) println!("Calling export..."); store, ())?; //(5) println!("Done."); Ok(()) }
  • Ruby Adds Support for WebAssembly: What is WebAssembly and how it benefits Ruby devs?
    3 projects | | 10 Feb 2023
    Running a Wasm application outside the browser requires an appropriate runtime that implements the WebAssembly VM and provides interfaces to the underlying system. There are a few competing solutions in this field, the most popular being wasmtime, wasmer, and WAMR.
  • Blog Post: Next Rust Compiler
    7 projects | | 25 Jan 2023
    In 2022, we merged a project that has a huge impact on compile times in the right scenarios: incremental compilation. The basic idea is to cache the result of compiling individual functions, keyed on a hash of the IR. This way, when the compiler input only changes slightly – which is a common occurrence when developing or debugging a program – most of the compilation can reuse cached results. The actual design is much more subtle and interesting: we split the IR into two parts, a “stencil” and “parameters”, such that compilation only depends on the stencil (and this is enforced at the type level in the compiler). The cache records the stencil-to-machine-code compilation. The parameters can be applied to the machine code as “fixups”, and if they change, they do not spoil the cache. We put things like function-reference relocations and debug source locations in the parameters, because these frequently change in a global but superficial way (i.e., a mass renumbering) when modifying a compiler input. We devised a way to fuzz this framework for correctness by mutating a function and comparing incremental to from-scratch compilation, and so far have not found any miscompilation bugs.
  • Cranelift's Instruction Selector DSL, ISLE: Term-Rewriting Made Practical
    2 projects | | 21 Jan 2023
    If you've got more thoughts on this, filing an issue is always a good way to either start a discussion or at least put the information in a permanent place we can find later! It looks like we don't have any issues related to this in our tracker at the moment.
  • Kernel-WASM: Sandboxed kernel mode WebAssembly runtime for Linux
    4 projects | | 20 Jan 2023
    This actually seems to be experimentally supported by some runtimes, like wasmtime[0].


  • Allocating Heap with Cranelift
    3 projects | | 19 Jan 2023
    So, does someone know how to allocate memory on the heap using Cranelift? I've seen instructions like heap_addr, heap_load and heap_store so there should be some way (altrough I don't understand why we can't use the normal load and store here..). create_heap would be my best guess, but it takes a HeapData which confuses me. Dafuq is an index_type, HeapStyle and offset_guard_size? How do I get a GlobalValue for it? How do I free it? Or maybe I should just use C's malloc/free instead... On the other hand direct support for heaps seems to be removed? Sigh. I'm confused.
  • Is coding in Rust as bad as in C++? A practical comparison
    15 projects | | 5 Jan 2023
    The only path forward here would be to bend rustc/MIR for streaming codegen (and then bolt it to something like lightbeam).
  • Hey Rustaceans! Got a question? Ask here (1/2023)!
    11 projects | | 3 Jan 2023
    But, am I mistaken in thinking that it isn't available for armv6 (based on the releases seen here)

What are some alternatives?

When comparing libfirm and wasmtime you can also consider the following projects:

wasmer - 🚀 The leading WebAssembly Runtime supporting WASI and Emscripten

SSVM - WasmEdge is a lightweight, high-performance, and extensible WebAssembly runtime for cloud native, edge, and decentralized applications. It powers serverless apps, embedded functions, microservices, smart contracts, and IoT devices.

quickjs-emscripten - Safely execute untrusted Javascript in your Javascript, and execute synchronous code that uses async functions

wasm-bindgen - Facilitating high-level interactions between Wasm modules and JavaScript

wasm3 - 🚀 A fast WebAssembly interpreter, and the most universal WASM runtime

wasm-pack - 📦✨ your favorite rust -> wasm workflow tool!


trunk - Build, bundle & ship your Rust WASM application to the web.

mold - Mold: A Modern Linker 🦠

pybind11 - Seamless operability between C++11 and Python

PyO3 - Rust bindings for the Python interpreter

wasi-libc - WASI libc implementation for WebAssembly