rclone
"rsync for cloud storage" - Google Drive, S3, Dropbox, Backblaze B2, One Drive, Swift, Hubic, Wasabi, Google Cloud Storage, Azure Blob, Azure Files, Yandex Files
- 61k
- Go
- MIT
- 21 h ago
Cross-platform cloud storage filesystem client in Rust with on-demand access, offline pinning, P2P block sync and several storage backends
Repo ExaDev/cascade, read from GitHub 1 min ago. ExaDev has not joined Take My Repo.
ExaDev/cascade is a public repo on GitHub by ExaDev. Cross-platform cloud storage filesystem client in Rust with on-demand access, offline pinning, P2P block sync and several storage backends. It declares no license on GitHub. Public does not mean open source: without a license, nobody is granted the right to reuse it. It is written mainly in Rust, has 8 stars and last changed on 2026-11-16. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Cross-platform cloud storage filesystem client built in Rust. On-demand file access, nested
.cascadeconfig with directory-walk precedence, offline pinning, policy-driven lifecycle management, P2P block sync, and multi-backend support. Uses native platform APIs (File Provider on macOS, ProjFS on Windows, FUSE on Linux) with NFS fallback — no kernel extensions required.
Rust (edition 2024) · Swift (macOS File Provider extension) · SQLite state · Tokio async runtime
Every cloud provider ships their own desktop client. They all share the same shape — pick a folder, sync it, hope your disk is bigger than the data. Google Drive for Desktop has a stream mode that loads files on demand, but it's macOS- and Windows-only, leaves you guessing what's actually local, and behaves badly offline. Dropbox, OneDrive, iCloud — same story, each with their own client, their own quirks, their own opinions about your filesystem layout.
rclone solves the cross-cloud unification well, but its mount story is per-OS fiddly: each platform needs its own filesystem driver, sometimes root, sometimes a separate install. The config is global; if you want different rules for Work/ than Personal/ you reach for a wrapper script.
Cascade is what happens when you want a single tool, with a single config language, that:
open() triggers a fetch.WebClient on Windows — with no kernel extension, no admin escalation, no third-party driver..cascade files scattered through the tree (gitignore-style precedence), so behaviour can vary per directory without restarting anything.My Drive, Shared drives, Shared with me, Bin — instead of pretending every account is one flat folder.The bet is that one filesystem client that works the same on every laptop is more useful than five vendor clients plus a folder full of rclone scripts.
rust-toolchain.toml (currently 1.96.0, edition 2024). rustup installs it automatically on first build.
rust-toolchain.toml. Install rustup from https://rustup.rs/ so local builds, the pre-push hook, and CI all use the same compiler.libfuse3 runtime libraries for the FUSE presenter (apt install libfuse3-dev on Debian/Ubuntu, yum install fuse3-devel on RHEL/Fedora). NFS fallback additionally needs root to bind a privileged port.WebClient service for the WebDAV mount. It ships with Windows but is often set to manual start — sc config WebClient start= auto (in an elevated shell) makes it come up automatically. A native ProjFS presenter (presenter-projfs) is implemented and tried first by cascade start — it serves directory browsing and on-demand file reads through an engine-backed content provider — with WebDAV as the fallback if ProjFS cannot start (for example when the Client-ProjFS optional feature is disabled).Pre-built binaries are published on each release from GitHub Releases.
macOS and Linux (Homebrew):
brew install Mearman/cascade/cascade
The Formula/cascade.rb bottle covers both aarch64 and x86_64 on macOS and Linux.
Linux (direct download): grab cascade-aarch64-linux.tar.gz or cascade-x86_64-linux.tar.gz from the release, extract, and place cascade on your PATH:
curl -L https://github.com/Mearman/cascade/releases/latest/download/cascade-x86_64-linux.tar.gz | tar -xz install -m 0755 cascade ~/.local/bin/
Windows (Scoop):
scoop bucket add cascade https://github.com/Mearman/scoop-cascade scoop install cascade
Windows (direct download): grab cascade-x86_64-windows.zip from the release, extract, and place cascade.exe on your PATH.
From source (any platform): see Build below.
cargo build --release # Specific presenter cargo build --release --features presenter-nfs cargo build --release --features presenter-fileprovider # macOS only # Including Swift extensions (macOS) cargo build --release xcodebuild -project swift/CascadeFileProvider.xcodeproj -scheme CascadeFileProviderHost -configuration Release -destination "platform=macOS" build cd swift/CascadeFSKit && xcodebuild
The Makefile wraps the common workflows:
make release # cargo build --release make build # cargo build (debug) make start # build then run the daemon make stop # stop a running daemon make dev # cargo watch with debug logging make debug # run the release binary with RUST_LOG=debug
cascade backend add gdrive --name personal cascade start cascade status cascade pin Documents/Accounts/ cascade stop
cascade service manages the daemon as an OS background service. The default scope is per-user and requires no administrator rights: a launchd LaunchAgent on macOS, a systemd --user unit on Linux, and a logon Scheduled Task on Windows.
cascade service install # write the service definition and register it cascade service start # start the registered service cascade service status # show whether the service is registered and running cascade service stop # stop the service cascade service uninstall # deregister the service and remove its definition
The scope is selected in this order: an explicit --user or --system flag, then inference from the session (an interactive GUI desktop session picks the user scope; a headless host picks the system scope), then — only when there is both a GUI desktop and a terminal — a prompt that defaults to the user scope. The chosen scope and the reason for it are always printed. The --system scope installs a machine-wide service: on Linux it writes a systemd system unit (requires root); on macOS and Windows it errors clearly — a system-scoped service in session 0 cannot drive File Provider, FSKit, ProjFS, or WebDAV, which all require a user session, and this is a documented platform limitation rather than a missing feature.
If you installed via Homebrew, brew services start cascade works out of the box — the formula ships a service block that delegates to cascade start.
The daemon exits cleanly with a log message when no backends are configured, so a freshly-installed service does not crash-loop before cascade backend add has been run.
cargo test --workspace # all unit tests cargo test --test integration # integration tests (require mock backend) cargo test -p backend-gdrive # single crate cargo clippy --workspace # lint cargo fmt --check # format check
The design is documented in full at docs/design.md. This section covers the high-level structure.
┌──────────────────────────────────────────────────────────┐
│ Platform Layer (per-OS) │
│ macOS: File Provider · FSKit (15.4+) · WebDAV · NFS │
│ Linux: FUSE · NFS (root) │
│ Windows: ProjFS · WebDAV via WebClient │
│ Universal fallback: NFS server · WebDAV server │
└────────────────────┬─────────────────────────────────────┘
│ VfsPresenter trait
┌────────────────────▼─────────────────────────────────────┐
│ Cascade Engine (Rust) │
│ VFS Tree · .cascade config walk · Cache Manager │
│ Backend trait · Expression Evaluator · P2P Engine (BEP) │
└──────────────────────────────────────────────────────────┘
cascade start tries the platform-preferred presenters in order and falls back as each one fails: on macOS that's FSKit → WebDAV → NFS; on Linux it's FUSE → NFS; on Windows it's ProjFS → WebDAV (mounted via net use * against the built-in WebClient service). The Windows ProjFS presenter implements the full callback table — directory enumeration, placeholder info, file-name queries, on-demand reads, notifications, and cancellation — and serves file contents through an engine-backed content provider. WebDAV remains the fallback for when ProjFS cannot start (for example when the Client-ProjFS optional feature is disabled on the machine).
Communication between the platform layer and the engine uses a Unix domain socket with a length-prefixed JSON protocol, shared by the CLI, the macOS File Provider and FSKit extensions, and any future GUI.
crates/
engine/ VFS tree, backend trait, cache manager, sync, state DB
cascade-config/ .cascade parsing (4 formats), merge, directory walk
expr/ Conditional expression parser (PEG via pest) and evaluator
p2p/ BEP protocol, peer discovery (LAN, gossip, announce, Mainline DHT), block store
cascade-announce-wire/ Announce-server wire contract: signed-candidate types, HMAC write auth, wasm-safe handler
backend-gdrive/ Google Drive (Drive API v3, OAuth2 device code)
backend-s3/ S3-compatible
backend-local/ Local filesystem (adopt-and-sync)
backend-p2p/ P2P-only content-addressed store (no cloud authority; blocks local, metadata in SQLite)
presenter-nfs/ NFSv3 server
presenter-fuse/ Linux FUSE presenter
presenter-webdav/ WebDAV server presenter (cross-platform)
presenter-fileprovider/ macOS File Provider bridge (Rust side)
presenter-fskit/ macOS FSKit bridge (Rust side, macOS 15.4+)
presenter-projfs/ Windows ProjFS presenter
cascade/ Binary crate (CLI entry point and daemon)
relay-server/ Opaque byte-pipe relay (binary): pairs two WebSocket clients by session ID for WAN NAT traversal, HMAC-gated, never inspects payload
swift/
CascadeFileProvider/ macOS File Provider extension
CascadeFSKit/ macOS FSKit extension (15.4+)
workers/
announce/ Stateless announce-server Cloudflare Worker (workers-rs, KV soft state)
Integration tests live inside each crate's tests/ directory rather than at workspace root.
Backend trait — every cloud provider and the local filesystem implement this. The engine never sees provider-specific APIs. Each backend crate exposes create_backend(config) -> Result<Box<dyn Backend>>.VfsTree — composes multiple backends into a single tree, routed by longest-prefix match. Cross-backend moves trigger download + upload + delete.VfsPresenter trait — platform-agnostic interface for presenting the VFS to the OS. Compile-time selection: FSKit on macOS (with WebDAV and NFS fallbacks), FUSE on Linux (with NFS fallback), ProjFS on Windows with WebDAV via WebClient as fallback, NFS as universal fallback..cascade config walk — like .gitignore: files in each directory layer with child-overrides-parent precedence. Four formats (gitignore-style, TOML, YAML, JSON) all deserialise to CascadeConfig.EvalContext (file, device, disk, network, power, time, peer). Used for conditional rules in .cascade files.ManageRequest / ManageResponse BEP frames carry the full command set — status read, pin/unpin, cache evict/warm, config push, policy set, backend add/remove, daemon restart/stop, and grant delegation/revocation — and dispatch into the same handlers the local CLI drives, gated by per-command authorisation and an append-only audit log. The dangerous verbs (backend, lifecycle, grant administration) are never satisfied by a node-wide grant and must be granted explicitly for a folder scope, and a delegated grant must be a subset of authority the caller can itself exercise. cascade grant add|list|revoke|audit administers the capabilities a node confers; cascade remote <device-id> drives a target reached over the discovery and connectivity stack. On top of the on-node grant list sits the signed capability-token model: cascade token issue|revoke|list mints and revokes tokens signed by the issuing node's real device key, which the bearer carries and presents with --token <file> on cascade remote. The node verifies the signature, expiry, and revocation list, then authorises the carried grant through the same path an on-node grant takes. Delegated tokens form bounded chains — each hop can only narrow authority, never widen it — and a token's expiry is clamped to its parent's, so a delegate never outlives the authority it derived from.SQLite at ~/.config/cascade/state.db. Tables: files, backends, pin_rules, lifecycle_policies, config_cache, sync_cursors, p2p_peers, p2p_block_index, grants, manage_audit. Full schema in docs/design.md.
async_trait for the Backend and VfsPresenter traits.anyhow for applications and thiserror for library crate error types.PlatformContext), not pulled from global APIs. Each OS provides its own implementation behind the same contract.create_backend function and implements the Backend trait.Cargo.toml: pedantic, nursery, and cargo Clippy groups are denied, plus unwrap_used, expect_used, indexing_slicing, string_slice, and unsafe_code. New code must satisfy these without #[allow] escapes.fusermount3. NFS fallback is different — binding a privileged port for NFS still needs sudo, so if FUSE is unavailable (missing libfuse3, no /dev/fuse) and you don't want to escalate, the daemon will fail rather than silently downgrade.cascade start runs net use * http://localhost:<port>/ which lets the OS pick the next free drive letter. If WebClient isn't running the mount fails immediately; start it once with sc start WebClient or set it to auto-start (see Prerequisites).$XDG_CONFIG_HOME/cascade/gdrive-tokens/<account>.json, falling back to ~/.config/cascade/.... Windows: %APPDATA%\cascade\gdrive-tokens\<account>.json, with the default NTFS ACLs restricting access to the current user.NfsCacheMode enum (off/minimal/full). off is read-only — writes are refused with NFS3ERR_ROFS/NFS4ERR_ROFS. minimal (default) is write-capable with minimal disk usage; full caches everything eagerly. Write-capable modes implement the full NFSv3 and NFSv4 write procedure set: WRITE, CREATE, SETATTR (size/mtime), MKDIR, REMOVE, RMDIR, RENAME, and COMMIT. All write procedures route through the same backend operations (upload, update, create_dir, delete, rename) as the WebDAV presenter.DiscoveryReach (lan-only/private/public) governs how far a device reaches for peers, defaulting to private — LAN discovery, gossip, hole punch, and peer relay across a trusted mesh, with nothing published to any global directory. Each discovery source self-activates only when the posture permits its level and it has what it needs (a bound listener, a configured server). Global publication to the Mainline DHT and announce servers is opt-in via the public posture; the DHT's bootstrap set is always present (empty falls back to the built-in public nodes), so disabling the DHT is a posture choice, not missing config. Rendezvous-by-presence is a complementary live-pairing path: two peers register under the same rendezvous key at the same instant, and the RendezvousBroker — a distinct in-memory component hosted alongside the relay server's SessionRegistry, not the same registry — exchanges their candidate sets and hole-punch agreements so they can connect directly; no durable state remains once either side disconnects. It activates under the public posture only and requires a configured rendezvous endpoint.report (work-laptop 2026-05-27).conflict). P2P-only folders use last-write-wins per-block.work/projects) appears as a directory when you list the parent (/work), shadowing a same-named entry, and a multi-segment mount prefix is shown nested at the right level rather than flat. Reads and writes route into the nested mount by longest-prefix match.gdrive appears at gdrive/Documents/… instead of Documents/…. To keep the old layout, add mount = "/" to that backend's config — an at-root mount is a first-class configuration, not a special case. Pin rules, lifecycle policies, and any stored files.path values written before this change need updating to include the mount prefix (e.g. Documents/** → gdrive/Documents/**). The state database schema is unchanged; only the semantics of files.path changed from a backend-relative path to a full VFS-absolute path..cascade formats in one directory is allowed — they merge in deterministic order: gitignore-style → TOML → YAML → JSON, with last-writer-wins for scalar settings.| Phase | Scope |
|---|---|
| v1 | NFS mount + .cascade (ignore only) + single backend (read-only, Google Drive) |
| v2 | Pinning + lifecycle + cache manager |
| v3 | Write-back + multi-backend + nested mounts + conflict resolution |
| v4 | Conditional rules (expressions + context providers) |
| v5 | macOS File Provider presenter (Swift extension), implemented |
| v6 | Adopt existing directories (local backend, adopt-and-sync, adopt-in-place) |
| v7 | P2P block sharing (LAN) |
| v8 | Windows native ProjFS presenter, implemented (Linux FUSE delivered earlier) |
| v9 | Full P2P (WAN discovery, NAT traversal), implemented |
| v10 | Node management plane (capability grants, remote administration over BEP), implemented |
| v11 | OS background service (`cascade service install |
Full timeline estimates, dependency list, and reference implementations in docs/design.md.
docs/design.md: core types, Backend trait definition, VFS tree implementation, .cascade parser details, expression grammar, NFS/FUSE/File Provider presenter internals, state database schema, wire protocol, Google Drive backend details.docs/deployment.md: deploying the announce Worker and relay server for WAN peer discovery and NAT traversal.ExaDev/cascade is a public repo on GitHub by ExaDev. Cross-platform cloud storage filesystem client in Rust with on-demand access, offline pinning, P2P block sync and several storage backends.
It declares no license on GitHub. Public does not mean open source: without a license, nobody is granted the right to reuse it.
Its maker tagged it for macOS, Windows and Linux, or as Docker or cross-platform. That is declared by the maker; Take My Repo has not tested it.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-16. GitHub counts 23 open issues and pull requests. Take My Repo does not judge from that whether it is maintained.
"rsync for cloud storage" - Google Drive, S3, Dropbox, Backblaze B2, One Drive, Swift, Hubic, Wasabi, Google Cloud Storage, Azure Blob, Azure Files, Yandex Files
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
SeaweedFS is a distributed storage system for object storage (S3), file systems, Iceberg table buckets, and Lance vector buckets, designed to handle billions of files with O(1) disk access and effortless horizontal scaling.
🌐 The Internet Computer! Free, Open-Source, and Self-Hostable.
💥 Blazing fast terminal file manager written in Rust, based on async I/O.
Cross-harness communication mesh for LLM agents, with rooms, direct messages, presence and visibility over TCP and no filesystem dependencies
TypeScript CLI, library, REST API and MCP server that moves, splits, joins and merges Markdown files and rewrites links between them
Vendor-neutral permission policy for AI coding agents, with a CLI, codecs, an evaluator and an MCP sync daemon that apply one .agents/permissions.json to Claude Code, Codex, OpenCode and Crush
TypeScript monorepo of MIT-licensed packages for lossless, type-safe document conversion across OOXML, OpenDocument, Markdown, EPUB and PDF
Web app for ranking any set of items through swipe-based pairwise comparisons, with shareable results
Tag and push a semantic-release release, then finish publishing it later, from a separate process after an external gate, without semantic-release core supporting this natively
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/ExaDev/cascadeTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.