Store once. Sync the difference. Verify the bytes.

Latest from the blogSep 27, 2026Introducing Casita: A content-addressed store for source code and build artifactsRead post →

Store once.
Sync the difference.
Verify the bytes.

Built in Rust. Apache 2.0.

Get started→Embed in Rust→

terminalcasita

# Attach this project to Casita
$ casita init

# Import and name a directory
$ casita import ./project --root demo
casita.directory.v1:...
root demo

# Audit stored content
$ casita fsck --audit-only

Supported platformsLinuxmacOSWindows

Cargo using Casita

WriteRun

Pause

Cargo writes all three outputs directly into Casita.

ABCACDEABC

Cargo

$ cargo build --bin uv

libuv.rlib

ACD→

Waiting

uv

ABC→

Waiting

uv.d

E→

Waiting

Writing outputs

Casita

cargo/builds/uvNamed root

Output directoryDirectory object · file entries

uvFile object

libuv.rlibFile object

uv.dFile object

BlobFile contents

BlobFile contents

BlobFile contents

Achunk

Bchunk

Cchunk

Dchunk

Echunk

Storage links, not compilation dependencies. Chunk boundaries and sharing are illustrative; directory payload details are omitted.

Run uv

uv

ABC

Awaiting metadata

$ casita run cargo/builds/uv -- --versionuv 0.12.7 (x86_64-unknown-linux-gnu)

Output tree prepared. Executable discovered and run.Replay

Proposed Cargo integration · uv 0.12.7 · executable reconstruction shown; chunks are illustrative. Run applications → · Verified artifact ↗

Bring your data in

Choose an importer.

Files, archives, NAR inputs, Git history, and OCI images all enter through the same verified repository API. Build your own importer.

Filesystem

Capture a directory as a canonical graph of files, links, and subdirectories.

Filesystem guide →

Tar

Stream a tar archive into a filesystem graph without extracting it first.

Tar guide →

OCI images oci feature

Stream registry layers into a verified image layout and, optionally, a merged filesystem.

OCI guide →

NAR Rust API · IPC

Import one canonical Nix archive and retain its measured filesystem tree.

NAR API →

Casitar

Import a portable Casita graph archive and verify its contents before publishing roots.

Casitar guide →

Git git feature

Keep native Git object IDs while importing local branches and tags.

Git guide →

What can you build with Casita?

Bring deduplicated storage and content verification to your files, repositories, and application objects.

Filesystem graphs

Save a directory, keep it under a name, and restore its files wherever you need them.

Filesystem workflow →

Repository sync

Mirror a named graph between repositories. Reuse existing content and verify everything that arrives.

Sync workflow →

Native Git

Store branches and tags with their original Git IDs. Check out a tree or serve it over read-only HTTP with the git features.

Git workflow →

IPLD and custom formats

Bring IPLD blocks or your own object format. Define identity and links; reuse Casita’s sync and collection through the experimental API.

Extend Casita →

Casitar archives

Package a complete object graph in a portable archive. Import it elsewhere, verify its contents, and publish its roots together.

Archive workflow →

Shared S3 storage

Let multiple runners share a repository in an S3 bucket, with coordinated writes and collection. Requires the experimental s3 feature.

S3 operations →

Two ways to use it

Use the CLI or embed it in Rust.

Both share the same deduplication, content verification, and sync workflows.

$

Command line

Import, inspect, sync, restore

$ casita init
$ casita import ./src --root app/source
$ casita fsck

Start with the filesystem workflow, then add only the features required for SSH or native Git.

Follow the Quick Start →

rs

Rust library

Embed the repository

use casita::{Repository, RootName};

let repository = Repository::local("./data").await?;
repository.import(casita::import::FilesystemImport::new("./src", RootName::try_from("app/source")?)).await?;

for root in repository.roots().await? {
    println!("{} -> {}", root.name(), root.target());
}
repository.flush().await?;

One concrete handle supports memory, local disk, and optional S3 storage. Custom backend composition lives in casita::experimental; the S3 storage profile remains experimental.

Read the Library guide →

Benchmarks

First import. Small update. Sync the difference.

Median of 10 runs · seconds · lower is faster

First import

Import into an empty repository.

01.0 s

• Casita0.361 s
• Git0.564 s
• restic0.977 s
• Borg0.833 s
• tar + zstd0.078 s

Small update

Re-import an edited copy of the tree.

01.0 s

• Casita0.249 s
• Git0.132 s
• restic0.984 s
• Borg0.979 s
• tar + zstd0.085 s

Sync the update

Local sync to a destination with the base tree.

01.5 s

• Casita0.115 s
• Git0.023 s
• restic1.464 s
• BorgNot measured
• tar + zstdNot measured

Each chart has its own scale. Sync measures a local update, not a network transfer.

AMD Ryzen 7 7840S · 27.2 GiB RAM · Linux / Btrfs

Baseline: 2026-08-29 · Casita 45699f8 · Source data ↗

Run details and comparison limits

Measured 2026-08-29 at Casita revision 45699f8, using the standard profile and the powersave CPU governor. These are published baseline results, not measurements of the current build.

The update inserts 4 KiB into one file and adds an 8 KiB file. Re-import uses a copied tree; it does not measure an in-place edit. Sync starts with the base tree already at the destination.

Warm cache pre-reads regular files; cold cache requests eviction with POSIX_FADV_DONTNEED. Neither controls filesystem metadata or device caches. The filesystem uses zstd compression on an encrypted volume.

Git, backup tools, and tar archives have different publication and verification guarantees. restic uses repository encryption; Casita and Borg use plaintext repositories. tar + zstd rebuilds the archive for an update. Borg and tar + zstd have no sync measurement in this suite.

Timings use the report’s nearest-rank p50: the fifth sorted sample of ten. Setup and validation are outside the timed region. Every accepted sample passes integrity and restored-content checks. Raw samples and hardware details ↗

borg 1.4.5 · casita 0.1.0 · git version 2.55.0 · restic 0.19.1 compiled with go1.26.5 on linux/amd64 · tar (GNU tar) 1.35; *** Zstandard CLI (64-bit) v1.5.7, by Yann Collet ***

Explore all benchmarks→Reproduce a run

Get started with Casita.

Follow the quick start or explore the Rust library.

Get started→Rust library