explaingit

syrusakbary/wasmjit

Analysis updated 2026-07-18 · repo last pushed 2018-10-05

CAudience · developerComplexity · 5/5DormantLicenseSetup · hard

TLDR

Wasmjit is a small runtime that runs WebAssembly code outside a browser on Linux, including a kernel-module mode for extra-fast system calls.

Mindmap

mindmap
  root((Wasmjit))
    What it does
      Runs WASM outside browser
      User-space mode
      Kernel module mode
    Why it matters
      Faster syscalls
      No browser needed
      C90 portable core
    Use cases
      Compiled C or C++
      High-perf web servers
      Custom file systems
    Audience
      System programmers
      Embedded developers
    Caveats
      Active development
      Security of dev wasm

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

What do people build with it?

USE CASE 1

Run C/C++ code compiled to WebAssembly directly on a Linux server without needing a browser.

USE CASE 2

Load performance-critical WebAssembly programs into the Linux kernel itself for faster syscall handling.

USE CASE 3

Build a high-performance web server or custom file system where every microsecond of syscall latency matters.

What is it built with?

CWebAssemblyLinux kernelEmscripten

How does it compare?

syrusakbary/wasmjitac000/find-flvacc4github/kdenlive-omnifade
Stars0
LanguageCCC
Last pushed2018-10-052013-04-05
MaintenanceDormantDormant
Setup difficultyhardmoderatemoderate
Complexity5/52/52/5
Audiencedeveloperdevelopergeneral

Figures from each repo's GitHub metadata at analysis time.

How do you get it running?

Difficulty · hard Time to first run · 1h+

Kernel module mode requires careful /dev/wasm access control, not all Emscripten features are supported yet.

Free to use, modify, and distribute for any purpose, including commercial use, under the MIT license.

In plain English

Wasmjit is a small runtime that lets you run WebAssembly code, a portable, compact format for executing programs, outside of a web browser. Think of it as a way to take code compiled to WebAssembly (often from C or C++ using a tool called Emscripten) and run it on your Linux machine or server, without needing a browser. The interesting twist is that Wasmjit can run WebAssembly in two very different places. The standard way is in user-space, like any normal program, you compile WebAssembly code and execute it through Wasmjit on your computer. But the project's main innovation is a Linux kernel module that runs WebAssembly code directly inside the Linux kernel itself. This sounds exotic, but it has a real performance benefit: when your WebAssembly program needs to talk to the operating system (for example, a web server handling requests or a file system), it can do so as fast function calls rather than the slower back-and-forth between user programs and the kernel. For syscall-heavy workloads, this can be noticeably quicker, especially on modern systems with Meltdown mitigations. Who would use this? System programmers, embedded systems developers, or anyone running performance-critical code that's already written in C/C++ and compiled to WebAssembly. The kernel module mode is particularly interesting for infrastructure services like high-performance web servers or custom file systems where every microsecond counts. Since the core is written in C90, a very old and portable C standard, it's designed to be small and easy to port to different environments. The project is still actively under development and doesn't yet support all Emscripten features, but it's permissively licensed under MIT, so it's free to use and modify. The README notes that the kernel module does have a security consideration: you need to be careful about who can access the /dev/wasm device, since untrusted code could potentially use it to consume excessive memory.

Copy-paste prompts

Prompt 1
Show me how to compile a simple C program to WebAssembly with Emscripten and run it using Wasmjit in user-space.
Prompt 2
Explain how Wasmjit's Linux kernel module mode speeds up syscall-heavy WebAssembly workloads compared to user-space execution.
Prompt 3
Walk me through the security considerations of exposing /dev/wasm when using Wasmjit's kernel module.
Prompt 4
Help me identify which Emscripten features aren't yet supported by Wasmjit before I try to port my project.

Frequently asked questions

What is wasmjit?

Wasmjit is a small runtime that runs WebAssembly code outside a browser on Linux, including a kernel-module mode for extra-fast system calls.

What language is wasmjit written in?

Mainly C. The stack also includes C, WebAssembly, Linux kernel.

Is wasmjit actively maintained?

Dormant — no commits in 2+ years (last push 2018-10-05).

What license does wasmjit use?

Free to use, modify, and distribute for any purpose, including commercial use, under the MIT license.

How hard is wasmjit to set up?

Setup difficulty is rated hard, with roughly 1h+ to a first successful run.

Who is wasmjit for?

Mainly developer.

Open on GitHub → Explain another repo

This repo across BitVibe Labs

Verify against the repo before relying on details.