Skip to main content
Dits LogoDits
Open Source • Apache 2.0 + MIT

Version Control, Reimagined for Media

Dits is a distributed version control system built from the ground up for video production, game development, and large binary files. Finally, version control that understands your workflow.

Get StartedRead the Docs

Our Mission

We believe every creative professional deserves version control that works for them — not against them. Git revolutionized how developers collaborate, but it was never designed for the massive files that define modern media production.

Dits exists to bridge this gap: providing the full power of distributed version control to video editors, game developers, 3D artists, and anyone who works with large binary files. No workarounds, no extensions, no compromises.

Why We Built Dits

The story of Dits began with frustration. Working on video projects with distributed teams, we constantly hit the limits of existing tools. Git LFS felt like a band-aid, Perforce required expensive infrastructure, and nothing understood the unique patterns of video files.

We asked ourselves: what if we could build version control specifically for media? What if we could leverage content-defined chunking to find the actual changes in video files? What if we could make terabyte repositories feel as fast as kilobyte ones?

Dits is the answer to those questions. Built in Rust for performance, designed with media workflows in mind, and open source so everyone can benefit.

$ dits add project.prproj
$ dits add media/

Adding 847 files (1.2 TB)
Chunking: ████████████ 100%
Deduplication: 67% (412 GB saved)

$ dits commit -m "Final cut v3"
[main abc1234] Final cut v3
  847 files, 788 GB (net)

Illustrative example. See real benchmark numbers below.

The Problem with Existing Tools

Problem: Git can't handle large files efficiently

Solution: Content-defined chunking with deduplication

Problem: Storing multiple versions wastes space

Solution: Only unique chunks are stored

Problem: Cloning large repos takes forever

Solution: VFS mount (local fuser build today; remote hydration on the roadmap)

Problem: Binary files don't merge

Solution: File locking prevents conflicts

Problem: No video-specific optimization

Solution: Keyframe-aligned chunking for video

Chunk, hash, deduplicate

Instead of storing files as single objects, Dits breaks them into content-defined chunks, names each by its BLAKE3 hash, and stores every unique chunk exactly once — across versions, files, and projects. The full walkthrough, with diagrams and the honest Git-vs-Dits comparison, lives on its own page.

See how Dits works

What we're actually building

Dits is in active alpha. To set expectations honestly, here's exactly what works today versus what's still on the roadmap.

Working today
The local-first engine you can run right now.
  • Content-addressed object store with BLAKE3 verification
  • FastCDC chunking, dedup, and byte-exact reconstruction
  • Structure-aware MP4/ISOBMFF parse → deconstruct → reconstruct
  • Convergent AES-256-GCM encryption
  • Hybrid Git (libgit2) text + Dits binary storage
  • Local commit / add / status / diff / log / branch / merge / checkout
  • Local-filesystem clone & push
  • FUSE virtual filesystem mounts — dits mount / unmount (requires a --features fuser build; works locally, remote hydration is roadmap)
  • Local file locking (dits lock / unlock / locks)
  • FACR frame-addressable video (experimental — try dits facr-demo)
On the roadmap
Designed and scaffolded — don't rely on these yet.
  • QUIC delta sync (network push / pull / fetch is scaffolding today)
  • P2P rendezvous & NAT traversal
  • Bi-directional sync over a network remote
  • Server-coordinated distributed locking for teams

Where Dits wins — and where it loses

Real numbers from a benchmark spike against git-lfs, restic, borg, and xdelta3. The differentiator is the format-aware layer — and we show the case where generic chunking loses, because that's what makes the wins credible.

98.3%

deduplicated on a frame-addressable re-grade (store 5 changed frames, reuse 295)

7.4×

less data shipped on an incremental streaming re-publish (re-encode 1 of 6 segments)

0.19 MiB

stored for a metadata-only MP4 change — beats restic (0.77) and borg (5.93)

Loses

on a full video re-export: generic chunking can't help when every byte shifts. We say so.

See the full comparison

Open core, hosted convenience

Dits follows an open-core model inspired by Git and GitHub. The core is fully open and self-hostable; the hosted platform adds scale and managed services.

Dits (open source core)
  • CLI, libraries & protocol — run locally or self-host
  • Open data formats and wire protocol
  • Local-first, works offline
  • Apache-2.0 / MIT
Ditshub (hosted platform — planned)
  • Managed cloud built on the open protocol (roadmap)
  • Real-time collaboration & permissions (roadmap)
  • Cloud render / transcode compute (roadmap)
  • Everything it does will be possible self-hosted

Built for Creative Professionals

Whether you're a solo creator today or planning for a larger team as sync lands, Dits is built to adapt to your workflow.

Video Production Teams
From solo YouTubers to small studios today, with larger teams as the networked sync engine lands. Track every cut, every render, every revision.
Documentary projectsCommercial productionVFX pipelinesColor grading workflows
Game Developers
Manage textures, models, audio, and cinematics alongside your code in one unified workflow.
Asset managementBuild pipelinesCinematic sequencesLocalization files
Creative Agencies
Collaborate on design files, brand assets, and multimedia projects without the chaos.
Brand asset librariesCampaign materialsClient deliverablesArchive management
Enterprise Media (roadmap)
The longer-term goal: scale version control across departments with fine-grained access control and audit trails. These team features depend on the networked sync engine still in development.
Broadcast archivesCompliance trackingMulti-site collaborationLegacy migration

Built with Modern Technology

We've chosen the best tools for performance, reliability, and security.

Rust

Core engine for performance and safety

Memory-safe systems programming with zero-cost abstractions. Rust ensures reliability without sacrificing speed.

BLAKE3

Fast cryptographic hashing

10x faster than SHA-256 while maintaining cryptographic security. Enables rapid content verification at scale.

FastCDC

Content-defined chunking algorithm

Intelligent file splitting that finds natural boundaries. Insertions and deletions only affect nearby chunks.

FUSE/ProjectedFS

Virtual filesystem support

Files appear local but download on-demand. Work with terabytes without filling your disk.

QUIC

Modern transport protocol

Multiplexed connections, built-in encryption, and improved performance over unreliable networks.

Roadmap

We're actively developing Dits and committed to transparency about our progress.

Alpha● Active Development
Core Functionality
CLI implementation, basic operations, local chunking and deduplication
  • Init, add, commit, log
  • Content-defined chunking
  • BLAKE3 hashing
  • Local storage backend
Beta○ Coming Soon
Collaboration Features
Remote operations, file locking, and basic networking
  • Push/pull operations
  • File locking
  • Remote tracking
  • Conflict resolution
1.0○ Planned
Stable Release
Remote virtual filesystem hydration, team features, and broader platform support
  • FUSE/ProjectedFS VFS
  • Windows/macOS/Linux
  • Access control
  • Performance optimization
Future○ Planned
Advanced Features
P2P networking, cloud integrations, and specialized tools
  • QUIC-based P2P
  • Cloud storage backends
  • CI/CD integrations
  • NLE plugins

Our Values

Open Source

Dual-licensed under Apache 2.0 and MIT. Free to use, modify, and distribute. Your data belongs to you.

Community Driven

Built for and with the media community. Your feedback shapes the roadmap. Join the conversation in GitHub Discussions.

User First

Designed for real workflows. Git-like commands make adoption easy. We listen to creators, not marketers.

Join the Community

Dits is open source and community-driven. There are many ways to get involved.

Core Development
Contribute to the Rust codebase, fix bugs, and implement new features.
Get Started
Documentation
Improve guides, write tutorials, and help new users get started.
Get Started
Community Support
Answer questions, share knowledge, and help grow the community.
Get Started
Testing & Feedback
Test new features, report bugs, and provide valuable user feedback.
Get Started

Star us on GitHub

Help spread the word by starring our repository

Star on GitHub

Ready to Take Control of Your Media?

Download Dits and experience version control built for how you actually work. It's free, open source, and ready to handle your biggest projects.

Download DitsRead the Docs