Free low poly assets for Godot: where to get them and how to get them in

Most low poly packs aren't made with Godot in mind. The big free sources ship for Unity first, so a Godot project means a series of small conversions, and this guide covers all of them. It goes through which formats Godot reads and which to ask for, every free source worth knowing and what its license lets you do, the import step by step, keeping the shading flat and the colors right, adding a collider, and putting a forest down without a thousand nodes. The articles under this one compare the packs and put a forest down with MultiMesh. The import itself, setting by setting, is in the Godot OBJ article, and levels of detail in Godot covers keeping the far trees cheap.

• Free low poly asset packs comparedThe free sources of low poly 3D models compared on license, formats, style and size, with what each one is best for. The paid packs are included for context, along with where a builder fits beside them.
• A forest in Godot 4 with MultiMeshInstance3DHow to put thousands of low poly trees in a Godot 4 scene in one draw call with MultiMeshInstance3D. It covers populating it from code with varied transforms and colors, giving the far trees levels of detail, and where the scatter add-ons take over.

Formats Godot likes

• GLB or glTF is Godot's native format. Materials, scenes, node hierarchy and animation all come across, and nothing needs converting. Take it whenever it's offered.
• OBJ imports directly as a mesh resource, with materials from the .mtl beside it. It's fine for static props, but it carries no hierarchy or animation.
• FBX imports in Godot 4.3 and later through the built-in ufbx importer. Before 4.3 it needed the FBX2glTF tool, which the editor prompts for. If a pack has GLB as well, take that.
• Blend files import if Blender is installed and the editor knows where it is. That's convenient, but it ties the project to that machine.
• DAE (Collada) still imports, and a few older packs ship it. It works, but GLB is better.

Where the free packs are

CC0 means no conditions at all. You can use the model, modify it and sell a game with it, and you don't need to credit anyone. CC BY needs a credit somewhere, and a line in the game's credits is enough. Read the license on anything from a marketplace, because "free" there often means free for personal use.

The problem every pack shares is that its tree is the same tree in every game that uses it. The other route is to build the model to the size and shape you want. PolyMason's tree builder does that in the browser, for free. It has twenty-four species and exports OBJ, with GLB next. The packs compared article goes through the sources one by one.

Importing an OBJ

Drop the .obj, its .mtl and any texture into the project folder together. Godot imports the OBJ as a mesh resource. Add a MeshInstance3D to the scene and set its Mesh property to the imported file, or drag the file from the FileSystem dock into the 3D viewport. The materials from the .mtl come with it, one surface per material.

If you'd rather have a scene with a node per object than one mesh, select the file, open the Import dock, change Import As to a scene, and Reimport.

Scale. Godot's unit is the meter, so a file made in meters comes in at the right size. A model that arrives tiny was made in centimeters, or exported from a tool that scaled it. Fix it once with the scale setting in the Import dock and reimport. Don't scale the node instead, because a scaled node scales its collider and its children too.

GLB is the same drag and drop, and it arrives as a scene. To edit it, right-click it in the FileSystem dock and choose New Inherited Scene. Otherwise you can instance it into your scene as it is.

Keeping it flat

Godot uses the normals in the file and generates smooth ones only when there are none. A model exported with flat normals shades flat with nothing to set, and there's no smoothing angle in Godot to adjust. If a pack's model comes in smooth, you have to fix it in the tool it came from. Shade it flat there and re-export, or use the GLB from the same pack, which usually carries the intended normals.

For the colors, low poly packs use one small texture with a square per color, and so does PolyMason. The OBJ, its .mtl and the PolyMason palette PNG go into the project together, and Godot makes one StandardMaterial3D with the palette as its albedo texture. The palette is the same file for every model from here, so a scene of them shares that one material. Two settings on that material help the flat look under Godot's default lighting. Turn Specular down, under Metallic, and set the texture's filter to Nearest in the material's Sampling section if you want hard-edged blocks. Repainting a block in the PNG recolors every face that points at it.

Some packs use a material per color instead. A model like that gives you a StandardMaterial3D per surface, each editable in the inspector, and it costs a draw call per material.

Adding a collider

A MeshInstance3D has no collision. With the node selected, the Mesh menu in the 3D viewport's toolbar has Create Trimesh Collision Sibling for exact collision on static props, and Create Single Convex Collision Sibling for a cheaper hull. Neither is what you want for a tree. Make a StaticBody3D, and give it two children, the mesh and a CollisionShape3D with a cylinder or capsule shape the size of the trunk. The player can then walk under the canopy and bump into the trunk, which is how trees behave in games. Rocks and buildings take a trimesh or a box.

Putting many of them down

A forest of separate MeshInstance3D nodes works, up to a point. A MultiMeshInstance3D draws thousands of copies of one mesh in one draw call, with a transform and optionally a color per instance, and if you split the forest into chunks, Godot's automatic mesh LOD drops the far chunks to a cheaper level. Godot's scattering add-ons build on it. For a small hand-placed scene, duplicating nodes is still fine. The forest article populates a MultiMesh from code and with the editor's Populate Surface tool, and points to the scatter add-ons.

The things that go wrong

• Gray model. The .mtl or the texture wasn't beside the .obj when it imported. Put them together and Reimport.
• Tiny or huge model. It's the units. See Scale above.
• Model on its side. It was exported Z-up from Blender with the wrong Forward and Up settings. Re-export with -Z forward, Y up.
• Smooth where it should be flat. There are no normals in the file. Re-export flat, or take the GLB.
• Dark underside on leaves. The material is single-sided and the leaf planes are seen from behind. Set Cull Mode to Disabled on that material, or use a closed foliage mesh.

The other guides

• Flat shading in Unity for low poly modelsWhy a low poly model goes smooth when it lands in Unity, what the importer's Normals and Smoothing Angle settings do, the three places you can fix it, and how to keep the colors flat as well. Three articles underneath go into the detail.
• The OBJ file format, explained for game enginesWhat's in an OBJ file and its MTL, what it leaves out (units, axes, colors), how it compares with FBX, GLB and STL, and how to import one into Unity, Godot and Unreal so the model doesn't arrive tiny, sideways or gray.
• LODs and billboards for low poly modelsHow levels of detail work, what triangle counts are reasonable for low poly trees, rocks, buildings and characters, how to make the levels so the swap doesn't pop, billboards and impostors for the far distance, and the LOD setup in Unity, Godot and Unreal.
• How to make low poly trees for gamesThe method behind a low poly tree that looks like its species: the silhouette that identifies it, the trunk, where the boughs leave and how the trunk divides, foliage as a few closed meshes, two greens, triangle budgets, and the export a game engine wants. The same steps work in the builder and by hand in Blender.

Or build a tree and see what comes out.