Free tile sets for Godot 4 and Tiled, drawn from a terrain description

Four free sets to download

All four are 16 × 16 pixel tiles. Each zip holds the folder Pixelbolt's render command writes: the tile sheet (.png), the Godot 4 TileSet (.tileset.tres), the Tiled tileset (.tsx), a TexturePacker-style atlas (.atlas.json, with each tile's weight, and its collision where the set has it), one PNG per tile, the editable recipe, a preview page and a README; plus the description it was made from (.autotile.json) and the licence (MIT). The tiles are transparent outside the terrain: put a ground layer or a background colour under them. The background colours of the snow, meadow and ground test maps are only previews.

Make your own in two commands

1. Write the description. Here is the whole snow set (snow.autotile.json):

   {
     "format": "pixelforge-autotile",
     "version": 1,
     "name": "snow",
     "tile": 16,
     "palette": {
       "k": "#1b2433", "b": "#6f87a8", "S": "#a9bfd6", "s": "#d3e1ee", "w": "#f4f8fc",
       "i": "#bfe6f7", "r": "#4a4f5c", "R": "#7b8090", "u": "#4f4038", "c": "#0e162659"
     },
     "symbols": {
       "rock": [".rr.", "rRRr", ".rr."],
       "twig": ["r..", ".r.", ".rr"]
     },
     "terrain": {
       "seed": 6,
       "fill": {
         "color": "s",
         "speckle": [
           { "color": "w", "amount": 0.24, "size": 5 },
           { "color": "S", "amount": 0.12, "size": 4 },
           { "color": "i", "amount": 0.03, "size": 2 }
         ]
       },
       "edges": {
         "all": { "depth": 2, "jitter": 1, "size": 6, "bands": ["k", "S"] },
         "n": { "bands": ["k", "w"] },
         "s": { "depth": 3, "bands": ["k", "b"], "outside": ["c"] }
       },
       "round": 2,
       "inner": 1
     },
     "frame": "snow-{mask}-{variant}",
     "variants": [
       { "name": "a", "weight": 4 },
       { "name": "b", "weight": 4, "terrain": { "fill": { "seed": 11 } } },
       { "name": "c", "weight": 4, "terrain": { "fill": { "seed": 23 } } },
       { "name": "rocks", "weight": 1, "terrain": { "fill": { "seed": 37 } },
         "ops": [
           { "op": "stamp", "symbol": "rock", "x": 10, "y": 27 },
           { "op": "stamp", "symbol": "twig", "x": 19, "y": 35 }
         ] }
     ],
     "preview": { "background": "u" },
     "sheet": { "columns": 16 }
   }

   • palette names each colour with one character; c has an alpha byte (59), so the shadow is see-through.
   • fill is the inside of the terrain: a base colour and seeded speckle layers, each covering its amount of the tile in clumps about size pixels across.
   • edges describes each side (n, e, s, w, or all): depth is the margin between the tile border and the terrain, jitter lets the edge wander, bands colour it from the edge inward (an outline, then a highlight), and outside colours the margin beyond that edge (here, the shadow under the bottom edge). Grass sets add tufts.
   • round and inner round the outer and inner corners. variants redraw the fill with another seed or stamp details on it, and weight sets how often each turns up.
   Pixelbolt's art workflow notes list every field, including "mode": "cardinal" (16 tiles, sides only), "mode": "corner" (16 tiles for a dual grid), layers for transitions between two and four terrains, slopes and collision. This guide tested the 47-tile mode and a three-terrain set only.
2. Run two commands with Node.js 20 or newer, in the folder holding the description:

   npx -y pixelbolt@0.13.0 autotile snow.autotile.json --out snow.recipe.json --preview snow-test-map.png
   npx -y pixelbolt@0.13.0 render snow.recipe.json --out snow

   autotile draws the set into an editable recipe and the test map into snow-test-map.png. render writes a new folder snow/ with snow.png, snow.tileset.tres, snow.tsx, snow.atlas.json, the editable recipe snow.pixel.json, one PNG per tile in frames/, a README and a preview page. Neither command overwrites its earlier output: after editing the description, add --force to both. Both commands together took about 0.6 seconds for each of the four sets on our PC (a Ryzen 9 7950X3D, Node.js 24.19.0), once npx had the package.
3. Look at the test map for stray pixels and repetition. A terrain's own edges can't seam, so the compiler checks the joins that stamps and variants change and names pixels that break an outline with a Seam warning: there were none in the four sets.

Have your own drawing instead? Pixelbolt also builds a set from a small template you write as rows of characters, one per pixel (same notes; not tested for this guide). AI agents can do all of this through Pixelbolt's MCP server (pixel_compile, then pixel_render); see the README.

Use it in Godot 4

These steps use the TileMapLayer node, which needs Godot 4.3 or newer; we tested 4.7.2.

1. Copy snow.png and snow.tileset.tres into one folder of your project. The TileSet finds the sheet by its file name, so keep the two together (move them in Godot's FileSystem dock, which updates the path).
2. Add a TileMapLayer node and set its Tile Set to snow.tileset.tres. Set its Texture Filter to Nearest (or make Nearest the project's default texture filter) so the pixels stay sharp.
3. In the TileMap panel, open the Terrains tab, pick the terrain snow and paint. Godot picks each cell's tile from its neighbours, and between a shape's four variants at random, by each tile's probability (the rock variant has 0.25).

Or paint from code, as our test did:

var cells: Array[Vector2i] = [Vector2i(0, 0), Vector2i(1, 0), Vector2i(2, 0)]
$Ground.tile_set = preload("res://tiles/snow.tileset.tres")
$Ground.set_cells_terrain_connect(cells, 0, 0) # terrain set 0, terrain 0 (snow)

• Collision. The ground set's TileSet has a physics layer with a polygon on every tile, set under the drawn grass rather than the tufts (we checked the polygons against the atlas; we didn't simulate a body). For the 45° slopes, give your CharacterBody2D a Floor Max Angle a little above 45°, as Pixelbolt's notes advise. Godot's terrain painter doesn't place slopes: paint the terrain, then place each slope tile, and the tile under its low end, by hand, as the test map's hills show.
• Transitions (shore). The shore's three terrains are one terrain set: water is terrain 0, sand 1 and grass 2. Paint bottom-up: water over the whole area, then sand over the sand cells and the grass cells, then grass over the grass cells, as our test did:

  # all_cells, sand_and_grass_cells and grass_cells: each an Array[Vector2i], like cells above
  $Shore.set_cells_terrain_connect(all_cells, 0, 0)            # water
  $Shore.set_cells_terrain_connect(sand_and_grass_cells, 0, 1) # sand
  $Shore.set_cells_terrain_connect(grass_cells, 0, 2)          # grass

  Godot puts each terrain on the points where four cells painted with it meet, so a terrain ends half a cell inside the cells you paint: 3 × 3 grass cells show 2 × 2 cells of grass, centred on them, and a single cell or a one-cell-wide strip shows none. Paint one row and one column more than the shape you want. Our check compared Godot with Pixelbolt's map of those points, which it matched in every cell; it is not the figure above, which Tiled paints as shown. Painting sand only on the sand cells would leave water between the sand and the grass. The three blob sets have no such offset: Godot paints them cell by cell.

Pixelbolt's game integration notes cover several sets in one TileSet, padding and scale.

Use it in Tiled

1. In a map of 16 × 16 tiles, Map → Add External Tileset and pick snow.tsx (with snow.png beside it).
2. In the Terrain Sets view, pick snow and paint with the Terrain Brush. Tiles with the same sides and corners (the same Wang id) are alternatives that Tiled picks between at random by their probability.

• A lone cell. Tiled paints the sides and corners between cells, so a single cell with its terrain on no side has no terrain tile: place its tile by hand (the first tile of the sheet, snow-0-a, or its variants just after it).
• Shore. The three terrains are one corner set with a colour each, painted on the points where four cells meet: each point of Tiled's map is a cell of Pixelbolt's, so paint each terrain where you want its cells, as in the shore figure. Every mix of the three has a tile, so the order doesn't matter.
• Slopes. The ground set's slopes are plain tiles with their collision objects, outside the terrain: paint the terrain, then place them by hand.

What the engines did with the four sets

• The maps. For the three blob sets: each set's 20 × 14 test map (for ground, without the slope hills, which aren't terrain) and the five maps of Pixelbolt's engine checks: islands, single cells and one-cell strips, inner corners, a ring, cells that touch only at a corner, and a seeded scatter. For shore: its 22 × 21 test map and Pixelbolt's five layered maps; Tiled paints a corner map one cell wider and taller (the test map is 23 × 22 there), so its six shore maps hold 855 cells to Godot's 736 (an island ring, grass in water, a band of sand and grass, a checkerboard and a scatter). The blob maps have 393 terrain cells, 28 of them lone cells; the empty cells around them stayed empty in both engines.
• Godot. It loaded each TileSet with no error or warning; every tile had the right terrain, peering bits, probability, collision polygon and pixels, and set_cells_terrain_connect put Pixelbolt's tile shape in every painted cell (for a variant, any of that shape's variants counts). For shore, Pixelbolt's tile is the one its map of the corner points draws, half a cell in from the painted cells (see Godot 4).
• Tiled. Each .tsx loaded with the right grid, probabilities, collision objects and a Wang set whose ids match the tiles. Each cell was then given all its sides' and corners' terrain colours from Pixelbolt's map through Tiled's scripting interface for terrain edits (TileLayerWangEdit, which picks tiles that match the requested colours), and every tile Tiled chose was one Pixelbolt's tilemap draws there. That checks the tileset's Wang ids and Tiled's tile lookup, not strokes painted by hand. A lone cell gets no tile in Tiled (above). Tiled's tmxrasterizer drew every tile with its exported pixels, except that the half-transparent shadow pixels of snow and meadow (1,824 of them) came back at most one colour step off in each channel, most likely rounding as it blends a partly transparent pixel; Godot read the same pixels exactly.
• Both engines ran without a window. Painting by hand in the editors was not tested.

Other ways to get a tile set into Godot or Tiled

Every row but Pixelbolt's is from the tool's own page, read on 8 November 2026, not run by us.

A selection: tools that make or wire a whole set and write Godot or Tiled files. Our searches also turned up other AI tile generators, and tools that, by the search summaries, wire or assemble tiles you draw, among them Blobsmith Autotile Wirer and TileBitTools (on the Godot Asset Library), better-terrain, Pentatile and Blobator; we didn't open their pages. SpriteCook also has a free Tileset Base Generator for blank 15- and 17-piece templates.

When to use something else

• You have a finished tile sheet, such as a bought pack in a 47-tile or Wang layout: TerrainForge wires it into a Godot TileSet and a Tiled tileset.
• You'd rather draw the tiles: Autotiler (free, MIT) builds the 47-tile set from a 13-tile template or an RPG Maker A2 block, and Blobsmith from six base tiles. Pixelbolt's own template route takes your drawing as rows of text characters, which is slower than a paint program for detailed tiles.
• You want painted detail from a written prompt and don't mind a hosted AI service with credits: SpriteCook. Pixelbolt draws flat pixel-art fills, speckle, outlines, highlights and stamped details from the description; it doesn't paint textures from a sentence.
• Godot 3: Pixelbolt writes Godot 4 TileSets only. TilePipe exports Godot 3 tilesets, and Autotiler's page lists a Godot 3 export too.
• Isometric tiles: SpriteCook's page lists isometric sets. Pixelbolt's autotile sets are square tiles of an even size from 2 to 84 pixels (its notes).
• A jam that bans AI-made art: no image model is involved here, but rules differ on tools and on what you write with an AI assistant; check with the organisers.

How we tested

• Builds. Pixelbolt 0.13.0 from npm (its source byte-identical to the v0.13.0 tag) built the four sets with the two commands above, in a new folder through npx and again with a local install; both gave byte-identical files, and three timed runs of each set took 555 to 666 ms each, both commands included. make-sets.sh rebuilds them byte for byte.
• Engines. Godot 4.7.2 stable (the official Windows build, its SHA-512 checked against the release's sums), run headless; Tiled 1.12.2 (the Windows installer build), run with --evaluate and tmxrasterizer. No window and no GPU.
• The checks. Pixelbolt's repository has two independent engine checks, scripts/verify-godot.mjs and scripts/verify-tiled.mjs; both passed at the v0.13.0 tag as they are (Godot output, Tiled output). check-page-sets.mjs then ran them on this guide's four sets and their test maps, and compared the CLI's files on this page, byte for byte, with a build of the same descriptions made in the same run as the files the engines loaded (results). For Tiled it uses a copy of the Tiled check that allows a partly transparent pixel to come back one colour step off in tmxrasterizer's render, as the stock check already allows where partly transparent pixels blend in its scene step; opaque pixels and alpha must still match exactly. The copies published here were run from a v0.13.0 checkout's scripts/ folder and gave the same results.
• Not tested: painting by hand in either editor; other Godot or Tiled versions; macOS and Linux; a game body walking on the collision shapes (the polygons were checked against the atlas); the 16-tile cardinal and single-terrain corner modes.

To repeat it: data/README.txt has the commands. The searches this page answers, and what ranked for them on 8 November 2026, are in searches-2026-11-08.txt.