Judy arrays in pure Rust, rebuilt for modern hardware

Add core Expanse engine to your Cargo.toml:

cargo add expanse-trie

Usage example in Rust (Maps, Sets, Off-Heap Blobs, Lock-Free OCC):

use expanse_trie::{ExpanseMap, ExpanseSet, ExpanseBlobMap, SyncExpanseMap};

// 64-bit integer map with zero-allocation immediates
let mut map = ExpanseMap::new();
map.insert(42, 100);
assert_eq!(map.get(42), Some(100));

// Variable-length byte blob map with slab arena & hot metadata
let mut blobs = ExpanseBlobMap::new();
blobs.insert(1, b"hello expanse", 0x2A);
assert_eq!(blobs.get(1), Some(&b"hello expanse"[..]));

// Thread-safe optimistic OCC map (zero reader locks)
let sync_map = SyncExpanseMap::new();
sync_map.insert(99, 500);
let reader = sync_map.reader();
assert_eq!(reader.get(99), Some(500));

Install the official Python extension from PyPI (binary wheels for Linux, macOS, Windows):

pip install expanse-trie

Usage example in Python:

from expanse_trie import ExpanseMap, ExpanseSet, ExpanseStrMap, ExpanseBlobMap

# High-performance integer word map
m = ExpanseMap()
m[42] = 100
assert m[42] == 100

# Lexicographical String Trie (JudySL) with zero-copy prefix range scans
st = ExpanseStrMap()
st["https://api.service.internal/v1/users"] = 1001
assert "https://api.service.internal/v1/users" in st

# Off-heap Blob Map with 32-bit hot metadata & TTL pruning
bm = ExpanseBlobMap()
bm.insert(42, b"raw binary payload data", hot_meta=1750000000)
print(bm.get(42))  # b'raw binary payload data'

Install native Node.js / Bun / Deno bindings via npm (napi-rs v8+ with zero-copy Buffer views):

npm install @orieg/expanse
# or: bun add @orieg/expanse / pnpm add @orieg/expanse

Usage example in TypeScript / JavaScript:

import { ExpanseMap, ExpanseSet, ExpanseStrMap, ExpanseBlobMap } from '@orieg/expanse';

// Integer map with BigInt key support
const map = new ExpanseMap();
map.set(42n, 100n);
console.log(map.get(42n)); // 100n

// Off-heap blob map with Buffer / Uint8Array slices & hot metadata
const blobs = new ExpanseBlobMap();
blobs.set(1001n, Buffer.from("payload bytes"), 42);
const entry = blobs.getWithMeta(1001n);
console.log(entry?.payload.toString()); // "payload bytes"

Install the official .NET package from NuGet (multi-targeting .NET 8.0 & 9.0 with SafeHandle zero-GC memory safety):

dotnet add package Orieg.Expanse

Usage example in C#:

using Expanse;

// High-speed integer word map
using var map = new ExpanseMap();
map[42] = 100;
if (map.TryGet(42, out var val)) {
    Console.WriteLine($"Found: {val}");
}

// Off-heap blob map with zero-copy ReadOnlySpan<byte> views
using var blobs = new ExpanseBlobMap();
blobs.Set(1001, "Hello .NET"u8, hotMeta: 1);
if (blobs.TryGet(1001, out var payload, out var meta)) {
    Console.WriteLine($"Payload: {System.Text.Encoding.UTF8.GetString(payload)}");
}

Header-only modern C++20 RAII container wrapper (include/expanse.hpp):

// main.cpp - Header-only C++20 STL-compatible RAII wrapper
#include <expanse.hpp>
#include <iostream>
#include <span>

int main() {
    // RAII word map with std::forward_iterator compatibility
    expanse::map<uint64_t, uint64_t> map;
    map.insert(42, 100);
    std::cout << "Key 42 -> " << *map.get(42) << "
";

    // Binary-safe byte map (JudyHS) with std::string_view / std::span
    expanse::bytes_map<uint64_t> bmap;
    bmap.insert("embeddedbinarykey"sv, 999);

    // Off-heap blob map with zero-copy std::span
    expanse::blob_map blobs;
    std::string data = "cache-line aligned blob";
    blobs.insert(1, std::as_bytes(std::span(data)), 0x1F);
    return 0;
}

Compile with any C++20 compiler:

clang++ -std=c++20 -I/usr/include main.cpp -lexpanse -o main

Compile with modern expanse.h or drop-in Judy.h via pkg-config:

// main.c - Using modern Expanse C API
#include <expanse.h>
#include <stdio.h>

int main() {
    expanse_map_t map = NULL;
    expanse_map_insert(&map, 100, 500);
    
    uint64_t val = 0;
    if (expanse_map_get(map, 100, &val)) {
        printf("Found key 100 -> %llu
", (unsigned long long)val);
    }
    expanse_map_free(&map);
    return 0;
}

Build with gcc/clang:

gcc $(pkg-config --cflags expanse) main.c $(pkg-config --libs expanse) -o main

Configure the official Expanse APT repository (view APT repository page):

# 1. Add repository source
echo "deb [trusted=yes] https://orieg.github.io/expanse/apt/ stable main" | sudo tee /etc/apt/sources.list.d/expanse.list

# 2. Update index and install runtime, dev headers, and compat symlinks
sudo apt-get update
sudo apt-get install -y libexpanse1 libexpanse-dev libjudy-compat

Configure the official Expanse YUM/DNF repository (view RPM repository page):

# 1. Add repository configuration
sudo dnf config-manager --add-repo https://orieg.github.io/expanse/rpm/expanse.repo

# 2. Install runtime library, development headers, and libjudy compat
sudo dnf install -y libexpanse libexpanse-devel libjudy-compat

Add Java / JVM bindings via Maven Central (Java 22+ Foreign Function & Memory / JNI):

<!-- Maven pom.xml -->
<dependency>
    <groupId>io.github.orieg</groupId>
    <artifactId>expanse</artifactId>
    <version>0.7.0</version>
</dependency>

Usage example in Java:

import io.github.orieg.expanse.ExpanseMap;

try (var map = new ExpanseMap()) {
    map.put(42L, 100L);
    System.out.println("Value: " + map.get(42L));
}

RocksDB pluggable MemTable plugin (ExpanseMemTableRepFactory / integrations/rocksdb):

// RocksDB integration: 1.42x denser MemTable indexing (13.2 vs 18.7 B/entry)
#include <expanse_memtable.h>
#include <rocksdb/db.h>
#include <rocksdb/options.h>

int main() {
    rocksdb::Options options;
    // Plug in Expanse digital trie MemTable representation
    options.memtable_factory.reset(
        rocksdb::NewExpanseMemTableRepFactory(/*leaf_capacity=*/64, /*enable_prefix_trie=*/true)
    );

    rocksdb::DB* db;
    rocksdb::DB::Open(options, "/tmp/rocksdb_expanse", &db);
    db->Put(rocksdb::WriteOptions(), "user:1001", "payload");
    // ...
}

Unified Composer package (orieg/expanse) with native Zend extension (pie install orieg/php-expanse) and portable FFI fallback:

# Install via Composer (Packagist)
composer require orieg/expanse

# Or install native Zend extension via PIE
pie install orieg/php-expanse

Usage example in PHP (Sets, Maps, BlobMaps, and Judy compatibility):

use Expanse\Set;
use Expanse\Map;
use Expanse\BlobMap;
use Judy;

$set = new Set();
$set->add(42);
$rank = $set->rank(100); // O(depth) rank

$map = new Map();
$map->set(42, 1000);
$val = $map->get(42);

// 1:1 legacy php-judy drop-in compatibility
$judy = new Judy(Judy::INT_TO_INT);
$judy[42] = 999;

Add the Go module to your project (PureGo and CGO bindings for 64-bit and 32-bit embedded):

go get github.com/orieg/expanse/bindings/go/v0.5.0

Usage example in Go (Maps, Sets, and Slab-Backed BlobMaps):

package main

import (
    "fmt"
    "github.com/orieg/expanse/bindings/go/v0.5.0"
)

func main() {
    m := expanse.NewMap()
    defer m.Close()

    m.Insert(42, 100)
    if val, ok := m.Get(42); ok {
        fmt.Printf("Found key 42 -> %d
", val)
    }

    // Off-heap blob map with 32-bit hot metadata
    bm := expanse.NewBlobMap()
    defer bm.Close()
    bm.Insert(1001, []byte("payload data"), 0x2A)
    if data, meta, ok := bm.Get(1001); ok {
        fmt.Printf("Blob: %s, meta: 0x%X
", string(data), meta)
    }
}

Install the official Ruby gem from RubyGems (native C extension with Rice/Magnus integration):

gem install expanse -v 0.5.0
# Or in Gemfile: gem 'expanse', '~> 0.5.0'

Usage example in Ruby:

require 'expanse'

# Integer word map with zero-allocation immediates
map = Expanse::Map.new
map[42] = 100
puts "Key 42: #{map[42]}"

# Bitmap-backed integer set with O(depth) rank/select
set = Expanse::Set.new
set.add(1001)
set.add(1002)
puts "Contains 1001: #{set.include?(1001)}"
puts "Rank: #{set.rank(1002)}"

Install the official WebAssembly package via npm / unpkg (wasm-bindgen with zero-allocation memory views):

npm install @orieg/expanse-wasm
# or: bun add @orieg/expanse-wasm / pnpm add @orieg/expanse-wasm

Usage example in JavaScript / TypeScript (Node.js & Browser):

import { ExpanseMap, ExpanseSet } from '@orieg/expanse-wasm';

// Zero-allocation digital trie in WebAssembly
const map = new ExpanseMap();
map.insert(42n, 100n);
console.log(`Found: ${map.get(42n)}`);

// Bitmap bitset with instant membership test
const set = new ExpanseSet();
set.insert(1001n);
console.log(`Contains 1001: ${set.contains(1001n)}`);

Add Expanse to your ESP-IDF project's main/idf_component.yml (ESP-IDF v5.0+):

dependencies:
  expanse:
    version: "^0.4.0"

Usage example in ESP-IDF C/C++ (with internal fast DRAM placement):

#include "expanse.h"
#include "expanse_esp_idf.h"
#include "esp_log.h"

void app_main(void) {
    // 32-bit digital map (compact 8-byte Edge32, 32-byte cache line aligned)
    expanse_map_t *map = expanse_map_new();
    expanse_map_insert(map, 0x18FF50E5 /* CAN ID */, 42 /* Sensor Value */);

    uint32_t val = 0;
    if (expanse_map_get(map, 0x18FF50E5, &val)) {
        ESP_LOGI("expanse", "Found CAN ID 0x18FF50E5 -> %u", (unsigned int)val);
    }
    expanse_map_free(map);
}