Fix Crashes & Stutters After Engine Change

Updated 5 November 2026 · Standard formula, shown below

Switching game engines (like moving from Unity to Unreal, or upgrading to a new engine version) can leave your project with crashes, stuttering, or missing settings. This guide walks you through the most common causes and fixes, from clearing stale caches to reconfiguring project settings. You’ll need access to your project files and the ability to open the engine’s project settings.

What You’ll Need

Access to your project’s root folder (where the project file and Assets/Content folders live).
The new engine version installed and able to open the project.
A backup of your project (always make one before making major changes).
A text editor (like Notepad++ or VS Code) for editing config files if needed.

Step-by-Step

Back up your project first. Copy the entire project folder to a safe location. This is your rollback point if something goes wrong.
Clear the engine cache and intermediate files. Most engines store compiled shaders, asset caches, and other temporary data. Delete the folders named Library (Unity), Intermediate and Saved (Unreal), or build and .gradle (Godot). The engine will rebuild them from scratch on next open, which often fixes missing settings and mysterious crashes.
Open the project with the new engine version. Use the engine’s project launcher or open the project file directly. If prompted to upgrade or convert the project, accept it. This may take a while as the engine reimports assets.
Check the console/error log. After the project loads, look at the engine’s output log (usually in a “Output Log” or “Console” panel). Search for errors like “missing”, “failed to load”, or “incompatible”. These point directly to what’s broken.
Re-apply project settings. Engine upgrades often reset or ignore certain settings. Go to Project Settings (Edit > Project Settings in Unity, Edit > Project Settings in Unreal, Project > Project Settings in Godot). Review key sections:
- Graphics: Render pipeline (e.g., Built-in vs. URP/HDRP), shader model, and color space.
- Audio: Audio device, sample rate, and spatializer plugin.
- Input: Input handling (old vs. new input system) and action mappings.
- Physics: Physics engine (e.g., PhysX vs. Chaos) and collision settings.
Re-enable any features you were using before.
Update or reimport third-party plugins. Plugins and assets compiled for the old engine version may not work. Check each plugin’s documentation for a version compatible with your new engine. Remove or update any that are incompatible, then reimport them.
Fix script references and assemblies. If your code uses APIs that changed, you’ll get compile errors. Open the code editor and check the error list. Update any deprecated function calls to the new API. Use the engine’s migration tools if available (e.g., Unity’s API Updater).
Rebuild lighting and navmesh. If your scenes look dark or AI doesn’t work, lighting and navigation data may be stale. In Unity, go to Window > Rendering > Lighting and click “Generate Lighting”. In Unreal, build lighting from the Build menu. In Godot, bake lightmaps again.
Test with a minimal scene. Create a new, empty scene with just a camera and a light. If it runs fine, the problem is with your specific assets or settings. If it still crashes, the issue is with the engine installation itself.
Reinstall or repair the engine. If a minimal scene still crashes, the engine installation may be corrupted. Use the engine’s installer to repair or reinstall it. Also make sure your graphics drivers are up to date.

Common Mistakes

Skipping the backup. Always back up before changing engines. You can lose hours of work if something goes wrong.
Not clearing caches. Leaving old cache files is one of the most common causes of crashes and missing settings after an upgrade.
Assuming all settings carry over. Engine upgrades often reset settings to defaults. You must manually re-apply them.
Forgetting to update plugins. Plugins are usually the first thing to break. Check for updates before anything else.
Ignoring the error log. The console tells you exactly what’s wrong. Skipping it means guessing.

Tips

Use version control. If you use Git or Perforce, commit a clean state before the upgrade. This makes reverting easy.
Upgrade incrementally. If you’re skipping several engine versions (e.g., 2020 to 2023), upgrade one major version at a time. This isolates issues.
Keep a changelog. Note what settings you change and what fixes worked. This helps if you need to do it again.
Test on a copy. Try the upgrade on a duplicate of your project first. If it works, apply it to the main project.

Troubleshooting

If the steps above don’t resolve the issue:

Project won’t open at all: Check if the project file is corrupted. Try creating a new project in the new engine and manually copying over your Assets/Content and settings files. If that works, the issue is the project file itself.
Crash on startup: Disable all plugins temporarily by moving them out of the project folder. If it opens, re-enable them one by one to find the culprit.
Stuttering persists: Check if shader compilation is happening at runtime. Pre-build shaders for your target platform. Also, check for memory leaks in your codeâ€”use the profiler.
Missing settings: Some settings are stored in files like ProjectSettings.asset (Unity) or DefaultEngine.ini (Unreal). Use a text editor to search for the missing setting and see if it’s still there. If not, add it manually based on the new engine’s documentation.
If all else fails: Search the engine’s official forums or documentation for your specific error message. Chances are someone else has had the same issue.

Frequently Asked Questions

Why did my project settings reset after the upgrade?

Engine upgrades often change the format of settings files. The engine may not recognize old values and reverts to defaults. You’ll need to re-apply your custom settings manually.

Can I downgrade back to the old engine version?

Yes, if you have a backup. But be aware that the project may have been modified by the new engine, so the downgrade might not be clean. Always back up before upgrading.

How long does it take to update a project to a new engine version?

It depends on the project size and how many assets/plugins you use. A small project might take an hour; a large one could take days. Plan accordingly.

Do I need to redo all my lighting?

Usually yes. Lighting data is often incompatible between engine versions. You’ll need to rebuild lighting, but the light placement and settings should remain.

Will my C#/C++ code work without changes?

Not always. APIs change between versions. You’ll likely need to update some function calls and class names. The engine’s compiler will tell you what’s broken.

What’s the best way to avoid these problems in the future?

Stay on a stable engine version for the duration of your project. Only upgrade when necessary, and always test on a branch first. Keep your plugins updated regularly.

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.