XRAPH/Work/Object storage
Go · since 2026

Trove

One object-storage API across local disk, memory, S3, GCS, Azure and SFTP, with middleware you stack on the read and write paths for encryption, compression or virus scanning. Content-addressed storage with reference counting and GC, and an io/fs.FS view so a flat bucket reads like a directory tree.

Language
Go
Category
Object storage
Since
2026
Stars
0
In production
01+
Repository Docs
01

Highlights

3 claims
H.01
Sixbackends
One interface

Local disk, S3, GCS, Azure Blob, SFTP and in-memory, swapped without the calling code changing.

H.02
BLAKE3
Content-addressed

Store by hash with automatic deduplication through reference counting, and a garbage collector that respects it.

H.03
io/fs.FS
A real filesystem view

A hierarchical directory interface over flat object storage, so standard Go file operations work unchanged.

02

In production

1 named · more on the way

Shipping something on Trove? The list is only as complete as the people who tell me. Ask to be on it, or just say what got in your way.

Get listed
03

What it does

8 entries

Object storage with the parts everybody rewrites already present: dedup, encryption, scanning and a filesystem view.

03.1
Storage

Six drivers, one interface

Local filesystem, S3, GCS, Azure Blob, SFTP and in-memory. Swapping a backend is configuration, and the application code does not learn which one it got.

Unified
03.2
Middleware

Direction and scope aware

Zstd compression, AES-256-GCM encryption, BLAKE3 deduplication, ClamAV scanning and invisible watermarking compose into a pipeline that knows whether bytes are arriving or leaving.

Composable
03.3
Streaming

Chunked with backpressure

Configurable chunk sizes, pause and resume, and managed stream pools across upload, download and bidirectional modes.

Backpressure
03.4
Addressing

Stored by content hash

BLAKE3, SHA-256 or XXHash, with deduplication through reference counting and garbage collection that will not delete something still referenced.

Dedup
03.5
Filesystem

io/fs.FS over flat objects

A hierarchical directory view with metadata management, so code written against the standard library keeps working.

Standard library
03.6
Routing

Objects sent by pattern

Glob patterns or a custom function decide the backend, so logs go to archive storage, images to CDN-backed S3 and temporary files to memory.

Per-object
03.7
Capabilities

Opt-in per driver

Multipart uploads, presigned URLs, server-side copy, versioning, change notifications and lifecycle rules are declared by the driver and detected at runtime.

Detected
03.8
Integration

A first-class Forge extension

REST API, ORM models, migrations, container registration and hooks into Chronicle, Dispatch and Warden.

Forge
04

Anatomy

4 modules
01

Backends

Multi-backend routing with per-prefix rules.

02

Capabilities

Interfaces describing what a backend can do, not which product it is.

03

Content addressing

Immutable objects keyed by their own hash.

04

Virtual filesystem

One tree across several stores.

05

Why it exists

Design notes

#What it is

Trove is a multi-backend object storage engine for Go: one API across local disk, memory, S3, GCS, Azure Blob and SFTP, with middleware you stack on the read and write paths.

#What it does

  • Composable middleware: stackable read/write interceptors for encryption, compression, virus scanning or watermarking, each with fine-grained scoping so a rule can apply to one bucket or one key pattern.
  • Multi-backend routing: route objects to different backends by glob pattern or a custom function. Logs to cold storage, temp files to an ephemeral backend, everything else to the default.
  • Streaming: chunked transfers with backpressure, resumability, pause/resume and lifecycle hooks.
  • Content-addressable storage: deduplication by SHA-256, BLAKE3 or XXHash, with reference counting and garbage collection.
  • Virtual filesystem: an io/fs.FS-compatible hierarchical view over flat object storage, so standard library code that walks directories works unchanged.
  • Capability interfaces: multipart uploads, pre-signed URLs, versioning, server-side copy, range reads, lifecycle rules and change notifications are opt-in per driver, detected rather than assumed.

#The capability design

Not every backend can do everything. A local filesystem has no pre-signed URLs; SFTP has no server-side copy. Rather than a lowest common denominator or a runtime error, capabilities are separate interfaces you type-assert for, so calling code can degrade deliberately instead of discovering the gap in production.

06

Signals

GitHub
Stars
0
Language
Go
Since
2026
Adopters
01