JuiceFS (14K⭐): The Distributed POSIX File System That Turns

Imagine your team needs to share massive datasets across 50+ workers for AI training. Each worker expects a standard Linux filesystem — but your data lives in S3. Mounting S3 as a local filesystem has been frustrating: slow, unreliable, or both. JuiceFS solves this by combining the best of both worlds.

With 13,900+ GitHub stars and backing from major cloud providers, JuiceFS has become one of the most popular cloud storage solutions in 2026. It gives you the infinite capacity of object storage with the performance characteristics of a local disk.

How JuiceFS Works #

JuiceFS splits file metadata from file data. This architectural decision is the key to its performance.

┌─────────────────────────────────────────────────────┐
│                    JuiceFS Client                     │
│  ┌──────────────┐    ┌──────────────┐               │
│  │  Metadata DB  │    │  Object Store│               │
│  │  (Redis)      │    │  (S3/GCS/OSS)│               │
│  └──────┬───────┘    └──────┬───────┘               │
│         │                   │                        │
│  ┌──────┴───────────────────┴───────┐               │
│  │      POSIX Filesystem Interface  │               │
│  │   (mount -t juicefs juicefs /mnt)│               │
│  └──────────────────────────────────┘               │
└─────────────────────────────────────────────────────┘

Metadata operations (file lists, permissions, timestamps) go to Redis — a lightning-fast in-memory data store. File data (the actual content) goes to any S3-compatible object storage — infinite capacity, cheap storage. This separation means metadata is always fast, while data scales to petabytes.

Q: Why use Redis for metadata instead of another database?

A: Redis is ideal because metadata operations are tiny but incredibly frequent. Opening a file, listing a directory, or checking permissions happens thousands of times per second. Redis handles millions of operations per second with sub-millisecond latency. While JuiceFS supports other metadata engines (MySQL, PostgreSQL, TiKV), Redis offers the best performance for typical workloads.

Installation and Quick Start #

Getting JuiceFS running takes minutes. Here is a complete setup using Redis for metadata and AWS S3 for storage:

# Install JuiceFS CLI
curl -sSL https://d.juicefs.com/install | sh -

# Create a JuiceFS filesystem
juicefs format \
  --storage s3 \
  --bucket https://my-bucket.s3.amazonaws.com \
  --access-key YOUR_ACCESS_KEY \
  --secret-key YOUR_SECRET_KEY \
  redis://localhost:6379/0 \
  mydata

# Mount it locally
juicefs mount mydata /mnt/juicefs

That is it. /mnt/juicefs now behaves exactly like a regular Linux filesystem. Run ls, cp, python train.py, or any standard tool — it all works seamlessly.

Advanced Usage: Tiered Storage #

One of JuiceFS powerful features is tiered storage. Cold data moves to cheaper storage tiers automatically:

# Mount with tiered storage (S3 as cache backend)
juicefs mount \
  --cache-size 10000 \
  --cache-dir /mnt/cache \
  --cache-compress \
  mydata \
  /mnt/juicefs

When the local cache fills up, the least recently used files are evicted. On next access, they are fetched from S3 transparently. This gives you the speed of SSDs for hot data with the capacity of S3 for cold data.

Cache Configuration Options #

Fine-tune caching behavior for your specific workload:

# 50GB memory cache + 100GB disk cache with compression
juicefs mount \
  --read-only-false \
  --cache-size 50000 \
  --cache-dir /mnt/cache \
  --cache-partial \
  --cache-compress \
  --cache-full-gc-miss \
  mydata \
  /mnt/juicefs

# Verify cache stats
juicefs status mydata
# Cache usage: 45.2GB / 150.0GB (30%)
# Cache hit rate: 94.7%
# Cache miss: 2.1K ops

Multi-Mount and Read-Write Collaboration #

Multiple JuiceFS clients can mount the same filesystem simultaneously for collaborative work:

# Worker 1: Mount and start training
juicefs mount mydata /mnt/juicefs &
python train.py --data /mnt/juicefs/dataset --workers 8

# Worker 2: Mount the same filesystem (no sync needed)
juicefs mount mydata /mnt/juicefs &
python evaluate.py --data /mnt/juicefs/dataset

# Worker 3: Upload new data while training runs
rsync -av ./new_data/ /mnt/juicefs/dataset/
# Training workers see new data immediately

S3 Lifecycle Integration #

Combine JuiceFS with S3 lifecycle policies for automatic cost optimization:

# Set S3 lifecycle rule via AWS CLI
aws s3api put-bucket-lifecycle-configuration \
  --bucket my-bucket \
  --lifecycle-configuration '{
    "Rules": [
      {
        "ID": "tieredStorage",
        "Status": "Enabled",
        "Filter": {"Prefix": ""},
        "Transitions": [
          {"Days": 90, "StorageClass": "GLACIER"},
          {"Days": 365, "StorageClass": "DEEP_ARCHIVE"}
        ]
      }
    ]
  }'

# JuiceFS automatically handles tier transitions
# Accessing a cold file triggers fetch from Glacier

Performance Benchmarks #

JuiceFS delivers impressive performance across different workload types:

| Workload Type | JuiceFS | Local SSD | Cloud Storage (raw) | |