Introducing

Know who changed what.
Even when it's not human.

Real-time code modification tracking for the multi-agent era.
One binary. Zero config. Total visibility.

curl -fsSL https://0diff.dev/install.sh | sh

Open source · MIT License · Built with Rust · By ZeroSuite, Inc.

The problem

AI agents write code under your name.
Nobody tracks who changed what.

You run Claude Code, Cursor, Copilot, Windsurf, or Devin alongside your team. They modify files silently, commit under your identity, and introduce changes that bypass review. Traditional tools like git diff and git blame were not built for this world.

"I had 100 agents spawned on a complex Rust project. One agent refactored a shared module. 4 other agents started failing silently. I didn't know for 45 minutes."

-- Senior engineer, distributed systems team

The cost

Untracked changes cost real money.

Change-related regressions are the #1 preventable source of production incidents.

23%

of developer time spent debugging untracked modifications

4.2h

average time to identify root cause of change-related regression

$680K

average annual cost per team from preventable change incidents

67%

of production incidents trace to a change that bypassed review

The solution

0diff: real-time visibility
into every change.

A single Rust binary that watches your codebase, computes intelligent diffs,
identifies who made each change (human or AI), and logs everything.

0diff watch

$ 0diff watch

▶ Watching 847 files across 23 directories...

▶ Git: main branch, 3 contributors tracked

[14:32:05] src/parser.rs +12 -3 (alice on feature/parser)

@@ -45,3 +45,12 @@

- fn parse_expression(&mut self) -> Result<Expr> {

+ fn parse_expression(&mut self, precedence: u8) -> Result<Expr> {

[14:33:41] src/checker.rs +47 -2 (⚡ Claude Agent on fix/enum-collision) [AI AGENT]

+ fn resolve_name_shadowing(&mut self, scope: &Scope) {

Key features

Everything you need.
Nothing you don't.

Real-Time Watching

Native inotify/FSEvents monitoring. Debounced. Instant detection, zero CPU overhead.

Smart Diff Engine

Myers algorithm. Line-level precision. Whitespace and comment filtering built in.

Git Attribution

Automatic blame, branch detection, and author identification on every change.

AI Agent Detection

Identifies Claude, Cursor, Copilot, Windsurf, Devin via commit headers, env vars, and TTY heuristics.

Searchable History

JSON-lines log. Query by author, file, date, branch, or agent. Full audit trail.

Single Binary

Written in Rust. ~2 MB static binary. No runtime, no dependencies. Install with curl.

Killer feature

Built for the age of
AI-assisted development.

The first code tracking tool designed for human + AI codebases.

Detection Methods

Co-Authored-By commit headers
Commit message keyword analysis
Environment variable scanning
TTY / non-interactive session heuristic

Agents Detected

Claude Code / Claude Agent
Cursor
GitHub Copilot
Windsurf / Devin

Custom patterns configurable in .0diff.toml — detect any agent.

Comparison

Why not just use `git diff`?

Capability	git diff	watchexec	fswatch	0diff
Real-time file watching	--	✓	✓	✓
Smart diff engine	✓	--	--	✓
Author attribution	manual	--	--	auto
AI agent detection	--	--	--	✓
Searchable history	--	--	--	✓
Notifications (Slack/Discord)	--	--	--	✓
Background daemon mode	--	--	--	✓
Single binary, zero deps	✓	✓	build	✓

Who it's for

Built for how you actually work.

Solo Developers

Using AI assistants daily. Need to know what the AI changed vs what they wrote.

Dev Teams

Distributed across time zones. Need real-time awareness of each other's changes.

Tech Leads / CTOs

Need the big picture: hotspots, author summaries, and flagged sensitive file changes.

Critical Systems

Database migrations, auth logic, payment code. Zero tolerance for silent changes.

Architecture

Lean. Fast.
Deliberately simple.

Written in Rust -- ~2,400 lines of code
No async runtime, no heavy frameworks
Myers diff algorithm via similar crate
OS-native file watching (inotify / FSEvents)
JSON-lines append-only history with rotation
Shell-based git integration (no libgit2)
11 well-vetted dependencies
44 unit tests, 0 failures

src/

main.rs CLI entry (clap derive)

config.rs .0diff.toml parsing

watcher.rs FS events + debouncer

differ.rs Myers diff engine

filter.rs Whitespace filtering

git.rs Blame, branch, author

agents.rs AI agent detection

history.rs JSON-lines log

output.rs Terminal + JSON output

Release binary: ~2 MB

Dependencies: 11

Tests: 44 passing

Roadmap

Where we're going.

v0.1

Foundation -- shipped

Watch, diff, log, status, init. Git attribution. AI agent detection. JSON output. Single binary.

v0.2

Notifications

Background daemon mode. Slack / Discord / webhook integrations. Daily digest summaries.

v0.3

Intelligence

Comment filtering. Critical file alerts. Multi-agent collision detection. File-level watch rules.

v1.0

Ecosystem

VS Code extension. GitHub Actions integration. Cross-platform release CI/CD. Homebrew tap.

Stop guessing.
Start watching.

Open source. Free forever. MIT License.
A single Rust binary. Zero configuration.

Install 0diff View on GitHub 0diff.dev