Trace
Open any asset in the graph
Pan, zoom and follow inbound and outbound edges until the reference chain is obvious.
Unity 6 Editor tool · v1.3 · Addressables audit
See every reference.
Trust every delete.
An interactive dependency graph that reads your assets, your scripts and your Addressables bundles — so the thing you are about to delete is the thing you meant to delete.
- Code awareReads string loads
- ReversibleVerified backups
- Editor-onlyNo build cost
Built for the moment before you delete
Every cleanup tool has the same blind spot.
Nothing in Unity's AssetDatabase records that a script calls
Resources.Load("Prefabs/Enemy"). Zion Dependency Graph reads your
assets and your scripts and your Addressables bundles, then shows
you the evidence — as a graph you can pan, zoom and click through.
- 50k+
- Assets indexed per project
- 5
- Analysis tabs
- 3
- Load patterns detected
- 0
- Unrecoverable deletes
Prove
Check what code does
String loads, Shader.Find calls and Addressables keys resolved to real assets, with file and line.
Remove
Delete with a way back
Every asset and its .meta is copied and verified on disk before anything leaves the project.
Release notes
New in v1.3.
Headline feature
Addressables audit
Object-level bundle analysis that flags the assets genuinely duplicated across your bundles — and quietly clears the false positives Unity's own reporting leaves behind.
- Object-level duplication Compares the actual objects pulled into each bundle rather than file paths, so shared files with disjoint sub-objects are not miscounted.
- False positives filtered Every candidate is checked before it is reported, and cleared ones are labelled so you can see what was ruled out and why.
- Faster at scale Audits and scans run in the background against the incremental project index — the editor stays usable on large projects, and you can cancel at any time.
- JSON & CSV export Export the full audit for code review, a build-size ticket or a CI artefact, alongside the existing Markdown and CSV cleanup report.
Real Unity editor workflow
See the complete workflow.
Every image below is the tool running on a real project — not a concept interface.
Use the arrow keys, controls or thumbnails to explore all eight stages.
Object-level bundle analysis · new in v1.3
Addressables, audited properly
Know which duplicates are real.
Duplicate-in-bundle warnings are only useful if you can trust them. The audit projects your bundle layout from your explicit entries, compares the objects each bundle actually pulls in, and reports the wasted bytes per asset — separating genuine duplication from files that merely look shared.
DuplicatedReal waste, with bytes
False positiveCleared and explained
Projected bundlesBuilt from your entries
ExportableJSON and CSV
- Shared files with disjoint sub-objects are ruled out instead of flagged
- Filter the report by group, bundle or asset type
- Optional integration — auto-detected by reflection, no hard package dependency
- Addressables entries are excluded from orphan detection automatically
Resolved to the asset · click through to the line
The blind spot, closed
It reads your code, not just your scenes.
Every .cs file under Assets is scanned for string-based loads. Comments
are stripped first and only plain literals are trusted, so a call mentioned in a log
message never becomes a false match.
Resources.Load,LoadAsyncandLoadAllresolved to real assetsShader.Findcalls and Addressables addresses and labels- Case-mismatch lint — paths that work in the editor and fail on case-sensitive platforms
- Incremental index: saving a script re-scans only that file, with no rescan button
- Unresolvable dynamic loads are still listed, so blind spots are visible instead of silent
Warned, backed up, verified — then deleted
Safe by design
Nothing leaves without a way back.
Orphan detection is deliberately conservative, and the confirmation dialog is where the tool argues with you: it names the script and line when code loads the asset, and warns when other assets still reference it.
ZionDependencyGraph_Backups/
Timestamped copies of every asset and its .meta
Verified on disk
The copy is checked before deletion is allowed to proceed
- Orphan detection excludes Resources, StreamingAssets, build scenes, scripts and ProjectSettings references
- Assets loaded by code strings and Addressables entries are never flagged
- Multi-select delete, with one-click restore from any backup
Five tabs, one project index
Everything needed to make the call.
Start in the graph, then move to whichever tab answers the question in front of you — all backed by the same incrementally built index.
Interactive node view
Unity GraphView with pan, zoom, minimap and a layered layout, auto-capped to stay responsive on 15,000+ asset projects.
Find Path
Bidirectional search between any two assets: the shortest chain first, plus alternative routes, every step clickable.
Conservative cleanup
Assets with no inbound references, with every known exclusion applied before anything reaches the list.
Byte-identical detection
SHA-256 verified and size-bucketed for speed, opt-in per session so hashing never runs on startup or entering Play mode.
Biggest assets first
The top 200 by size on disk, for finding oversized textures and models before they reach a build.
Reports that travel
Graphviz DOT export for publication-quality rendering, plus Markdown, CSV and JSON reports for review and CI.
Compatibility & scope
Clear requirements. Honest limits.
Technical requirements
Ready for real projects
- Built for Unity 6 — supported on all Unity 6 versions
- Compatible with URP, HDRP and the Built-in Render Pipeline
- Editor-only — zero runtime cost and no build-size impact
- Addressables integration is optional and auto-detected
- Settings, depth, filters and panel widths persist between sessions
What static analysis cannot see
No false promises
- Loads built from variables, interpolation or concatenation cannot be resolved by any static scan
- Those call sites are still detected and listed, so the gaps are visible
- Procedurally assigned materials and runtime-instantiated assets stay invisible
- The tool surfaces evidence; the delete decision remains yours
Frequently asked questions
The practical details.
Not sure whether it fits your project setup?
Talk directly to the developerDoes it modify my project automatically?
No. It surfaces dependencies, orphans, duplicates and bundle duplication for you to review. You decide what to remove, and every deletion is backed up and verified first.
What does the v1.3 Addressables audit actually check?
It projects your bundle layout from your explicit Addressables entries, then compares the objects each projected bundle pulls in. Assets genuinely present in more than one bundle are reported with the wasted bytes; candidates that only share a file — with disjoint sub-objects — are cleared and labelled as false positives so you can see what was ruled out. The full result exports to JSON or CSV.
Do I need the Addressables package installed?
No. Addressables support is detected by reflection, so there is no hard package dependency. With the package installed you get the audit tab and automatic exclusion of Addressables entries from orphan detection; without it, everything else works unchanged.
How does it detect Resources.Load and Addressables usage in code?
Every .cs file under Assets/ is scanned for string-based load calls — Resources.Load and its variants, Shader.Find, and Addressables keys. Comments are stripped first and only plain string literals are trusted, so a call mentioned in a comment or a log message never produces a false match. Each resolved call is listed with its script and line, and clicking it opens your IDE at that exact line.
Is it safe to delete a flagged orphan?
Orphan detection is deliberately conservative and cross-checks code string references, so assets your scripts load are never flagged. You can open any asset in the graph to confirm its inbound references are empty first. Every safe delete copies the asset and its .meta to a timestamped backup folder and verifies the copy on disk before anything is removed.
Will it freeze the editor on a huge project?
No. The project index builds incrementally in the background and is cancellable at any time, graph rendering is auto-capped to stay responsive on projects with 15,000+ assets, and duplicate hashing runs only when you ask for it.
Can it detect every reference?
Serialized references and literal string loads, yes. Loads built from variables or string interpolation only exist at runtime, so no static tool can resolve them — but those call sites are detected and listed anyway, so you can see exactly where the blind spots are instead of trusting there are none.
Available now — v1.3.0
Stop guessing what breaks.
Interactive graph, code-aware orphan cleanup, object-level Addressables auditing and verified backups — in one editor window.
