Lib.rs

arrow

Apache Arrow

tantivy

Search engine library

surrealdb

A scalable, distributed, collaborative, document-graph database, for the realtime web

fjall

Log-structured, embeddable key-value storage engine

redb

Rust Embedded DataBase

sonic-server

Fast, lightweight and schema-less search backend

turso

API

oxigraph

SPARQL database and RDF toolkit

surrealkv

A low-level, versioned, embedded, ACID-compliant, key-value database for Rust

indicium

in-memory search for collections and key-value stores

lancedb

serverless, low-latency vector database for AI applications

sentinel-cli

Command-line interface for Cyberpath Sentinel DBMS

datafusion-functions-json

JSON functions for DataFusion

edgefirst-cli

EdgeFirst Client Library and CLI

indradb

A graph database server

datafusion-python

Apache DataFusion DataFrame and SQL Query Engine

dittolive-ditto

Ditto is a peer to peer cross-platform database that allows mobile, web, IoT and server apps to sync with or without an internet connection

akita

Mini orm for rust

cypherlite-storage

Storage engine with WAL, B+Tree indexing, and ACID transactions for CypherLite

s2-lite

Lightweight server implementation of S2, the durable streams API, backed by object storage

seekstorm

Search engine library & multi-tenancy server

roughdb

Embedded persistent key-value store — a LevelDB port to Rust with a compatible on-disk format

grovedb

Fully featured database using balanced hierarchical authenticated data structures

rvf-runtime

RuVector Format runtime -- RvfStore API, compaction, and streaming I/O

native_db

Drop-in embedded database

cypherlite-query

Cypher query engine with parser, planner, and executor for CypherLite

marble

garbage-collecting on-disk object store

yedb

Rugged crash-free embedded and client/server key-value database

substrait-explain

Explain Substrait plans as human-readable text

worterbuch

A message broker / database hybrid

symspell_rs

Spelling correction & Fuzzy search

tern

Embedded database migrations in SQL or Rust

persy

Transactional Persistence Engine

codemem

Persistent memory engine for AI coding assistants

polars-view

A fast and interactive viewer for CSV, Json and Parquet data

arrow-ord

Ordering kernels for arrow arrays

rrd

Bindings to librrd to create and interact with round robin databases created with Tobias Oetiker's rrdtool (https://www.rrdtool.org/)

sentinel-dbms

Cyberpath Sentinel is a filesystem-backed document DBMS written in Rust

qubl-rs

Low level And flexible query builder that gives you full control of your queries

kotoba-execution

Complete query execution and planning engine for Kotoba graph database

mnemoria

Persistent, git-friendly memory storage for AI agents with hybrid semantic + full-text search

signet-hot

Trait-based hot storage abstractions for fast read/write access to blockchain state

mhgl

Matts HyperGraph Library (MHGL). A straightforward library for hypergraph datastructures.

reporters-db

An unoffical port of the freelawproject's database of court reporters

tf-idf-vectorizer

search and analyze engine

aeternusdb

An embeddable, persistent key-value store built on an LSM-tree architecture

cypherlite-ffi

C ABI foreign function interface bindings for CypherLite graph database

entidb_core

Core database engine for EntiDB

dwbase-pack-runner

DWBase: agent-first immutable atom store, components, and tools

overgraph

An absurdly fast embedded graph database. Pure Rust, sub-microsecond reads.

surrealdb-nightly

A scalable, distributed, collaborative, document-graph database, for the realtime web

sanakirja

Copy-on-write datastructures, storable on disk (or elsewhere) with a stable format

vortex-layout

Vortex layouts provide a way to perform lazy push-down scans over abstract storage

ck-index

Indexing and storage for ck semantic search

polars-rows-iter

easy and convenient row iteration of polars dataframes

rustdb

SQL database

dbutils

Utils for developing databases

tantivy-sstable

sstables for tantivy

mdcs-db

Database layer for the Carnelia MDCS - Document API with collaborative features

ironwal

A high performance, high durability, deterministic Write-Ahead Log (WAL) for reliable systems of record

toondb

LLM-optimized database with native vector search

btree-store

A persistent, embedded key-value storage engine in Rust featuring a Copy-On-Write (COW) B-Tree, ACID compliance, and crash safety with multi-bucket support

varvedb

A high-performance, embedded, append-only event store for Rust

aedb

Embedded Rust storage engine with transactional commits, WAL durability, and snapshot-consistent reads

cityhasher

A pure Rust implementation of Google's CityHash hashing algorithm

re_arrow_util

Helpers for working with arrow

pickledb

A lightweight and simple key-value store written in Rust, heavily inspired by Python's PickleDB (https://pythonhosted.org/pickleDB/)

polars-lazy

Lazy query engine for the Polars DataFrame library

avila-arrow

Zero-copy columnar format with scientific arrays (Quaternions, Complex, Tensors, Spinors), SIMD acceleration (35x), and native compression (125x RLE, 16x BitPack, 4x Delta) - Zero external dependencies

nostr-archive-cursor

iterating over JSON-L archives

mnemefusion-core

Unified memory engine for AI applications - Core library

statespace

command-line interface

tantivy-columnar

column oriented storage for tantivy

neleus-db

Local-first Merkle-DAG database for AI agents with cryptographic proofs and immutable versioning

inferadb-ledger-store

Embedded B+ tree database engine for InferaDB Ledger

append_kv

persistent append-only key-value store built in Rust

sled-overlay

Overlay mechanism for sled

ugnos

A high-performance, concurrent time-series database core written in Rust, designed for efficient IoT data ingestion, real-time analytics, and monitoring

miden-note-transport-node-bin

Miden Note Transport Node

kronroe

Embedded temporal property graph database

tantivy-cli

Command line interface for Tantivy, a search engine library

rag-module

Enterprise RAG module with chat context storage, vector search, session management, and model downloading. Rust implementation with Node.js compatibility.

canopydb

Transactional key-value storage engine

thunderdb

A minimal, embedded, transactional key-value database engine

brk_fjall

Log-structured, embeddable key-value storage engine

cursor_db

Cursor-based database engine. Append-only. Deterministic. Sparse index. Timestamp primary index.

omry-db

Database abstractions used by the Omry backend

ruvector-filter

Advanced metadata filtering for Ruvector vector search

vortex-error

Vortex errors

inferadb-ledger-state

Domain state management for InferaDB Ledger

izihawa-tantivy

Search engine library

aimdb-tokio-adapter

Tokio runtime adapter for AimDB - full-featured std async runtime support

astra-core

Core datastore engine, Raft state machine, and control-plane semantics for Astra

rvf-cli

Unified CLI for RuVector Format vector stores

redbx

Rust Embedded DataBase with AES Encryption - Fork of redb

simd-r-drive

SIMD-optimized append-only schema-less storage engine. Key-based binary storage in a single-file storage container.

manifold-db

Manifold Embedded Database

lume

intuitive Query Builder inspired by Drizzle

raphtory-api

Raphtory common interface and APIs

buffdb

Embedded storage at the speed of light

xdl-interpreter

XDL interpreter engine

overdrive-db

— Embeddable hybrid SQL+NoSQL database. Like SQLite for JSON. #OverDriveDB #AFOT

lago

CLI tool for the Lago event-sourced agent runtime

kotoba-monitoring

Comprehensive monitoring and metrics collection system for KotobaDB

redsumer

Lightweight implementation of Redis Streams for Rust

streex

Kafka store runner

page-store

Management of data pages

cloudillo-crdt-adapter-redb

redb-backed CRDT document persistence adapter for Cloudillo, storing binary Yjs updates

apex-store-rs

A high-performance, embedded LSM-tree storage engine with SSTable V2 format, LZ4 compression, and Bloom Filters

ministore

WAL-based embedded state store for Rust-application

symspell_complete_rapid

typo-tolerant autocomplete in Rust (based on symspell_complete_rs, replace gxhash with rapidhash)

velarixdb

An LSM Storage Engine focused on reduced IO amplification

value-log

Value log implementation for key-value separated LSM storage

datafusion-orc

Apache ORC file format using Apache Arrow in-memory format

entdb

Rust-based SQL database engine core for EntDB

keradb-sdk

Rust SDK for KeraDB - a lightweight, embedded NoSQL document database with vector search

lupabase

Blazingly fast (work-in-progress) database engine written entirely in Rust

rustyssim

A high-performance IATA SSIM (Standard Schedules Information Manual) parser. Parses SSIM files into Polars DataFrames or exports to CSV/Parquet.

terminus-store

a triple store library

pulsedb

A high-performance time-series database written in Rust

melange_db

基于 sled 架构深度优化的下一代高性能嵌入式数据库，支持 ARM64 NEON SIMD 优化、多级缓存和布隆过滤器

turbokv

A fast, embedded key-value store with BTreeMap-like API

tensordb

— single-node, append-only, bitemporal ledger database with MVCC snapshot reads and SQL facet

nu_plugin_polars

Nushell dataframe plugin commands based on polars

databoard

hierarchical key-value-store

RustyPage

RustyPage is a simple startpage configurable with a simple TOML file

torc-slurm-job-runner

Torc Slurm job runner for HPC environments

ferrumdb

A premium, high-performance embedded key-value database with TTL and compaction

magic-db

precompiled magic database for file type identification. It allows any program to perform magic file detection without the burden of compiling rules from source.

polars-ops

More operations on Polars data structures

palletizer

self-hosted Cargo registry

symspell_complete_rs

typo-tolerant autocomplete in Rust

shuttle-qdrant

Shuttle plugin for connecting to a Qdrant database

epoch-db

An intelligent, persistent, and concurrent key-value store for Rust, designed to manage data with a lifecycle through frequency tracking and TTL

alopex-core

Core storage engine for Alopex DB - LSM-tree, columnar storage, and vector index

InfuseDB

InfuseDB is a Document oriented KV database

sentinel-wal

Write-Ahead Logging (WAL) implementation for Cyberpath Sentinel

kotadb

A custom database for distributed human-AI cognition

ttid

Typed, time-aware IDs built on UUIDv8

entidb_cli

CLI tools for EntiDB

aimdb-core

Core database engine for AimDB - async in-memory data synchronization with bidirectional connectors

seerdb

Research-grade storage engine with learned data structures

vortex-datetime-dtype

Vortex datetime extension dtype

aora

Append-only random-accessed data persistence

llkv

An Apache Arrow columnar storage layer with SQL for key-value storage systems

graphrecords

High-performance graph-based data records

rudabai

A robot motor management system and custom database

cynos-core

Core types and schema definitions for Cynos database

pyref-core

Core of the pyref project

raphtory-storage

Raphtory storage interface

so-core

High-performance statistical computing library written in Rust, exposed to Python via PyO3

cypherlite-core

Core types, traits, and error handling for CypherLite graph database

lsm_storage_engine

A high-performance, zero-dependency LSM-Tree storage engine in pure Rust

osmiumdb

A dense, chunk-oriented database engine with explicit hot/cold memory control

tickv

(Tiny Circular Key Value) is a small file system allowing key value pairs to be stored in Flash Memory

nostrdb

An unfairly fast embedded nostr database backed by lmdb

skillsrs-policy

Policy engine for skills.rs - Access control and security policies for MCP skills

sstable

Sorted String Tables, an on-disk format for storing immutable maps consisting of string,string pairs, and retrieving values by key efficiently. This crate also features bloom filters…

atom-file

Buffered concurrent access to files with async atomic commit

systemprompt-runtime

Application runtime context and module registry for systemprompt.io

byodb-rust

Build Your Own Database in Rust!

bgr

bgr: BUGGU-GREP, Ultra-fast in-memory log search engine with microsecond queries

vortex-dtype

Vortex's core type system

izihawa-tantivy-columnar

column oriented storage for tantivy

chroma-types

Chroma-provided crate for internal types used in the Chroma API

sos-audit

Audit trail for the Save Our Secrets SDK

xapian-rusty

Rust bindings to Xapian

izihawa-tantivy-sstable

sstables for tantivy

moogle

data structures for relational code

tantivy-derive

Generate code to converts struct from and to tantivy documents

nano-wal

lightweight Write-Ahead Log (WAL) implementation for append-only operations

eyros

multi-dimensional interval database

synctato

A JSONL-based embedded database with sharding, transactions, and CRDT-style merge

surrealmx

An embedded, in-memory, lock-free, transaction-based, key-value database engine

vegafusion-runtime

VegaFusion Runtime

trs-data-value

Data Value for common data types

transliterator

High-quality Indic script transliteration engine using FSM + Trie

mdcs-sdk

High-level SDK for building collaborative applications with the Carnelia MDCS

vespertide-loader

Loads migrations and models from filesystem

deeb

An ACID compliant JSON embeddable database built in Rust

vortex-tui

a small but mighty tool for working with Vortex files

re_dataframe

High-level query APIs

frugalos

Frugal Object Storage

ld-lucivy

BM25 search engine with cross-token fuzzy matching, substring search, regex, and highlights

alopex-cli

Command-line interface for Alopex DB

vectorscan-async

Wrapper for the vectorscan C++ regex library

arroyo-udf-common

Common utilities for the Arroyo UDF FFI API

crepedb-redb

An versioned and forkable embedded Key-Value database

actionqueue-storage

WAL, snapshot, and recovery storage layer for the ActionQueue task queue engine

nebari

ACID-compliant database storage implementation using an append-only file format

df-interchange

Seamless interoperability between Polars and Arrow

mergedb-types

CRDT data structures for mergeDB

queued

Fast zero-configuration single-binary simple queue service

grafeo

A high-performance, embeddable graph database with a Rust core and no required C dependencies

fleascope-rs

interact with a Fleascope

ld-lucivy-sstable

sstables for lucivy

wallust_themes

Embeded colorschemes in an array of u32s

datafusion-session

hfq_rs

optimized for multithreading and enhanced performance using Polars for dataframe operations, designed to analyze circuit files for josim and determine the operating margins of specified circuit elements

miden-node-db

Shared database capabilities for Miden node

azure_mgmt_migrateprojects

generated REST API bindings

nanograph

Embedded typed property graph database. Schema-as-code, compile-time validated, Arrow-native.

rowboat

A package for working with row/column/cell structured data AKA dataframe

everything-sdk

An ergonomic Everything(voidtools) SDK wrapper in Rust. (Supports async and raw sdk functions)

trs-dataframe

Dataframe library for Teiresias

vineyard

SDK: core library

typed-sled

Sled with types instead of bytes

kora-doc

JSON document database with secondary indexes and WHERE queries for Kōra

fusio-log

The append only log implementations

dwbase-stream-local

DWBase: agent-first immutable atom store, components, and tools

onload

binding to solarflare onload libarary

ld-lucivy-columnar

column oriented storage for lucivy

spatio-server

High-performance RPC server for Spatio database

searchy

Search index (in-memory), that can be constructed and searched using a bag of words model, with cosine similarity scoring based on tf-idf. Supports multiple search terms, permissions…

referer-parser-rs

snowplow-referer-parser

walrus-rust

A high-performance Write-Ahead Log (WAL) implementation in Rust

akita_codegen

Akita - Mini orm for rust

valor_kv

efficient key value store built with Rust

azoth

High-performance embedded database for state management and event sourcing with ACID guarantees

tectonicdb

server

stonix

A lightweight, atomic key-value storage engine optimized for ARM and Intel hardware

thulp-query

Query engine for searching and filtering thulp tools

wavekv

An embeddable, eventually consistent, distributed key-value store with peer-to-peer architecture

idx-stream

Database

entidb_testkit

Test utilities for EntiDB

sochdb

LLM-optimized database with native vector search

syn-select

A lightweight selector engine for searching Rust source code

uni-algo

Graph algorithms for Uni - PageRank, Louvain, shortest paths, and more

db-core

dbms engine

re_chunk_store

A storage engine for Rerun's Chunks

simplebase

database library

signet-hot-mdbx

MDBX implementation of signet-hot storage traits

unobtanium-viewer

The default web-frontend for unobtanium

aimdb-persistence

Persistence backend trait and extension traits for AimDB

bilberrydb

Developer SDK for creating image search engines, image classification models, image duplication recognition, and Visual recommender systems with BilberryDB

vlog_db

High-performance embedded key-value database with LSM-tree architecture, ACID transactions, and value-log separation

kjarni-search

Kjarni Search - Search primitives for the Kjarni inference engine

tsxlib

timeseries library

rvf-import

Import tools for migrating data from JSON, CSV, and NumPy formats into RVF stores

structsy

single file structs database

entidb_sync_engine

Sync state machine and engine for EntiDB

ruvector-router-ffi

NAPI-RS bindings for ruvector-router-core vector database

vortex-tensor

Vortex tensor extension type

sqjson

JSON-based embedded database

gurtca-cli

GURT CA CLI tool

cannyls

Embedded persistent key-value storage optimized for random-access workload and huge-capacity HDD

ekv

Key-value database for embedded systems, for raw NOR flash, using an LSM-Tree

hudi-datafusion

The native Rust implementation for Apache Hudi

rustque

fast on disk perstant memeory mapped que for rust it stores Vec<u8> to a file on a disk

lago-store

Content-addressed blob storage with SHA-256 and zstd compression

nexus-core

Core storage engine, WAL, topology, and data-path primitives for Nexus

llm-memory-graph

Graph-based context-tracking and prompt-lineage database for LLM systems

pwal

Partitioned Write-Ahead Log (WAL)

codesense

Local semantic code context engine — fast codebase indexing, search, and AI-ready context retrieval. Ported from Elixir.

avin_utils

Utils for the 'avin' library

axum_session_surreal

📝 Surreal Persistent Database layer for axum_session

avx-arrow

Zero-copy columnar format with scientific arrays (Quaternions, Complex, Tensors, Spinors), SIMD acceleration (35x), and native compression (125x RLE, 16x BitPack, 4x Delta) - Zero external dependencies

indradb-lib

A graph database library

matdb

An experimental embedded SQL-like DBMS

hyperQL

Query language for hyperspatial graph databases with temporal and spatial semantics

opendiskmap

Single-threaded disk-backed hash map with memory-mapped file backing

datafusion-functions-array

Array Function packages for the DataFusion query engine

dwbase-vector-hnsw

DWBase: agent-first immutable atom store, components, and tools

mbf_gtf

Fast Parser for Ensembl formated GTF Files to Pandas DataFrames

parquet_aramid

Query engine using Parquet tables as a Key-Value store

skill-discovery

Autonomous skill discovery agent with LLM tool chaining, powered by Rust

glaredb_core

Core functionality for GlareDB

worldinterface-contextstore

Atomic durable store for WorldInterface node outputs

litestash

High-performance key-value store using SQLite static lock sharding. Native Rust client for the litestash-engine.

ministate

A minimal, embeddable state manager with durable WAL logging and optional snapshot support. Ideal for component registries, metadata stores, and local state machines in edge applications.

entdb-server

PostgreSQL wire-compatible server for EntDB

shortcut

an indexed, queryable column-based storage system

surrealdb-alpha

A scalable, distributed, collaborative, document-graph database, for the realtime web

nu-cmd-dataframe

Nushell's dataframe commands based on polars

pallet

Document store built with sled and tantivy

search-api

Search Engine Result scraping

aol

Generic purpose append only log implementation

codegraph

A fast, reliable, and flexible graph database optimized for storing and querying code relationships

amaters-server

AmateRS server binary

velocidb

A high-performance SQLite reimplementation in Rust optimized for modern hardware

teddy

A SIMD-accelerated multistring searcher

rucksack-db

The rucksack encrypted database

netsblox-cloud-common

containing the types used internally by the NetsBlox cloud (stored in the database)

manifold-timeseries

Time-series storage optimizations for Manifold embedded database

furdb

A minimal Database Management System that prioritizes storage space usage and fast lookup/query times

mmdb

A std-collection-like database

llkv-column-map

Column mapping utilities for the LLKV toolkit

lb-tantivy-sstable

sstables for tantivy

vegafusion-dataframe

VegaFusion's DataFrame and Connection traits

googleapis-tonic-google-cloud-discoveryengine-v1beta

A Google APIs client library generated by tonic-build

versatile-data

databases that has convenient datasets that group together commonly used fields and gives you the flexibility to create your own fields

raindb

A persistent key-value store based on an LSM tree implemented in Rust

vortex-scan

Scanning operations for Vortex

seglog

High-performance segment log with CRC32C validation - optimized for event sourcing and append-only storage

secubot

Discord bot!

quotick

Embedded tick market data (trade, quote, ..) database storage optimized for billions of data points

veresiye

Database

rustsec-admin

Admin utility for maintaining the RustSec Advisory Database

entropy-kvdb

Encrypted key-value database for the Entropy Theshold Signing Server

kronroe-agent-memory

High-level agent memory API built on Kronroe

tinkv

A fast and simple key-value storage engine

doublets

Modular framework to automation by automation

polars-plan

Lazy query engine for the Polars DataFrame library

alopex-embedded

Embedded database interface for Alopex DB

celerix-store

A lightweight, low-latency KV data store with 1:1 parity with the orginal golang version, atomic persistence, and AES-256-GCM encryption

lb-tantivy-columnar

column oriented storage for tantivy

kimberlite-server

Kimberlite server daemon

entidb_storage

Storage backend trait and implementations for EntiDB

qwal

A disk baced Write Ahead Log that can functuin as a FIFO queue

minisnap

Minimal snapshot store for durable state managers

black-jack

DataFrame / Series / general data processing in Rust

pagecache

lock-free pagecache and log for high-performance databases

anbar

local database solution crate

supertable-core

Core library for SuperTable, a next-generation open table format

vectorscan

wrapper for Vectorscan

gravitydb

A graph database

shardex

A high-performance memory-mapped vector search engine with ACID transactions and incremental updates

yakv

persistent key-value storage based on B-Tree

unobtanium-crawler

The default web-crawler for unobtanium

s3b

A command line tool for uploading data to Amazon S3, backed by an embedded database

vectordb

LanceDB: A serverless, low-latency vector database for AI applications

flinch

in-memory database

aimdb-executor

Pure async executor trait definitions for AimDB - runtime-agnostic abstractions

vespertide-naming

Naming conventions and helpers for vespertide database schema management

hkvdb

key-value store tracking historical information

grebedb

Lightweight embedded key-value store/database backed by files in a virtual file system interface

alexandria

An encrypted document-oriented database with tag based query support

tinybase

A tiny embedded database built in Rust

kotoba-db

High-performance embedded database for Kotoba ecosystem

sysadmin-bindings

Rust bindings for StarryInternet/sysadmin. Sysadmin is an embedded database and system configuration tool

datafusion-quality

Data quality tools for DataFusion

readb

efficient, and modular embedded read-first key-value database in Rust

crepedb-mdbx

An versioned and forkable embedded Key-Value database

re_view_dataframe

A view that shows the data contained in entities in a table

trek

Database migration management for Rust programs

polars-row

Row encodings for the Polars DataFrame library

memory-lol

Database for tracking historical social media data

reddb

Minimalistic in-memory embedded database with persistance

ld-lucivy-query-grammar

Search engine library

feophant

A SQL database server written in Rust and inspired by PostreSQL

mdb-rs

Embedded database for agentic memory, backed by RocksDB

alex-db-server

AlexDB server

bbolt-rs

port of the Bolt database

nu-data

Data for Nushell

inspector-gadget

A cli-based, multi-architecture gadget-finding tool, designed for fast operation, even with large binaries like browser engines and OS kernels

langmore

A KV Store Based On Write-Ahead Log

husky

creating databases like iterators

skipdb

An embedded, in-memory, zero-copy, atomicity, consistency, MVCC, almost lock-free and serializable snapshot isolation database engine

limbo_series

Limbo series extension

kvstore

typesafe key-value store, that allows users to set, get, and delete key-value pairs, with each key stored in a separate file on disk

cargo-dbcheck

A CLI tool for tracking the progress in the db-academy.io courses

subliminal

Base crate for subliminal microservices project

humus

A composting database. This is a small experiment in deliberate data decaay: A simple in-memory database that slowly forgets the things that you don't revisit.

quicksearch

Configurable quick search engine shortcuts

struct_db

Drop-in embedded database

kronroe-android

Android JNI bindings for Kronroe

entidb_sync_protocol

Sync protocol types and CBOR codecs for EntiDB

spatio-client

Native Rust RPC client for Spatio database

partition_tree

Partition Tree: conditional density estimation in general outcome spaces

sqlo

Syntactic sugar for sqlx. Sqlo is another attempt to make a nice/pleasant API in Rust using relational database. Sqlo is built on top of sqlx and uses sqlx macros so you keep all the…

dbeel

fast and minimal distributed thread-per-core document database

ghaladb

LSM tree based key value store with keys and values separation

ruvector-snapshot

Point-in-time snapshots and backup for Ruvector vector databases

polodb_core

An embedded document database

rolodex-tui

A fast and minimal terminal-based contact manager built in Rust

uuid64rs

UUID v4 (random) Rust crate with an additional custom base 64 encoding which is web and database friendly

alopex-server

Server component for Alopex DB

xapian-rs

Rust bindings for the Xapian search engine

quadb

An asynchronous octree manager implemented over redb, designed for efficient storage and retrieval of spatial data from disk

sql_reverse_template

sql reveser template

vortex-buffer

A byte buffer implementation for Vortex

memorydb

in-memory implementation of hashdb

a2-memory-map

Database of Apple II memory addresses

pikodb

A Pico-sized In-memory Vector Database

sombra

High-performance graph database with ACID transactions, single-file storage, and bindings for Rust, TypeScript, and Python

dwn-native-db

DWN backend implementation using native_db

mindb

Lightweight embedded key–value store with write-ahead log and zstd compression

roo_engine

Roo is a smart bookmarking and productivity tool that works as a custom search engine for your browser

typedb

persistent generic HashMap/Key-value store

cube-query

querying the CubeMX database

mhdb

Pure rust embeddable key-value store database

orderwal

A generic-purpose, atomic, ordered, zero-copy read, zero-cost (in-place) write, Write-Ahead Log implementation for Rust

fake-sql

generate create table, alter table, drop table, insert, update, delete and select sql

unobtanium

Opinioated Web search engine library with crawler and viewer companion

weldmock

Full fake REST API generator

gsgdt

Generic Stringly Typed Graph Datatype

utimeseries

An experimental time series database with a compact storage format to record data occurring in regular intervals

binstore

key-value store written in Rust. Uses its own compact file format.

xdcc-search

search in the xdcc databases available online

simd-r-drive-entry-handle

Standalone mmap-friendly entry handles for SIMD R Drive

bonsaidb-client

Client for accessing BonsaiDb servers

concurrent_diskmap

Multi-threaded disk-backed hash map with sharded locking (work in progress)

koit

asynchronous, pure-Rust, structured, embedded database

syn-select-next

A lightweight selector engine for searching Rust source code

wired

WIP: Collection of embeddable database models for Rust

textdb

A high performance read only text database

koala

Python's pandas implementation in Rust

vinculum

Lock-Free Deduplication in Rust