NXS — Nexus Standard

A bi-modal serialization format that opens a 1.5 GB dataset in under 2 microseconds.

Author: Micael Malta · Live demos →

JSON was designed to be read by humans and transmitted over HTTP — not to serve as an in-memory query layer for millions of records. At scale, the parsing overhead becomes the bottleneck: every field is a heap allocation, every number is a string that must be converted, and the entire payload must be decoded before the first record can be accessed. CSV has the same decode cost with no type information at all. Protobuf solves the type problem but sacrifices human readability and requires schema compilation tooling that couples producers and consumers. None of them can be memory-mapped and queried without a full parse pass, and none are safe to share across threads or web workers without copying.

NXS (Nexus Standard) is a bi-modal data format with two representations. The text format (.nxs) is a sigil-typed, human-readable source language compiled by a Rust tool. The binary format (.nxb) is a zero-copy wire format designed around CPU-native memory alignment. Because the binary layout encodes type and offset information at write time, a reader can locate any record by index, decode any single field by key, and run columnar reducers over millions of records — all without parsing the file.

All benchmarks use an 8-field record schema on an Apple M-series (arm64), macOS. See [BENCHMARK.md](./BENCHMARK.md) for the full cross-language results.

Span schema: 14 services, 20 OTel operation names, realistic per-op duration distributions, ~15% payload rate.

All ten implementations read the same .nxb binary produced by the Rust compiler.

Live at nxs.covibe.us

cd js && python3 server.py   # required for SharedArrayBuffer (sets COOP/COEP headers)
# open http://localhost:8000

Every value in a .nxs file carries a sigil that declares its machine type — no schema file, no generated code:

user {
    id:         =42
    username:   "alice_wonder"
    email:      "alice@example.com"
    age:        =31
    balance:    ~2874.99
    active:     ?true
    role:       $admin
    created_at: @2022-03-15
    tags:       [$admin, $beta, $verified]
    address {
        city:    "Springfield"
        country: "US"
    }
}

More examples in [examples/](./examples/) and full API usage in [GETTING_STARTED.md](./GETTING_STARTED.md).

A .nxb file is four segments: a 32-byte preamble, an embedded schema header, a data sector, and a tail-index. The tail-index holds one (KeyID u16, AbsoluteOffset u64) pair per top-level record and is located by reading the final FooterTailPtr before MagicFooter — enabling O(1) random access with a single seek. All atomic values are 8-byte aligned, allowing zero-copy reads on any little-endian platform.

[Preamble 32B][Schema Header][Data Sector][Tail-Index]

# Generate test fixtures (required by all language benchmarks and tests)
cd rust && cargo run --release --bin gen_fixtures -- ../js/fixtures 1000

# Compile a .nxs source file
cargo build --release
./target/release/nxs ../examples/user_profile.nxs

# Run all language tests
cd js     && node test.js ../js/fixtures
cd py     && python test_nxs.py ../js/fixtures
cd go     && go test ./...
ruby ruby/test.rb js/fixtures
php php/test.php js/fixtures
cd c      && make test && ./test ../js/fixtures
cd swift  && swift run nxs-test ../js/fixtures
cd kotlin && gradle run --args="../js/fixtures"
cd csharp && dotnet run -- ../js/fixtures

nxs-mcp is a Model Context Protocol server that lets an AI agent (Claude, Cursor, etc.) query .nxb files directly. It wraps the Rust CLI binaries as typed MCP tools with no additional parsing logic.

# Rust binaries must be built first
cd rust && cargo build --release && cd ..

make build-mcp          # → bin/nxs-mcp
make install-mcp        # install to /usr/local/bin (PREFIX=~/.local to override)
make test-mcp           # run unit tests
make lint-mcp           # gofmt + go vet

Add to .claude/settings.json:

{
  "mcpServers": {
    "nxs": {
      "command": "/absolute/path/to/bin/nxs-mcp",
      "args": [
        "--data-dir", "/absolute/path/to/js/fixtures/",
        "--bin-dir", "/absolute/path/to/rust/target/release/"
      ]
    }
  }
}

--data-dir makes all .nxb files in that directory discoverable as nxb:/// resources. --bin-dir tells the server where to find the Rust binaries (nxs-inspect, nxs-export, nxs-import, nxs). If omitted, the server searches ../rust/target/release/ relative to its own location, then $PATH.

Every language has its own GitHub Actions workflow triggered on changes to its directory. Fixtures are generated once by the Rust workflow and shared as artifacts. See [.github/workflows/](.github/workflows/).

Stable (v1.1). The spec now supports streamable sealed .nxb files: writers can emit schema and record bytes before the final Tail-Index is known, then seal with FooterTailPtr + MagicFooter. The conformance/ directory contains vectors validated by runners in Rust, JS, Python, Go, Ruby, PHP, C, Swift, Kotlin, and C#.