Releases: TheHolyOneZ/ZFileTimeMachine
ZFileTimeMachine v0.1.0
ZFileTimeMachine
A local, private, automatic version history for any folder on your computer.
Think of it as Time Machine for individual files — but lighter, faster, and entirely yours.
Download prebuilt binaries for Linux, Windows & macOS → zsync.eu/zftm/
What is ZFileTimeMachine?
ZFileTimeMachine watches folders you choose and automatically saves a copy of every file every time it changes. At any moment you can scroll back through a file's history, see exactly what changed between versions, and restore any version instantly — with a single click.
No cloud. No git. No command line. Just your files, safely versioned, on your own machine.
Note
This is not a backup tool in the traditional sense. It does not copy files to an external drive or upload them anywhere. It is a local version history system — it keeps a record of every version of your files so you can go back in time whenever you need to.
Why Was It Made?
Every developer, writer, or power user has had this moment: you made a change, saved the file, and then realized the old version was exactly what you needed. You hit Ctrl+Z — too late, the session is gone. You check git — you never committed it. You look in Recycle Bin — nothing there.
ZFileTimeMachine was built for exactly that moment.
It was also built because existing solutions all require a compromise:
- Git is incredible but requires learning, intentional commits, and a command line
- Cloud services (Dropbox, Google Drive history) lock your data to their servers and subscription fees
- System snapshots (Time Machine, VSS) operate at a disk level — slow, large, inflexible
- Manual backups only work if you actually remember to do them
ZFileTimeMachine sits in a gap nothing else fills: automatic, per-file, local, zero-friction version history that just runs silently in the background.
Who Is It For?
|
You'll love this if you...
|
Especially useful for...
|
Core Strengths
Tip
These are the things ZFileTimeMachine does exceptionally well — not features bolted on, but design decisions baked in from the beginning.
| Strength | What it means for you |
|---|---|
| 100% Local & Private | Your files never leave your machine. There is no account, no sync, no telemetry, no internet required. |
| Zero Friction | Add a folder, walk away. Everything else is automatic. You don't think about it until you need it. |
| Smart Deduplication | If ten files share the same content, only one copy is stored. Large projects with many similar files stay lean on disk. |
| Safe Rewinding | Before restoring any file, the app automatically saves its current state first. You can always undo the undo. |
| Surgical Control | Restore one specific file, or all 200 at once. Target the latest version, Nth from latest, or any exact point in time. |
| Binary-Aware | Images, compiled outputs, and binary files are handled separately — tracked but not diffed, with configurable storage limits. |
| Lightweight Backend | Built in Rust. The background watcher uses almost no CPU or RAM even on large folders with thousands of files. |
Features
Automatic Snapshots
ZFileTimeMachine watches your folder continuously. When a file changes, it captures a snapshot. You choose how this works per folder:
- On Change — snapshot the moment a file is saved
- Interval — snapshot every X minutes, regardless of changes
- Manual — only when you click the camera icon yourself
- Hybrid (recommended) — debounce rapid changes AND take periodic checkpoints
Important
Snapshots are not copies of your entire folder. The app uses a content-addressed store — only the unique content of each changed file is saved, deduplicated by hash. Two files with identical content take up space only once. This keeps storage usage surprisingly small even across hundreds of versions.
File Timeline & Diff Viewer
Every tracked file has a full timeline showing every version ever saved. Click any entry to see:
- What changed — a line-by-line diff (green = added, red = removed)
- When it changed — exact timestamp
- How much it changed — byte delta from the previous version
- Why it was captured —
change,interval,manual, orpre-rewind - Your notes — attach a personal note to any snapshot
The diff viewer supports search (including regex), so you can find exactly when a specific line was introduced, changed, or removed across the entire history of a file.
One-Click Rewind
Found the version you need? Click Rewind. The app:
- Shows you a full diff of exactly what will change
- Optionally saves your current file as a new snapshot first (so you can undo the rewind)
- Atomically replaces the file with the chosen version and verifies the write was successful
Caution
When Restore in Place is used, the current file is overwritten. The app automatically creates a pre-rewind snapshot before writing, but make sure you understand what you're restoring before confirming — especially when restoring multiple files at once.
Bulk Recovery
Lost multiple files at once? Bad refactor that touched 80 files? Accidentally deleted a whole folder?
The Recover Folder screen lets you:
- Browse and select any combination of files from a visual checkbox tree
- Choose a snapshot point: latest version, Nth from latest, or any specific date and time
- Choose a destination: export to a new folder (completely safe, non-destructive) or restore in place (replaces current files)
- Preview first — run a dry run to see exactly what would be written before anything is touched
- Handle conflicts — skip existing destination files or overwrite them
- Recover soft-deleted files — if a file was deleted from the watched folder but snapshots exist, it can be restored
- Filter with ignore patterns — recover everything except
node_modules/,target/, etc.
Note
Export mode is completely non-destructive. It copies snapshot content to a new location and never touches your original files. When in doubt, always export first.
Notes & Search
Attach plain-text notes to any file or any snapshot:
- "This was working before the refactor"
- "Version sent to client on Monday"
- "Broke everything — pinning this as reference"
All notes are full-text searchable from the folder view. Click a search result to jump directly to the file or the exact snapshot that matches.
Retention Rules
You control how many snapshots are kept per folder, so your storage doesn't grow forever:
| Rule | How it works |
|---|---|
| Keep Last N | Always keep the most recent N snapshots per file |
| Time-Based | Keep all snapshots from the last X days |
| Hybrid | Keep the last N snapshots AND anything within the last X days |
Old snapshots are cleaned up automatically. The deduplication store is garbage-collected so freed snapshots actually free disk space.
Binary File Support
ZFileTimeMachine tracks binary files (images, compiled outputs, archives) with smart limits:
- Configurable maximum size per binary file (default: 50 MB)
- Configurable maximum copies kept (default: 3 most recent)
- Binary files appear in the timeline but diffs are unavailable — you can still rewind them
- Files exceeding your size limit are tracked in the database but not snapshotted
Pause, Resume, and Soft Delete
- Pause a folder — temporarily stop watching without losing any history. Useful when doing a large batch operation you don't want versioned.
- Resume — the watcher picks up exactly where it left off
- Remove a folder — soft-deleted for 7 days so you can reconsider; then permanently removed. Your original files are untouched.
Storage Stats & Health
The Settings screen shows you exactly what is happening with your storage:
- Total physical storage used (after deduplication)
- Logical size vs. physical size (how much space deduplication is saving you)
- Per-file storage breakdown for any folder
- A built-in integrity checker to verify your snapshot database is healthy
- A QA test suite that runs a live end-to-end recovery test against your real backend
Ignore Rules
Tell ZFileTimeMachine what to skip, using the same gitignore syntax you already know:
node_modules/
targe...