Modern Judy Arrays & High-Performance Digital Tree Engine

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 lock-free 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 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 OriEg.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.1.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: 2x-3x higher key density in RAM, fewer SSTable flushes
#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");
    // ...
}

PHP C extension (ext-judy), pure-PHP polyfill (judy-polyfill), and high-density PSR-16 cache (judy-cache):

# Install Judy polyfill & high-density cache
composer require orieg/judy-cache orieg/judy-polyfill

Usage example in PHP:

use Judy;
use OriEg\JudyCache\JudySimpleCache;

// Core digital trie array
$judy = new Judy(Judy::INT_TO_INT);
$judy[42] = 100;

// High-density PSR-16 cache with native TTL pruning & compression
$cache = new JudySimpleCache();
$cache->set('user:42:profile', ['name' => 'Alice', 'role' => 'admin'], ttl: 3600);
$data = $cache->get('user:42:profile');