What breaks when a Unity game moves to Godot
Scenes, prefabs, sprites, tilemaps and physics settings convert mechanically; the C# does not, and four of Unity's UI components turn out to be unnecessary in Godot. Measured on two MIT-licensed Unity projects in November 2026.
AppImage, x86_64. Ubuntu 22.04, Debian 12, Fedora 39 or newer.
Intel or AMD Chromebook, with Linux turned on.
Twenty-nine things crossed before anyone wrote a line
Artifact is a small top-down game from Ludum Dare 46, whose theme was "Keep It Alive". You harvest berries from bushes, carry them back to a stone artifact that loses health every second, and slash at the wolves that come for the bushes. Its developer, Augusto Micheli Debard, published the Unity 2019.4 project under the MIT licence, which makes it a good test: small enough to finish, real enough to have a menu, a HUD, two languages, enemies and a win and lose screen.
We imported it into a new Godot 4.7.2 project with Flockbay's Import from Unity, which reads Unity's files without Unity installed. Before any code was touched, 29 parts of the game were already Godot: its 6 scenes, its 4 prefabs, its 3 tilemaps with their tile sets, its sprites with their sorting, and 9 project settings, from the physics layers to the input axes. The level loaded, drew, and had a player standing in a field of berry bushes. It did nothing else.
The engines disagree about what a game is, but mostly in a mechanical way
The usual explanation for why there is no Unity to Godot converter is that the two engines disagree about what a game is made of. In Unity a GameObject is an empty container and behaviour comes from components bolted onto it. In Godot a node is one thing with a type. A converter would have to decide, for every GameObject, which node it really is, and that sounds like design.
Most of the time it is not. A GameObject with a SpriteRenderer and a Rigidbody2D whose velocity the code sets is a CharacterBody2D with a Sprite2D under it. A Tilemap is a TileMapLayer. A trigger collider is an Area2D. A prefab is a scene, and a prefab instance with overridden values is an instanced scene with those properties set. These are rules, and rules can be applied to every object in a project at once.
Where the disagreement is real is the code. A MonoBehaviour calls GetComponent, starts coroutines and reads Input.GetAxis, and none of those exist in Godot. Every line has to be rewritten against another API, which is the part a rule cannot do and an AI can, given the Unity source and the converted scene side by side.
The Inspector is the save file that matters
The values a designer tunes live in the scene, not the script. Artifact's stone loses 2 health a second from a maximum of 120, and its wolves and bushes carry numbers of their own. All of that is serialized in the Unity scene next to each component, and a port that starts from the script's defaults gets a different game.
So the import keeps every component it cannot convert as a placeholder node named after its Unity class, holding every Inspector value. When the C# was ported, the new GDScript took its numbers from those placeholders: the stone came across at 120 and 2.
Four of Unity's components had nothing to do
Artifact left 41 items for the AI after the import: 27 scripts, 6 pieces of uGUI, 2 particle systems and 6 other components. Claude Code, connected to Flockbay over MCP, worked through the list and ported 37 of them, rewriting the scripts in GDScript and rebuilding the four menu screens and the HUD as Control nodes from Unity's RectTransform data, with the game's own pixel font.
The other 4 were skipped, each with a reason: the CanvasScaler, the EventSystem, the input module and the raycaster. Unity needs those to route a click to a button. Godot's Control nodes take their own input and hit-test themselves, and scaling is a project setting. A port that faithfully recreated them would have built machinery the engine already has.
The ported game boots with no script errors, and its level runs headless with none either. The language buttons switch the strings between Spanish and English, the berries add to the backpack, and the wolves die on the third slash.
What still breaks is what you feel, not what you see
A clean run is not the same game, and the port was not compared with the original. The differences that survive a port are the ones a player feels. Unity's input axes ease in and out, so a character accelerates over a few frames; a Godot action is on or off unless the code says otherwise, and Artifact's player now starts and stops at once. Its dust particles were rebuilt from their settings, which describe the effect without reproducing it.
In 3D there is more of this. Unity uses PhysX and Godot its own physics, so mass, drag and friction settle differently, and a jump tuned by feel needs tuning again. Shader Graph has no Godot equivalent, so a stylised material is rewritten in Godot's shading language. UI built with anchors converts by arithmetic, but a layout that leaned on Unity's layout groups can land a few pixels off: Artifact's "Backpack:" label ended up against the right edge of the screen.
None of that is found by a headless check. It is found by playing the two builds one after the other and saying what feels different.
A larger game moves the same way, with a longer list
Infinity Square/Space, an MIT-licensed 3D space prototype by #NVJOB with 122 scripts, imported the same way. 81 items converted, 74 of them prefabs, and 69 were left to port: 59 scripts, 3 pieces of UI, 2 particle systems and 5 other components. Its menu scene came in empty, because its starfield is generated by a script, and its game scene came in as a single ship in empty space for the same reason. In a procedural game the content is the code, and the list to port is most of the game.
That is the honest shape of a move from Unity: the content crosses on its own, the code is ported one item at a time, and the feel is checked by hand.
The projects: Artifact on GitHub (MIT), Infinity Square/Space on GitHub (MIT), Unidot Importer (MIT).
Two Unity projects, imported into Godot 4.7.2
| Artifact (2D) | Infinity Square/Space (3D) | |
|---|---|---|
| Converted on import | 29 | 81 |
| Approximated | 3 (mouse axes) | 3 (settings) |
| Left to port | 41 | 69 |
| Ported by the AI | 37 | not run |
| Skipped, with a reason | 4 (uGUI plumbing) | 14 (editor and test code) |
Counted from each project's port manifest on 8 November 2026. Only Artifact was ported to the end.
From the filmed games



Questions
- Can a Unity project be converted to Godot automatically?
- The content can: scenes, prefabs, models, sprites, tilemaps, physics and input settings convert by rule. The C# cannot, because Unity's API is not Godot's, so each script is ported, by hand or by an AI working from the Unity source and the converted scene.
- Do my Inspector values survive?
- With Import from Unity they do: every component that is not converted stays as a placeholder node with its serialized values, and the ported script reads them from there.
- Will the ported game feel the same?
- Not automatically. Physics, input easing and particle effects are where a port drifts, so play both builds and tune what feels different.
Import your Unity project into Godot 4 and port it with the AI, on Windows, macOS or Linux.
Download Flockbay freeAppImage, x86_64. Ubuntu 22.04, Debian 12, Fedora 39 or newer.
Intel or AMD Chromebook, with Linux turned on.
