Skip to content

HestiaStore logo

HestiaStore is an embeddable Java key-value storage engine for large local datasets. It is optimized for predictable file I/O, bounded-memory lookups, bounded range scans, and operational simplicity inside a single application process.

Build (main) test results line coverage License: LGPL v3 OpenSSF Best Practices Maven Central Version javadoc Quality Gate Status Bugs Code Smells

What it is a good fit for

  • embedded storage inside a Java service or application
  • datasets that do not fit comfortably in memory
  • predictable local persistence with optional WAL-based crash recovery
  • point lookups plus ordered and bounded range scans over large key ranges
  • local uniqueness or compare-and-replace checks when WAL is disabled
  • teams that want a pure-Java dependency without native libraries

What it is not trying to be

  • a distributed database
  • a multi-node replication layer
  • a cross-key ACID transaction engine
  • a replacement for a full relational database when SQL is the primary need

Start here

  • Evaluate HestiaStore if you are deciding whether it matches your workload.
  • Install and Quick Start if you want a working example immediately.
  • Configuration if you need to tune directories, caching, filters, or custom data types.
  • Operations if you need WAL, monitoring, backups, or tuning guidance.
  • Export & Import if you need the standalone operational CLI for logical backup, migration, or export to other systems.
  • Architecture if you need implementation detail and internal contracts.
  • Contribute & Community if you are contributing code, documentation, or release work.

Key capabilities

  • Pure Java embedding with no native dependency requirement
  • In-memory or filesystem-backed directories
  • Strict UTF-8 keys and values for emoji and multilingual text
  • Custom key and value type descriptors
  • Bloom-filter assisted negative lookups
  • Segment-based storage with ordered and bounded range scans
  • Conditional putIfAbsent and replace mutations for WAL-disabled indexes
  • Optional write-ahead logging for local crash recovery
  • Monitoring snapshots and optional monitoring modules

Performance highlights

All tests ran on a 2024 Mac mini with 16 GB RAM. Absolute numbers vary between runs, so treat the charts as relative comparisons, not absolute guarantees.

Write throughput

Write benchmark comparison

Random read throughput

Read benchmark comparison

Sequential read throughput

Sequential read benchmark comparison

Multithread write throughput

Multithread write benchmark comparison

Multithread read throughput

Multithread read benchmark comparison

Detailed methodology, workload notes, and links to raw artifacts are available on the Benchmarks page.

Minimal example

import org.hestiastore.index.directory.Directory;
import org.hestiastore.index.directory.MemDirectory;
import org.hestiastore.index.segmentindex.configuration.api.IndexConfiguration;
import org.hestiastore.index.segmentindex.SegmentIndex;

Directory directory = new MemDirectory();

IndexConfiguration<String, String> conf = IndexConfiguration
    .<String, String>builder()
    .identity(identity -> identity
        .name("example")
        .keyClass(String.class)
        .valueClass(String.class))
    .build();

try (SegmentIndex<String, String> index = SegmentIndex.create(directory, conf)) {
    index.put("hello", "world");
    System.out.println(index.get("hello"));
}

String indexes use the compact ISO-8859-1 descriptor by default for on-disk compatibility. To store emoji or multilingual text, explicitly select one of the UTF-8 string descriptors when creating the index.

For the next step after this example, go to Quick Start.

Documentation paths

Support