Comparison

Swarmfile vs. Lore

Lore is Epic Games' open-source next-generation VCS for projects that mix code with very large binary assets. It's good work and we respect it. But Lore and Swarmfile are different shapes - a version control system you check out and commit to, versus a virtual filesystem you mount and open files from. Here's the honest side-by-side, both ways. Last reviewed August 2026.

The frame that matters
VFS
not VCS

A mounted drive, not a workspace to clone. Resolve, Premiere, Revit open files at native paths with no checkout step.

SaaS
not self-host

Cloud tier, identity, billing, alarms, R2 storage - all managed. Lore is yours to deploy and run.

LAN
P2P mesh

Every workstation seeds to its neighbors. One cloud fetch per office, not per editor.

Where Lore is stronger today: it's MIT-licensed and free, ships a native library (C/C++, Rust) plus bindings for JavaScript, C#, Python and Go, and is built around the branch-and-commit workflow that engineers already know. We don’t hide it - see the full side-by-side below.

Product shape

Capability
Swarmfile
Lore
How users access files day-to-day
Mount a drive on every workstation. Resolve, Premiere, Revit, ArcGIS open files at native paths - no checkout, no sync step.
Clone a workspace, hydrate, branch, commit. The VCS shape from Git/Perforce, adapted for huge binaries.
Workflow assumption
Editors, artists, BIM coordinators who don't want to learn a VCS. Files just appear.
Engineers + technical artists who already think in branches and commits.
Local disk required for a project
Zero until you read. A 5 TB project occupies bytes of metadata; only opened ranges hit the LRU block cache.
Sparse workspaces hydrate on demand, but the workspace is still a working tree of files on disk.

Lore is a version control system. Swarmfile is a virtual filesystem. Different workflow, different muscle memory - pick the one that matches how your team already opens files.

Architecture & data plane

Capability
Swarmfile
Lore
Content-addressed storage (Merkle / CID)
BLAKE3 per block.
Merkle trees, immutable revision chains.
Chunked storage with deduplication
FastCDC with per-file-type profiles (Revit headers, Avid index files, .prproj).
Chunked storage with dedup; maps content types to chunking strategies (CDC vs fixed-size).
On-demand byte-range streaming
Open a 200 GB file, stream only the byte ranges your app reads.
On-demand hydration; hydrated files sit on disk today (a virtual file system is on Lore's roadmap).
LAN-first P2P between workstations
Iroh private swarm + mDNS. One cloud fetch per office, not per editor.
-Centralized service-backed architecture with caching.
Managed cloud backend
Cloudflare R2, zero-egress. Nothing to provision.
-You run the service. Local mode out of the box; scale-out is on you.
Self-hosted seed node / cache appliance
Optional NAS seed on Pro and above.
Entirely self-hosted - that's the model.
Zero-stall writes
Saves return immediately; durable upload queue, exponential backoff, restart-safe.
Commits are explicit user actions; the VCS shape doesn't include async write durability.

Both content-address and chunk. We add a LAN P2P mesh and a managed cloud tier; Lore is centralized client/server you run yourself.

Versioning & branching

Capability
Swarmfile
Lore
Per-entry version history + point-in-time rollback
1-3650-day per-user retention. Per-user trash + restore.
Immutable revision chain; rollback to any revision.
Atomic multi-file commits (changesets)
Shipped (Mode A auto-landed groups and Mode B staged atomic submit): changesets are named, revertable, DAG-ordered, surface in the activity feed and a per-project Commits tab.
Native to the VCS model.
Lightweight branches + fast switching
Per-workspace branches (Perforce-streams model): each mount selects a branch and diverges independently, then merges back - whole-file, with conflict detection - into main or any parent branch.
Free, lightweight branches - a Lore headline feature. Branch-switching is near-instant and arbitrarily cheap; ours is mount-scoped, not git-native.
Merge / conflict resolution
Branch merge lands a whole-file merge (modifies, deletes, adds, new folder subtrees, rename propagation) back onto main or a parent branch, with conflict detection. Hub-side conflict resolution separately handles ambient (no-lock) writes outside of branches.
VCS-style merge primitives. Binary merge is still a hard problem industry-wide.
Tamper-evident revision chain
BLAKE3 content addressing + per-tenant audit log + unified activity feed.
Verifiable, tamper-evident chain - a stated Lore guarantee.

Lore was built around the VCS workflow - branches are the headline, and they're lighter-weight than ours. We ship per-workspace branching + merge too - coarser-grained, but real, automatic, and shipped today.

Collaboration & locking

Capability
Swarmfile
Lore
Cooperative file locks
Entry locks, 60s TTL, heartbeat.
Basic advisory file locking today; enforcement and scale are on the roadmap.
Byte-range locks (Revit / SolidWorks worksharing)
Hub + engine API ready and tested. Revit add-in not yet started.
-
Real-time presence (who's editing what)
Lock-lifecycle-driven roster; SSE stream to web + tray.
-
Per-file comments + @mentions
Markdown thread per entry, mention chips, share-link comment surface for external reviewers.
-
Disconnect-and-resync (Pack & Go + casual offline)
Pin a folder, checkout lock (7-day default, no heartbeat). Casual-offline auto-pins recent work and replays ambient writes with baseCid on reconnect.
VCS pattern: commit locally, push on reconnect. Different shape, similar effect.

Locking is the way binary-asset teams avoid merges they can't resolve. The full lock + presence + comments + ACL surface is built into Swarmfile.

Identity, access, sharing

Capability
Swarmfile
Lore
SAML / OIDC SSO
Included on Pro.
-Out of scope - you wire it into your deployment.
SCIM 2.0 + LDAP / AD sync agent
Included on Pro.
-
Folder & file-level ACLs
Allow / deny / inherit, recursive resolution, Windows DACL projection.
Repository-level permissions are typical for VCS; per-path ACL not advertised.
External collaborator / client review
Named guests + share links with password gate, expiry, access caps, inline preview, optional comment thread.
-

Lore is a tool you run; auth is bring-your-own, with partition/sub-repo-level access control built into its data model. Swarmfile ships SSO, SCIM, LDAP, ACLs, and share links on Pro.

Security & data protection

Capability
Swarmfile
Lore
AES-256-GCM encryption at rest + in flight
Per-project keys wrapped by hub KEK.
Self-host - encryption is your deployment's responsibility.
Erasure coding (Reed-Solomon 10+4)
Adaptive per WAN/LAN topology.
-
Inline ransomware detection + quarantine
CID-overwrite anomaly detector.
-
Block-level integrity verification
BLAKE3 per block on every fetch.
Content-addressed verification.
Unified audit / activity feed
Cross-source feed (history + ACL + quarantine + audit + notifications + unlock requests). Owner CSV export.
Revision log is the audit trail; cross-cutting access / quarantine surfaces are out of scope.
SOC 2 Type II
-Type I not started (planned).
N/A for an OSS project - compliance is the deploying org's responsibility.

Reach & platform

Capability
Swarmfile
Lore
Native drive mount (macOS / Windows / Linux)
FUSE on macOS/Linux, WinFsp on Windows (arm64 + amd64). Apps see a real volume.
-Workspace on disk, not a virtual drive. Different paradigm.
CLI
A real git/Perforce-vocabulary CLI on every mount - branch, commit, checkout, merge, log, tail - plus standalone swarmfile-migrate, swarmfile-search, and swarmfile-doctor.
Full-functionality CLI is a Lore design goal.
Multi-language SDK (native C/C++, Rust; bindings for JS, C#, Python, Go)
Rust engine + REST API. No first-party multi-language SDK.
Native library (C/C++, Rust) plus bindings for JavaScript, C#, Python and Go - a real edge if you're embedding version control into a build pipeline.
Integration with native creative tools (Resolve, Premiere, Revit, ArcGIS, …)
Mount-the-drive UX. Any app that opens files by path works. File-type-aware chunking profiles for AEC + M&E.
Possible via SDK or workflow tooling, but not the out-of-the-box shape.
Verticals served
M&E · Geospatial · AEC (Revit worksharing on the roadmap).
Games + entertainment (Epic's stated target).

Openness & licensing

Capability
Swarmfile
Lore
License
Proprietary SaaS. Data portability via the migration CLI and content-addressed object storage.
MIT - fully open source.
Self-host the whole stack
Seed nodes self-host. The control plane (hub + IdP) is managed SaaS.
Whole stack is yours.
Source available for audit
-Architecture is documented in depth; source is not public.
Managed SaaS - zero ops overhead
Sign up, mount, work. The cloud tier, the auth, the billing, the alarms all run themselves.
-You stand it up and keep it running.

Lore is open source. That is the single biggest thing they have and we don't. If your procurement story requires source availability and no vendor lock-in, talk to them.

Pricing

Capability
Swarmfile
Lore
Model
Per-seat SaaS. Storage included.
Free, MIT-licensed. You pay for the infrastructure you run it on.
Entry tier
$5/seat/mo Starter - 100 GiB/seat, capped at 5 seats.
$0. Self-host.
Team tier
$25/seat/mo Pro - 500 GiB/seat, SSO + SCIM + LDAP included.
$0 license + your infra + your ops time.
Hidden cost
Per-seat add-up at scale; transparent on the pricing page.
Engineering time to deploy, scale, monitor, secure, patch, and support an OSS VCS for your studio.

Where Swarmfile is stronger today

  • You don't learn a VCS. Mount the drive, open the file. The editor, colorist, BIM coordinator, or surveyor never sees the version-control surface unless they want to - the Commits tab in the dashboard is there if they do.
  • Zero local disk for huge projects. Byte-range streaming with an LRU block cache. A 5 TB project occupies a few MB of metadata until someone reads a file. Lore's sparse-workspace model is closer than most VCSes, but a hydrated file still lives on disk.
  • LAN-first P2P on every plan. Iroh private swarm + mDNS. One cloud fetch per office, not per editor. No appliance to deploy.
  • Real locking and presence, not just merges. Entry locks with heartbeat, byte-range locks for Revit-class worksharing, lock-lifecycle-driven presence roster, comments and @mentions per file. Binary assets don't three-way-merge; the antidote is knowing who else has the file open.
  • Per-workspace branching with automatic merge, no VCS required. Select a branch on your mount, work independently, then merge whole-file changes - with conflict detection - back into main or any parent branch. Lore's branches are lighter and git-native; ours don't require learning a VCS to use.
  • SSO, SCIM, LDAP, ACLs, DACL projection. The identity and access surface most procurement teams will ask about, included on Pro. With Lore that's on your deployment team.
  • Erasure coding + ransomware detection + block integrity. Reed-Solomon 10+4, inline CID-overwrite quarantine, BLAKE3 per block. Three layers of data protection built into the managed tier.
  • External collaborator sharing. Named guests and public share links with password gate, expiry, access caps, inline preview, optional comment threads. The client-review motion M&E and AEC firms run every week.
  • Multi-vertical from day one. M&E, Geospatial, and AEC. Lore targets games and entertainment.

Where Lore is stronger today

  • Open source under MIT. The single biggest thing they have and we don't. If procurement requires source availability, full audit, or zero vendor lock-in, Lore is the answer.
  • Native library + multi-language bindings A native C/C++/Rust library plus bindings for JavaScript, C#, Python, and Go. If you're embedding version control into a build pipeline or a game engine, that's a real edge. We expose a REST API and a Rust engine; we don't ship a multi-language SDK today.
  • First-class branching. Lightweight branches and fast switching are core to the Lore model - near-instant and arbitrarily cheap. We ship per-workspace branching + merge too, but ours is mount-scoped rather than git-native; if your team wants to branch constantly and switch fast, Lore's model is lighter.
  • Free at any scale (you pay only for the infrastructure you run on). Our Starter is $5/seat/mo; Pro is $25/seat. If your team has the ops capacity and your budget prefers capex to opex, Lore wins on sticker.
  • Backed by Epic Games. A credible long-term steward. We're smaller and independent - which means we ship every week and you deal directly with the people building it.

Pick the shape that matches your workflow.

If your team thinks in branches and commits, has the engineering capacity to self-host, and wants open source - Lore is a great answer. If your team opens files in Resolve, Premiere, Revit, or ArcGIS and wants a mounted drive without an ops project - start a trial.