The Mumpix Family

01 / 04STORAGE ENGINE

MumpixDB

WAL-BACKED HIERARCHICAL KEY-VALUE STORE

The foundation of the entire Mumpix stack. MumpixDB is a WAL-backed hierarchical key-value engine using MUMPS-style ^ delimiters for deterministic BTree scan order. Every write is versioned with a generation counter. Live prefix watchers, crash recovery, snapshot compaction, and protected system prefixes are all built in — no plugins.

WAL journaling — crash-safe, append-only log
Snapshot compaction — triggers at 8 MB WAL size
BTree storage — O(log n) prefix scan, deterministic order
Live watchers — typed event frames on any prefix write
Symlinks — keyref, url, latest, view, mirror, cas
Protected prefixes — cas^, audit^mcp^ are system-only

$npm i mumpix

# Cargo.tomlmumpixdb = "0.1"

01

// write & watch

db.set("memory^user^name", "Carrera")

db.watch("memory^", event => {

  // {key, value, previous, generation}

  console.log(event)

})

// scan any prefix

const rows = db.scan("memory^")

// [{key:"memory^user^name",value:"Carrera"}]

02 / 04FILE BRIDGE

MumpixFS

CHUNK-BASED FILE STORAGE OVER THE KEY STORE

MumpixFS bridges the filesystem into the Mumpix key tree. Any file — binary, PDF, image, audio — is split into 64 KB base64 chunks and stored as structured key nodes. MIME detection, alias symlinks, full-text extraction, content-addressed deduplication with SHA-256, and complete round-trip fidelity are built in.

64 KB chunks — no blob size limits, just more keys
MIME detection — 20+ types, fallback to octet-stream
CAS dedup — SHA-256, zero duplicate chunks ever stored
Alias symlinks — files^alias^report → files^m4k9z2
Text index — UTF-8 content stored at ^text for search
Version pointers — latest^ and history^ via symlink tree

$npm i mumpixfs

# REST endpointsPOST /v1/files/importGET /v1/files/:id_or_alias

02

// import any file

const r = await importFile(db, {

  name: "report.pdf",

  data: buffer,

  alias: "report"

})

// {id, chunkCount:16, mime}

// export by alias

const file = await exportFile(db, "report")

// {name, mime, bytes}

03 / 04FRONTEND ENGINE

MumpixFE

FRONTEND RUNTIME WITH BACKEND-COMPATIBLE MUMPIX API

MumpixFE is the Mumpix frontend runtime. It lets you run Mumpix directly in the browser, independent from the backend, while keeping the same key model and behavior you use server-side. Build local-first apps that read, write, scan, and watch keys on the frontend with the same developer experience as backend Mumpix.

Frontend-native runtime — run Mumpix in-browser without backend dependency
Backend-compatible API — same key behavior, scans, and watchers as backend Mumpix
File viewer — import, preview, and export any format
Watch feed — stream key events from any prefix
CAS dashboard — chunk map, dedup savings, content graph
Zero UI deps — single .jsx package, drops into any React app

$npm i mumpixfe

import MumpixFE from 'mumpixfe'// <MumpixFE mode="local" />

03

import MumpixFE from 'mumpixfe'

export default function App() {

  return (

    <MumpixFE

      mode="local"

      watchPrefix="memory^"

    />

  )

}

04 / 04SYSTEM DAEMON

MumpixSL

MUMPIXD — STATIC RUST BINARY, RUNS ON-DEVICE

MumpixSL is the production system daemon — a static Rust binary with zero runtime dependencies that runs the entire Mumpix stack as an OS service on Android and Linux phones. REST on :7770, WebSocket on :7771, Unix socket IPC. WAL engine, file layer, symlinks, delta sync. The whole stack in ~4 MB.

~4 MB binary — musl static, zero runtime deps
3 transports — REST · WebSocket · Unix socket
ARM64 — Volla Phone, Ubuntu Touch, Android
Delta sync — device-to-device, generation-based LWW
Systemd ready — .service unit and .deb package included
Kotlin + Python SDKs — coroutine-native client libraries

$npm i mumpixsl

# Cross-compile for ARM64cargo build --release--target aarch64-unknown-linux-musl

04

# health check

$ curl http://127.0.0.1:7770/v1/health

{"ok":true,"status":"running"}

# IPC via unix socket

$ printf '{"id":1,"op":"ping"}\n' | nc -U /run/mumpixd/mumpixd.sock

{"id":1,"ok":true,"pong":true}

One substrate. Four layers.

MumpixDB

MumpixFS

MumpixFE

MumpixSL

Pick what you need.