MoonBit: The Next‑Gen WebAssembly Language for Cloud and Edge Computing

MoonBit Overview

MoonBit (月兔) is a programming language created by a Chinese developer team, recently featured on Hacker News. It is designed specifically for cloud computing and edge computing, providing an end‑to‑end WebAssembly toolchain that integrates development, compilation, testing, and deployment.

Key Features

Generates significantly smaller WASM files compared to existing solutions.

Higher runtime performance.

Advanced compile‑time performance.

Simple yet practical data‑oriented language design.

The language offers a late‑comer advantage over mainstream languages by supporting multiple back‑ends, delivering high code generation performance and small binary size. It includes efficient incremental code parsing and type checking, multi‑paradigm programming with a functional core and OOP style, multi‑level intermediate code optimizations, low‑latency intelligent IDE, and more.

Future plans include adding a trait system, robust memory management and garbage collection, expanding the standard library and ecosystem, improving FFI mechanisms, and integrating AIGC technologies.

Team and Status

MoonBit is led by Zhang Hongbo, head of the Basic Software Center at the Guangdong‑Hong Kong‑Macao Greater Bay Area Digital Economy Research Institute (IDEA Institute). Zhang has contributed to languages such as OCaml, ReScript, and Flow, and authored most components of the ReScript toolchain.

The project is currently in a pre‑alpha experimental stage. An online IDE is available at https://try.moonbitlang.com without any installation or server dependencies. Documentation can be found at https://github.com/moonbitlang/moonbit-docs . The compiler is expected to reach beta status by the end of Q2 2024.

Sample Code

Fibonacci function implemented in MoonBit, Go, and Rust:

// MoonBit
func fib(num : Int) -> Int {
  fn aux(n, acc1, acc2) {
    match n {
      0 => acc1
      1 => acc2
      _ => aux(n - 1, acc2, acc1 + acc2)
    }
  }
  aux(num, 0, 1)
}

// Go
func fib(n int) int {
  var aux func(int, int, int) int
  aux = func(n, acc1, acc2 int) int {
    switch n {
    case 0:
      return acc1
    case 1:
      return acc2
    default:
      return aux(n-1, acc2, acc1+acc2)
    }
  }
  return aux(n, 0, 1)
}

// Rust
fn fib(n: i32) -> i32 {
  fn aux(n: i32, acc1: i32, acc2: i32) -> i32 {
    match n {
      0 => acc1,
      1 => acc2,
      _ => aux(n - 1, acc2, acc1 + acc2),
    }
  }
  aux(n, 0, 1)
}

Benchmark Results

Benchmark comparing the Fibonacci implementation across MoonBit, Go, and Rust shows MoonBit’s competitive performance.

Full benchmark details are available at https://moonbitlang.github.io/moonbit-docs/benchmark/fibonacci/ .

Related links: https://zh.moonbitlang.com/