Video Summary - I Made The Same Game in Unity and Godot, Which Engine is Better?

Overview

Thomas Grové (game designer) recreated the same simple horror-game prototype in Unity and Godot to compare performance, usability, workflow friction, build/load times, install size, and profiling results. He aimed for an apples-to-apples comparison by starting from his Unity work (already had the character controller, camera transitions, scene transitions, and a custom dither shader) and porting it to Godot.

Key technological comparisons & findings

1) Install size / disk footprint

Unity install size: about 21 GB (Unity Hub + editor)
Godot install size: about 164 MB

Takeaway: Godot is ~129× smaller, which can matter on limited-storage machines.

2) Editor + project startup time

From “nothing” to loading his project:

Godot: ~13.5 seconds
Unity: ~1 minute 20 seconds

Takeaway: Godot starts much faster for initial editor/project load.

3) Gameplay parity / visual matching

He ran both versions simultaneously with one controller controlling both.
He couldn’t reach a perfect one-to-one match (e.g., walk speed tuning differed, character/exit timing mismatched).
Visuals:
- Dither effect and basic lighting/textures looked “fine” in both.
- He preferred Godot’s look slightly, especially corner fading to black applied more liberally in Godot.

4) Camera follow system

Unity approach: Cinema Machine
Godot approach: custom follow camera

Takeaway: Though he was hesitant to roll his own, he preferred his Godot solution for controllability/simplicity.

5) Workflow / architecture differences

Overall he spent about similar time on both, but:

Even though Godot might feel like it should be faster after doing Unity first, he had less motivation to redo work.
Learning Godot nuances was sometimes frustrating for someone experienced with Unity.

Example friction points:

Rigged characters / animation requirements
- Unity: can work with T-pose or A-pose; root motion optional
- Godot: prefers T-pose
  - For non-root-motion, root motion should be disabled, which may require re-export or conversion steps (e.g., Mixamo versions without root motion, Blender edits, or a plugin)
- Unity FBX workflow is simpler; Godot requires extra steps to save/map animations into resources/animation libraries.

6) Rendering pipeline maturity & custom shader needs

He felt Unity URP is more mature than Godot’s pipeline for his requirements.
Shader requirement:
- He needed a dither effect applied after transparency, not before.
- In Unity, he created a custom compositor/HLSL shader to place the effect correctly.
He believes this may reduce performance a bit (later reflected in metrics).

7) Editor UX “gotchas”

Editor behaviors can hide properties until you expand them (example: clicking to reveal material properties).
Some workflows require material variants/instances so edits don’t apply globally.

8) Script/shader compile times (Unity pain point)

Unity compile time for a major script (character controller) after changes:

Godot: ~0.5 seconds
Unity: ~15.5 seconds

Takeaway: Unity compilation was ~31× slower in this test, contradicting his past experience with Unity’s “instant” iteration.

9) Export / build size and build times

Unity seemed to export “optimized” assets by default; Godot can do similar but is not on by default.
First Godot export produced a larger file because source assets were included.
- He fixed this by reorganizing assets and excluding source folders/resources during export.

Build time to PC (first build):

Unity: ~15 minutes
Godot: ~2–2.5 seconds

Second Unity export:

~52–53 seconds (still far slower than Godot, but improved vs first run)

10) Game launch time from builds

After exporting, load times:

Godot: ~2 seconds + frames
Unity: ~10.5 seconds

Takeaway: ~5× faster launch for Godot in his test.

Performance / FPS & profiling results

FPS target and VSync

Intended target: 60 FPS
He disabled VSync to measure “headroom.”

Initial profiling confusion (Godot shows different profilers)

Godot “appeared” to run at ~950 FPS while Unity was ~200–300 FPS.
Cause: Godot has two profilers (logic/physics vs rendering).
He initially looked at the wrong one; after correcting, the rendering comparison became more meaningful.

Frame rate (final export, barebones room)

Unity final export: ~650 to ~730 FPS
Godot final export: similar range in the corrected measurement
He notes results were close, except for one case.

GPU vs CPU utilization

Godot: ~95% GPU, ~8% CPU → more GPU-bound
Unity: ~76% GPU, ~29% CPU → more CPU overhead

Lighting change test in Godot

He changed global illumination from Voxel GI to Lightmap GI and adjusted resolution.
Result: Godot FPS increased to about 630 FPS.

System load restart test (reducing background interference)

He restarted and reran both without background apps (Godot/Unity/DaVinci Resolve/OBS):

Godot: ~1050 FPS
Unity: ~850 FPS
He notes results are somewhat inconclusive due to test conditions.

Overall conclusion

Based on his collected metrics, Godot beat Unity on every metric except the final output FPS, and even there the FPS results were pretty close.
Both engines exceeded his practical needs by a large margin (he reported ~600 FPS headroom), so performance was not the deciding factor.
He expects to continue with Godot due to:
- faster iteration/build/load
- more tailored/custom feel
- generally strong performance

Mentions of guides/tutorial-style points

Editor/property visibility gotcha: properties can be hidden until you click/expand them (relevant when following tutorials).
Godot export gotcha: you must configure resource inclusion/exclusion manually to avoid packaging unnecessary source assets (Unity-like behavior isn’t automatic by default).
Godot animation pipeline gotcha: pose/root-motion expectations and extra steps/resources mapping.

Main speakers / sources

Thomas Grové (primary speaker; game designer conducting the Unity vs Godot test)

I Made The Same Game in Unity and Godot, Which Engine is Better?

Key takeaways