⚡ Features → 📊 Benchmarks → 🔬 Simulator → 💻 Quickstart → GitLab Repository
Pure Go + TinyGo WASM

The Universal Performance & Reliability Fabric Универсальная Среда Скорости и Надежности

15.57 GB/s Memory Streaming · 8-Byte Blind SFU · Zero-Modification Recovery 15.57 ГБ/с в памяти · 8-байтный Blind SFU · Автономное восстановление

Wasmee transparently accelerates local IPC and microservice sockets, blind-forwards real-time media without server transcoding, and guarantees deterministic execution recovery with zero application code changes. Wasmee прозрачно ускоряет локальный IPC и сокеты микросервисов, пересылает медиапотоки без серверного транскодирования и гарантирует детерминированное восстановление процессов с нулевыми изменениями кода.

Explore on GitLab
100% In-Process Execution · 0 Network Daemons · Apache-2.0 License 100% In-Process исполнение · 0 внешних демонов · Лицензия Apache-2.0

Core Architectural Pillars

⚡
wasmee.Pipe()

Lock-Free SPSC Memory Pipes Lock-Free SPSC Пайпы

Single-Producer Single-Consumer lock-free ring buffer with 64-byte cache-line padding. Delivers 15.57 GB/s throughput and 495 ns roundtrip latency with 0 heap allocations, fully compliant with Go net.Conn. Однонаправленные lock-free кольцевые буферы с выравниванием по строкам кэша процессора. Обеспечивают 15.57 ГБ/с и 495 нс задержки с 0 аллокаций в куче, реализуя стандартный Go-интерфейс net.Conn.

🛡️
wasmee.Frame

8-Byte Wire Protocol & Blind SFU 8-байтный Wire Protocol & Blind SFU

Ultra-compact 8-byte framing header enabling line-rate blind forwarding. The relay executes 0 cryptographic operations (100% E2EE client encryption) and routes streams via port 443 with zero NAT/firewall friction. Минимальный 8-байтный заголовок фрейма. Релей выполняет 0 криптографических операций, пересылая сквозной зашифрованный трафик на скорости линии через единый порт 443 без проблем с NAT и файрволами.

🔄
durable.NewRunner()

Deterministic Durable Workflows Durable Execution & Оплог-восстановление

Microsecond state checkpoints via FNV-64a dirty-page diffing and transparent net/http oplog replay. Workflows survive sudden SIGKILL or power outages and resume with 100% idempotency. Микросекундные чекпоинты через хэширование страниц памяти FNV-64a и прозрачный перехват net/http. Воркфлоу переживают внезапный SIGKILL и восстанавливаются с 100% детерминизмом без повторных списаний.

🚀
wasmee.ListenUnix()

Transparent Socket Acceleration Прозрачное ускорение Unix-сокетов

Drop-in acceleration for existing microservices. Replaces Linux AF_UNIX domain sockets with Wasmee memory pipes dynamically, boosting throughput 4.21x (up to 1.55M packets/s) without changing code or socket paths. Мгновенное ускорение существующих сервисов. Подменяет стандартный AF_UNIX на быстрый кольцевой пайп на лету, повышая пропускную способность в 4.21 раза (до 1.55 млн пакетов/с) без изменения путей сокетов или логики.

Interactive Latency Simulator

Wasmee
Wasmee Pipe
Throughput
Linux AF_UNIX
Throughput
TCP Loopback (:127.0.0.1)
Throughput

Live Verified Micro-Benchmarks

● 100% Reproducible
⚡ Wasmee Lock-Free SPSC Pipe 30.09x vs TCP
Throughput 2,016,709 ops/s (15.57 GB/s)
Latency 495 ns
Allocs: 0 B/op (0 allocs)
Standard Linux TCP Loopback (:127.0.0.1) 1.00x
Throughput 67,012 ops/s (518 MB/s)
Latency 14.92 µs
Allocs: Kernel TCP buffers
🚀 Wasmee Transparent Unix Interception 4.21x vs AF_UNIX
Throughput 1,550,461 pkts/s (390.4 MB/s)
Latency 644 ns
Allocs: Zero-syscall in-memory
Standard Linux AF_UNIX Socket 1.00x
Throughput 368,083 pkts/s (92.7 MB/s)
Latency 2.716 µs
Allocs: Kernel socket buffers
🔥 Wasmee In-Memory Splice() Direct Line Speed
Throughput 74.3 GB/s
Latency 55 ns
Allocs: 0 heap allocs

Zero-Modification Integration

package main

import (
    "github.com/nativebpm/wasmee"
)

func main() {
    // 15.57 GB/s lock-free SPSC duplex in-memory pipe (0 heap allocations)
    c1, c2 := wasmee.Pipe()
    defer c1.Close()
    defer c2.Close()

    go func() {
        c1.Write([]byte("Hello from zero-copy Wasmee memory ring!"))
    }()

    buf := make([]byte, 128)
    n, _ := c2.Read(buf)
    println(string(buf[:n]))
}
package main

import (
    "github.com/nativebpm/wasmee"
)

func main() {
    // Intercepts and accelerates /tmp/app.sock: 4.21x higher throughput!
    ln, _ := wasmee.ListenUnix("/tmp/app.sock")
    defer ln.Close()

    // Client connects transparently via standard net.Conn interface
    conn, _ := wasmee.DialUnix("/tmp/app.sock")
    defer conn.Close()
}
package main

import (
    "github.com/nativebpm/wasmee/durable"
)

func main() {
    // In-process pure Go execution with automated FNV-64a state checkpointing
    res, err := durable.NewRunner().
        WithWasmBytes(wasmBinary).
        WithStore(store).
        WithSessionID("order-99").
        WithEntrypoint("execute").
        Run()

    // Workflows survive sudden SIGKILL or power cuts and resume with 100% idempotency
    _ = res
    _ = err
}