Coming from Unity Tilemap¶

If you already know Unity's own Tilemap, most of what you know carries over, but a few things work differently enough to trip you up in the first hour. This page maps each Unity piece to its counterpart here and lists the differences that matter.

Concept¶

Unity builds a tilemap from several components: a Grid, one Tilemap and TilemapRenderer per layer, a TilemapCollider2D with a CompositeCollider2D for physics, and a separate palette asset to paint from. Every tile is its own asset.

Here the pieces are fewer and bigger:

A tileset asset holds one atlas texture, every tile sliced from it, and the brushes that paint with those tiles. It is also the palette. There is no tile asset per sprite.
An STETilemap component is the layer. It has its own cell size, renders itself and builds its own colliders. There is no Grid component.
A TilemapGroup stacks several tilemaps as the layers of one level, where Unity would put several Tilemap objects under one Grid.

Both systems can live in the same project and the same scene. Neither needs the other.

Name for name¶

Unity Tilemap	Super Tilemap Editor
`Grid` with `Tilemap` children	`TilemapGroup` with `STETilemap` children. See Tilemap Groups.
`Grid` > `Cell Size`	`Cell Size` in each tilemap's `Map` tab, set from the tileset when you assign it. See Map.
`Tilemap` + `TilemapRenderer`	`STETilemap`. The renderer settings are its `Renderer` tab. See Renderer.
Tile asset (`Tile`, `TileBase`)	A tile inside the tileset, known by its tile id. See Tilesets.
Palette prefab and the `Tile Palette` window	The tileset itself, shown on the tilemap's `Paint` tab or in `Tools > Super Tilemap Editor > Window > Tile Palette Window`. See Tile Palette.
Rule Tile (2D Tilemap Extras)	`RoadBrush`, `CarpetBrush`, `Brush47` and `A2X2Brush`. See Built-in Brushes.
Animated Tile, Random Tile	`AnimBrush`, `RandomBrush`.
Custom `TileBase` subclass	A custom brush, a `TilesetBrush` subclass. See Custom Brushes.
`TilemapCollider2D` + `CompositeCollider2D` + `Rigidbody2D`	`Collider Type:` set to `2D` in the tilemap's `Collider` tab. Nothing to add. See Colliders.
The sprite's `Custom Physics Shape`	The tile's collider in the Tile Properties window, editable in the scene view too. See Tile Properties.
`Tile.gameObject`	The tile's prefab. See Tile Prefabs.
`Tilemap.SetColor`	The `Color` tab, which paints a color on each corner of a tile. See Color.
Rotating and flipping a cell with `SetTransformMatrix`	The `FlipH`, `FlipV` and `Rot90` flags stored in the cell. See Tile Data.
No equivalent	Named parameters per tile and per brush, read from code. See Tile Properties.

What works differently¶

Nothing appears until you rebuild¶

In Unity, SetTile shows the tile on the next frame. Here SetTile and SetTileData only store the data. The tiles appear when the mesh is rebuilt, and you ask for that:

using CreativeSpore.SuperTilemapEditor;

// Unity: tilemap.SetTile(new Vector3Int(3, 4, 0), grassTile);
m_ground.SetTile(3, 4, m_grassTileId);

// Rebuild once, after all your writes, not after each one.
m_ground.UpdateMesh();

This is the most common surprise, and it is on purpose: a generator that writes 250,000 cells pays for one rebuild at the end. Call UpdateMeshImmediate() instead when the colliders have to exist before your next line runs, for example before you place the player. See Scripting.

One atlas per tilemap¶

A Unity tilemap can hold sprites from any texture. An STETilemap draws from exactly one tileset, and a tileset from one atlas texture. If your art is spread over several textures, either combine it into one atlas or give each texture its own tilemap in a group.

You do not drag sprites in. You slice the atlas once in the tileset inspector, and every tile it yields is in the palette. A texture already sliced in Unity's Sprite Editor can be dropped into an empty tileset's Atlas Texture field and the tiles come from those sprites. See Getting Started.

Tiles are ids, not assets¶

A cell stores a number, not a reference to an asset. Code that asked Unity for tilemap.GetTile<MyTile>(pos) asks here for GetTile(x, y), which returns the Tile entry from the tileset, or GetTileData(x, y) for the raw cell value. Brush cells hold a brush id as well. Tile Data describes the format.

Because a cell is only a number, a big map is small on disk. In a measurement on 2026-09-23, a 512x512 map saved to a 2.5 MB scene here and a 68.7 MB scene with Unity's Tilemap.

Grid coordinates are two numbers¶

Positions are (x, y) cells, with no z. Cell (0, 0) has its bottom left corner on the tilemap's origin, as in Unity. The conversions:

Unity	Here
`grid.WorldToCell(worldPos)`	`TilemapUtils.GetGridPositionInt(tilemap, tilemap.transform.InverseTransformPoint(worldPos))`
`tilemap.GetCellCenterWorld(cell)`	`TilemapUtils.GetGridWorldPos(tilemap, x, y)`
`tilemap.cellBounds`	`MinGridX`, `MinGridY`, `MaxGridX`, `MaxGridY`
`tilemap.CompressBounds()`	`Trim()`
`tilemap.ClearAllTiles()`	`ClearMap()`
`tilemap.SetTile(pos, null)`	`Erase(x, y)`, then a rebuild

The overloads that take a Vector2 expect a position in the tilemap's local space, not a world position. Positions and the Mouse covers all of it.

Rectangular grids only¶

Unity's Grid also does isometric and hexagonal layouts. This tool only lays tiles out on a rectangular grid. A tile can still be drawn with any art you like, but the cells are rectangles.

Colliders are built per chunk, merged¶

A tilemap is split into chunks of 60 by 60 cells, and each chunk builds one set of colliders from the tile shapes, merging neighbouring tiles into longer outlines. There is no composite collider to set up, and no Rigidbody2D to add for it. Pick EdgeCollider2D or PolygonCollider2D under Collider 2D Type. Colliders explains which one to use. A Composite Collider 2D is still available if you want the chunks merged into one outline too; see Colliders for what it costs.

A tile's collider shape is set on the tile, in the Tile Properties window, not read from the sprite. Several tiles can be edited at once by selecting them together in the palette.

Autotiling uses fixed layouts¶

A Rule Tile lets you write any rule. The brushes here each expect a known layout of tiles: 16 pieces for a road, 13 for a carpet, 47 for a Brush47. You fill the brush's grid from the palette and it picks the right piece for each cell from its neighbours. If your art does not fit one of those layouts, a custom brush is a short C# class whose Refresh reads the neighbours and returns the tile to draw, so it can follow any rule you write.

Layers and switching between them¶

Select the TilemapGroup and the Tilemaps overlay in the scene view lists its layers. Click one to paint on it, or press keypad + and - to step through them. Ctrl + right click on a cell picks the tile from the first visible layer in the list that has one there, and switches to that layer.

Painting, key for key¶

Painting happens in the scene view with the tilemap, or its group, selected and the Paint tab open.

To do this	Press
Paint	Left click or drag, with the paint tool (`B`)
Erase	`Shift` + left click or drag
Flood fill	Double-click a cell
Pick the tile under the cursor	Right click
Copy a block of tiles	Right-drag over them
Line, rectangle, ellipse	`L`, `R`, `E`
Flip the brush	`X`, `Y`
Rotate the brush	`.` and `,`

Unity's Rect tool (T), or no transform tool, has to be active. The full list is in Keyboard and Mouse.

Bringing an existing map across¶

There is no converter from Unity Tilemap in this version. If the level was built in Tiled, the Tiled importer brings it in directly. Otherwise, the path is to slice the same atlas into a tileset and repaint, or to write the cells from a script that reads your Unity tilemap and maps each sprite to a tile id.