Start Building

When Unity’s Package Manager gets into a bad state, it can feel like your entire project is cursed:

  • Red error icons and “Incompatible” labels on core packages.
  • Endless “Resolving packages…” at the bottom of the editor.
  • Console warnings about missing dependencies or package cycles.

The good news: most dependency problems come from a small set of causes—corrupted cache, bad manifest.json, version mismatches, or network issues—and you can usually fix them without rebuilding your project from scratch.

This guide walks through a safe, step‑by‑step checklist to get the Package Manager healthy again.

1. Confirm It’s Really a Package Dependency Problem

First, double‑check that the issue is with packages, not something else.

Common dependency symptoms:

  • In Window → Package Manager:
    • Packages show red error icons.
    • Status lines like “Could not find dependency [email protected]”.
  • In the Console:
    • Messages about missing or incompatible dependencies.
    • Errors referencing PackageManager or manifest.json.

If you only see:

  • C# compilation errors in your own scripts, or
  • Shader errors, or
  • Ordinary runtime exceptions,

…fix those first; this guide is specifically for Unity Package Manager dependency issues.

2. Back Up Your Project and manifest.json

Before you touch any configuration files, create a backup:

  1. Close Unity.
  2. In your project folder, copy:
    • The entire project directory to a backup location, or
    • At minimum, the Packages/manifest.json file.

If something goes wrong, you can always revert.

3. Clear the Package Cache and Restart Unity

Many dependency issues come from a corrupted package cache or stale downloads.

3.1. Close Unity and Unity Hub completely

  • Quit the Unity Editor.
  • Quit Unity Hub from the system tray/menu bar.

3.2. Clear the global package cache

On your machine, locate Unity’s package cache (paths vary by OS and version; check Unity docs if needed) and:

  • Delete the cache folder contents only, not your actual project files.

Then:

  1. Re‑open Unity Hub.
  2. Open your project again.

Unity will re‑download packages as needed.

Check:

  • Does the “Resolving packages…” message finish normally?
  • Do red dependency errors in Package Manager disappear?

If yes, your issue was likely cache‑related. If not, continue.

4. Check Packages/manifest.json for Obvious Problems

The manifest.json file lists all packages and versions for your project. A single bad entry can break dependency resolution.

Open Packages/manifest.json in a text editor and look for:

  • Duplicate entries for the same package.
  • Typos in package names (for example com.unity.textmespro vs com.unity.textmeshpro).
  • Pinned versions that no longer exist in the registry.

Example of a healthy snippet:

{
  "dependencies": {
    "com.unity.collab-proxy": "2.0.3",
    "com.unity.textmeshpro": "3.0.6",
    "com.unity.inputsystem": "1.7.0",
    "com.unity.modules.audio": "1.0.0"
  }
}

4.1. Remove obviously broken or unused packages

If you see a package you don’t use and it’s causing a dependency error:

  1. Remove its line from dependencies.
  2. Save manifest.json.
  3. Reopen the project and let Unity re‑resolve packages.

If you’re unsure whether a package is safe to remove, comment it in your notes and skip it for now—don’t guess.

5. Reset Suspicious Package Versions to Verified Defaults

If someone manually pinned unusual versions (for example bleeding‑edge previews), you can get stuck with:

  • Unmet dependency ranges.
  • Incompatible combinations of core packages.

5.1. Check in Package Manager

In Unity:

  1. Open Window → Package Manager.
  2. For each problematic package:
    • Look at the “See other versions” or version dropdown.
    • Note which version Unity flags as Verified for your editor version.

5.2. Reset in manifest.json (if needed)

If your manifest pins a package to a version that’s clearly outside the verified list:

  1. Change it to the verified version.
  2. Save and reopen the project.

Do this especially for:

  • Core modules (com.unity.collections, com.unity.inputsystem, etc.).
  • Rendering pipelines (URP/HDRP).

Getting back to a supported version matrix often resolves nasty dependency tangles.

6. Temporarily Disable Custom or Local Package Sources

If you’re using:

  • Custom registries (npm‑style URLs).
  • Local packages linked via "file:" or "git:" references.

…a broken or unreachable source can block dependency resolution.

In manifest.json, look at:

  • The "scopedRegistries" section.
  • Any dependencies with:
    • "file:../SomeLocalPackage"
    • "git+https://..." or similar.

For debugging:

  1. Comment out or remove suspicious custom dependencies temporarily.
  2. Comment out extra custom registries, leaving Unity’s official registry intact.
  3. Reopen the project and see if Package Manager recovers.

If it does:

  • Re‑add custom sources one at a time until you find the culprit.

7. Fix Dependency Loops and Nested Requirements

Sometimes packages depend on each other in a way Unity can’t satisfy—especially when mixing preview packages or old manifests.

In the Console:

  • Look for error messages mentioning:
    • “Dependency loop”
    • “Cyclic dependency”
    • “Cannot satisfy dependency XXX for package YYY”

Strategies:

  1. Identify the lowest‑level package in the chain (often a foundational library).
  2. Set that package to:
    • The editor’s verified version, or
    • A version explicitly recommended by Unity docs for your editor version.
  3. Remove optional add‑ons that sit on top of it if they’re not critical.

If you inherited a very old manifest.json from a previous major Unity version, consider:

  • Creating a fresh blank project in the same Unity version.
  • Comparing its manifest.json to yours.
  • Bringing your project closer to the new default and adding only the packages you truly need.

8. Check Network and Registry Access (When Errors Look Random)

If dependencies are “sometimes” broken or only on certain machines:

  • Check that you can reach Unity’s package registry:
    • Corporate proxies and firewalls often block package URLs.
    • VPNs can break or fix access depending on configuration.
  • Make sure:
    • System time is correct (SSL can fail with bad clocks).
    • You’re not offline or on a flaky Wi‑Fi link.

Try:

  • Switching networks.
  • Temporarily disabling strict proxies or VPNs (if allowed).

If the problem disappears, you’ll need:

  • Proxy exceptions or registry URLs whitelisted by your IT/network admin.

9. Verification Checklist – Is Package Manager Healthy Again?

After each fix, run through a short checklist:

  • [ ] Project opens without hanging on “Resolving packages…”.
  • [ ] Window → Package Manager loads without throwing errors.
  • [ ] Packages that were red now appear normal or “In Project”.
  • [ ] You can:
    • Add a small, official package (for example TextMeshPro).
    • Remove it again.
  • [ ] Console no longer shows dependency resolution errors from Package Manager.

If all of that passes, you’re generally safe to resume normal development.

When to Consider a Fresh Project or Support Ticket

If, after all of the above:

  • The editor still hangs on package resolution, and
  • Your manifest.json looks sane compared to a fresh project in the same Unity version,

you may be dealing with:

  • A deeper editor bug specific to your Unity version.
  • Rare platform‑specific issues.

At that point:

  • Test with a brand‑new project:
    • If it has the same issues, file a bug with Unity and stick to a stable version.
  • If only this project is cursed:
    • Consider migrating your Assets/ and ProjectSettings/ into a clean project and rebuilding the manifest slowly.

Summary – Fixing Broken Unity Package Dependencies

Most Unity Package Manager dependency problems come down to:

  • Corrupted caches.
  • Bad or outdated manifest.json entries.
  • Version mismatches or broken custom registries.

By:

  • Clearing caches,
  • Resetting to verified package versions,
  • Temporarily disabling custom sources, and
  • Carefully editing manifest.json,

…you can usually get the Package Manager back to a stable state without rebuilding your whole project.

Bookmark this guide so the next time Unity starts complaining about dependencies, you can walk through the checklist instead of panicking.

title: Unity Package Manager Dependencies Broken - Dependency Resolution Fix category: Asset & Resource Problems description: Fix Unity Package Manager dependency errors when packages fail to resolve, show "X depends on Y which could not be found", or stay in a red error state. canonical: https://gamineai.com/help/unity-package-manager-dependencies-broken-dependency-resolution-fix og_title: Unity Package Manager Dependencies Broken - Dependency Resolution Fix og_description: Step-by-step guide to fix Unity Package Manager dependency errors, missing packages, and stuck installs in 2026 projects. og_image: https://gamineai.com/assets/img/help-og.jpg og_type: article twitter_card: summary_large_image status: published date: 2026-03-16 tags: [Unity, Package Manager, Dependencies, Asset Management, Troubleshooting]

Problem: Unity Package Manager Dependencies Are Broken

You open Unity Package Manager and see red errors like:

  • Package X has invalid dependencies or related test packages.
  • Package X depends on Y but Y could not be found.
  • Packages stuck in "Resolving" or "Error" states after an update.

This usually happens after:

  • Upgrading Unity to a new 2026.x version.
  • Pulling changes from version control with a different package set.
  • Manually editing manifest.json or packages-lock.json.

The good news: you can usually fix this without nuking your entire project if you reset the right files and sources.

Root Causes (Why This Happens)

Common reasons Unity Package Manager dependencies break:

  • Incompatible package versions after a Unity upgrade.
  • Stale or corrupted packages-lock.json after switching branches.
  • Custom registries or scoped registries (like npm-style feeds) that are temporarily unreachable.
  • Manually added package entries with typos or missing versions in manifest.json.

The fix is to:

  1. Verify your Unity version and supported package ranges.
  2. Clean up or regenerate manifest and lock files safely.
  3. Reset package sources and caches so Unity can fetch correct versions.

Step-by-Step Fix 1: Check Your Unity Version and Package Compatibility

  1. In Unity, go to Help → About (or equivalent on your OS) and note the exact version (for example 2026.3.1f1).
  2. Open the Package Manager (Window → Package Manager) and:
    • Switch the Packages dropdown to Unity Registry.
    • Select a failing package and check the Version dropdown.
  3. If you see a warning like “This version is not verified for your Unity version”:
    • Switch to the latest verified version for your Unity release.

This alone often fixes dependency mismatches introduced by manually forcing newer package versions.

Step-by-Step Fix 2: Safely Reset packages-lock.json

Unity tracks exact package versions and resolutions in Packages/packages-lock.json. If this becomes out of sync:

  1. Close Unity completely.
  2. In your project folder, go to the Packages directory.
  3. Backup packages-lock.json (copy it somewhere safe).
  4. Delete the original packages-lock.json.
  5. Reopen the project in Unity.

Unity will regenerate packages-lock.json based on manifest.json and the current registries.
Reopen Package Manager and see if the dependency errors disappear.

Step-by-Step Fix 3: Validate manifest.json Entries

Broken or inconsistent entries in manifest.json can cause the entire dependency graph to fail.

  1. Still in the Packages folder, open manifest.json in a text editor.
  2. Check for:
    • Packages you no longer use or recognize.
    • Obvious typos in package names (for example com.unity.postporcessing).
    • Manually pinned versions that are far outside what Unity lists as verified.
  3. For each suspicious entry:
    • Compare the name and version to what Unity lists in the Package Manager under Unity Registry.
    • If you are unsure, comment the line out (in a backup copy) and temporarily remove it from the live manifest.json to see if Unity loads without that package.

After editing, save manifest.json, reopen Unity, and let it re-resolve packages.

Step-by-Step Fix 4: Reset Scoped Registries and Network Issues

If your project uses scoped registries (for example private npm feeds or Unity Gaming Services packages), missing or unreachable sources will break dependencies.

  1. In manifest.json, look for a scopedRegistries section.
  2. Confirm:
    • URLs are correct (no trailing slashes typos).
    • You have network access and any required VPN or proxy is active.
  3. Temporarily comment out or remove problematic registries to see if Unity resolves the built-in packages correctly.
  4. If you are behind a corporate proxy, make sure Unity is allowed to reach:
    • packages.unity.com
    • Any custom registry URLs your team uses.

Once connectivity is restored, re-open Package Manager and watch for the errors to clear.

Step-by-Step Fix 5: Clear the Local Package Cache

Corrupted or half-downloaded packages in the local cache can keep causing errors even after fixes.

  1. Close Unity.
  2. Locate the Unity package cache for your OS (for example in your Unity Hub or Editor cache folders).
  3. Clear or rename the cache directory related to the problematic packages.
  4. Reopen Unity; it will redownload fresh copies from the registry.

Check Package Manager again to verify that dependency resolution now completes.

Verification: Confirm the Fix Worked

Use this quick checklist:

  • Package Manager opens without hanging on “Resolving packages”.
  • Previously broken packages no longer show red dependency error badges.
  • The Console is free of Cannot perform upm operation or Cannot find dependency messages on startup.
  • You can successfully add a new package from the Unity Registry and remove one without errors.

If all of these are true, your dependency graph is healthy again.

Alternative Fixes for Edge Cases

If you still see errors:

  • Try opening the project in a slightly newer Unity patch within the same major/minor version (for example 2026.3.2f1 instead of 2026.3.0f1).
  • Ask a teammate with a working copy of the project to:
    • Commit their manifest.json and packages-lock.json.
    • Pull those into your clone so you have a known-good package state.
  • For projects using Git submodules or external dependencies, ensure those submodules are initialized and updated before opening Unity.

Prevention Tips (Avoid This Next Time)

  • Avoid editing manifest.json by hand unless you know exactly what you are changing.
  • When upgrading Unity, let the Package Manager suggest compatible versions instead of pinning arbitrary package numbers.
  • Commit Packages/manifest.json and Packages/packages-lock.json together so your team keeps a consistent package snapshot.
  • Document any custom registries your project uses and how to access them (credentials, VPN, proxy settings).

Related Help Articles

  • Unity Package Manager Hangs/Stuck Loading - How to Fix
  • Unity Addressables 2.0 Not Loading - Asset Management System Fix
  • Unity Asset Database Refresh Hangs - Project Indexing Fix
  • Unity Build Fails with "Missing Dependencies" Error - Package Resolution Fix

Bookmark this article so you have a clear recipe the next time Unity’s Package Manager dependencies break after an upgrade or branch switch. If this helped, share it with your team so everyone can recover faster.