Built different

FlakeCache isn't just another cache. It's a universal build artifact store with revolutionary deduplication.

Vector-Accelerated Chunking

VectorCDC: 4x better deduplication

Traditional caches store files as blobs. FlakeCache uses VectorCDC (Vectorized Content-Defined Chunking) to split files using SIMD instructions (AVX2/NEON).

Result? Blazing fast chunking that finds 4x more duplicates than standard methods. Node 20 shares 90% of chunks with Node 18.

Research (DupHunter 2020, 10K Docker Hub images):
  • • Industry standard: 1.48x dedup ratio
  • • 80% of files are duplicates (but undetected)
  • • VectorCDC approach: 4x+ dedup ratio
Traditional cache vs FlakeCache
Traditional (blob storage)
300 MB stored (3 full copies)
FlakeCache (VectorCDC)
110 MB stored (shared chunks)
# Push Docker image
docker push cache.flakecache.com/myorg/app:v1

# Chunking layer...
Layer 3: 200 MB → 40 chunks
  ✓ 35 chunks cached (from Nix!)
  ✓ 5 new chunks uploaded

Uploaded: 12 MB (94% dedup)
Native Integration

Docker Registry v2

Full Docker Registry v2 API support. Push and pull images with standard Docker commands. No proxies, no wrappers.

The magic? Docker layers are chunked with the same FastCDC algorithm. Your Docker images automatically share chunks with your Nix packages.

Universal Storage

Cross-language deduplication

Build a Spring Boot app with Maven. The JAR is chunked and stored. Now build a Docker image with that JAR.

FlakeCache recognizes the chunks are identical. Zero additional storage. This works across Nix, Docker, Maven, Cargo, and more.

Chunk sharing across ecosystems
Nix
Docker
Maven
Same colors = shared chunks

Enterprise features

Built for teams that need more

SSO / SAML

Integrate with Okta, Azure AD, Google Workspace

Audit Logging

Full audit trail for compliance requirements

Multi-Tenant

Organizations with granular access control

GDPR Ready

Data residency and privacy compliance

Research-proven, finally shipped

Academic papers have proven FastCDC deduplication for Docker registries since 2020. Nobody shipped it commercially. Until now.

Standard registries
Layers are opaque compressed tarballs
node:18 and node:20 share 90% of files, 0% dedup
Change 1 byte, store entire layer again
FlakeCache
Layers split into content-defined chunks
node:18 → node:20 shares 90% of chunks
Docker + Nix + Rust share the same chunk store
Based on peer-reviewed research

DupHunter (USENIX ATC 2020) and ACM Transactions on Storage 2024 proved these techniques work. We're the first to ship them in a production registry with cross-language deduplication.