Less data moved.
A smaller cloud bill.
You changed a few frames of a video. Here's how much less dits had to store and move — and what that saves in real dollars — measured against the tools people actually use, on one computer.
Every comparison below is measured on one machine; project-over-time and scaling projections are clearly labeled. The honest losses are shown too — starting with the next section.
Most tools re-save the whole file. dits saves only the part you changed.
Imagine fixing one typo in a 400-page book — then being forced to reprint all 400 pages. That's what normal backup and version tools do with video. dits reprints the one page.
The catch: to do that, a tool has to understand what's inside a video. Most don't. Below, we show exactly where that matters — and where it doesn't.
Sometimes nothing helps much. We'll show you that too.
When a video editor exports a finished clip, almost every byte gets rewritten — even the parts that look the same. So even the smartest tools skip only a little. dits' basic mode does no better here.
If dits doesn't understand the video, it's no better than zipping a file. That's the whole reason the next pages exist.
Re-color a few frames?
You touched a handful of frames; dits stored a handful of frames. Storage and upload shrink by ~98% for that edit.
Tweak a 2-second moment in a stream?
Most streaming setups re-process and re-send the entire video after any change. dits rebuilds only the piece you touched — the rest is reused byte-for-byte.
Just changed the title or a setting?
Here's the honest part: the good general-purpose dedup tools handle this well too — restic skips ~95% of it. dits edges ahead, but structural edits aren't where the gap is. The real difference is frame work (chapters 03–04), not renames.
Yes. The engine under the hood.
The math that fingerprints and slices your files runs at hundreds of megabytes per second. We track it every commit so it never slows down.
The same edit, translated into dollars and minutes.
Bytes are abstract. So we convert the result into the things people feel: your cloud bill and your upload time.
Measured dedup applied to a 1 GB clip. Assumptions: S3 Standard $0.023/GB-mo · egress $0.09/GB · 50 Mbps upload. No hidden math.
(Translation of our measured frame-dedup to a 1 GB reference clip. On a full re-export, where dits' basic mode doesn't win, there's no saving — see chapter 02.)
Every re-transfer is a line item on a cloud invoice.
Whole-file tools (Git LFS, manual copies) move the entire asset every time it changes. dits' content-defined chunking + delta transfer moves only the changed chunks. Priced at real cloud egress rates, that gap is money.
One small edit to a 10 GB asset
A localized change (re-color a few frames). Whole-file tools re-transfer the entire 10 GB; dits transfers only the ~200 KB of changed chunks — the same figure as the engine's measured delta. Cost = GB transferred × egress rate.
| Per edit, transferred | Data moved | @ $0.09/GB (S3) | @ $0.01/GB (B2) |
|---|---|---|---|
| Git LFS / manual | 10 GB | $0.90 | $0.10 |
| dits | ~200 KB | < $0.01 | < $0.01 |
That's 100% less data per edit — and the dollar gap compounds every time the asset is distributed.
A 5-person team, one month
Stated assumptions: 5 collaborators, 3 edits/day over 22 working days (66 new versions/month) on the same 10 GB asset. Each new version is pulled by the other 4 teammates — and egress (data-transfer-out) is what cloud providers bill for serving those pulls. Whole-file tools download all 10 GB each pull; dits downloads only the changed chunks.
| Per month, served out | Egress (GB) | @ $0.09/GB (S3) | Per year |
|---|---|---|---|
| Git LFS / manual | 2,640 GB | $237.6 | $2,851.2 |
| dits | 52 MB | < $0.01 | $0.05 |
| You save | 2,640 GB | $237.6/mo | $2,851.15/yr |
Edit after edit, the storage piles up — except for dits.
One edit is nice; the real story is a project's life. We made 15 localized edits to one clip and tracked every tool's store. dits keeps only the frames you change, so it barely grows. git-lfs re-stores the whole file each time; restic's byte-level dedup can't see across the re-encode, so it climbs too. Measured, not projected.
The bigger the file, the more dits saves.
Same localized edit, clips of growing size. Frame-addressing cost tracks the edit, not the file — so the bigger the clip, the smaller a fixed edit looks, and the more dits skips. It beats byte-level dedup at every size (storing several times less even where restic does best). Measured, not projected.
Every tool, every test, five ways.
Storage saved, bytes uploaded, time, memory. Including the tests where dits doesn't win. Download it as a spreadsheet.
| What you did | git-lfs | restic | borg | xdelta3 | dits-generic |
|---|---|---|---|---|---|
| Re-export a finished clip | 0% | 17.9% | 14.6% | 21.3% | 0% |
| Rename / metadata fix | 74.9% | 64.1% | 100% | 98.8% | |
| Re-color a few frames | 98.3% | ||||
| Edit 2s of a stream | 77.2% | ||||
| Trim / cut a clip | 100% | ||||
| Non-destructive photo edit | 100% | ||||
| Color-grade the whole clip | 0% | 0% |
Some edits cost dits literally zero bytes.
Trim a clip or tweak a photo, and dits stores the instructions — not a new copy. The original is reused untouched. And where dits genuinely can't help (a whole-clip re-grade), we say so.
Trim a clip
0 bytesCut the first second; dits just remembers the new in/out points.
Edit a photo
0 bytesCrop, brighten, filter — dits stores the recipe, reuses the original pixels.
| Edit type | Best other tool | dits | You save |
|---|---|---|---|
| Trim / cut | re-stores the trimmed file | 0 bytes | 100% |
| Non-destructive photo edit | re-stores the full image | 0 bytes | 100% |
| Color-grade the WHOLE clip | 0% (restic) | 0% | ~0% (honest) |
One command re-runs every number on your own machine.
Same computer, same files, real tools. No cherry-picking, no marketing math. The test videos and the raw results live in the open-source repo.
Where dits loses, out loud: on a full re-export, dits' basic mode is no better than the rest (see chapter 02). On a whole-clip color grade, every tool — dits included — re-stores nearly everything. Format-awareness helps with localized edits, not total rewrites. How it works →