简体中文
EnglishWebsite review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is Tiled?
Tiled is a free, open-source 2D level editor for games. It is designed for building tile-based maps and object layouts, then exporting them for use in a game engine or framework. It is aimed at game developers, level designers and hobbyists who want a dedicated tool for map creation rather than editing levels inside an engine.
What you can build with it
- Tile layers: multi-layer tile editing, fast terrain painting and rule-based tile placement.
- Object layers: rectangles, ellipses and polygons for marking spawn points, triggers, collision zones and other level data.
- Map formats: orthogonal, isometric and hexagonal maps, plus infinite maps that expand as needed.
- Larger worlds: multiple maps can be organised into a world.
- Automation: Automapping places tiles automatically based on rules, and JavaScript extensions let you add custom formats, actions or tools.
Who it suits
- Indie teams and solo developers who want a lightweight, focused editor.
- Designers working with frameworks that already support Tiled’s export formats.
- Projects that need custom workflows, since the editor can be extended with scripts.
Trade-offs to know
Tiled is an editor, not a game engine: it creates and exports level data, and you still need a framework or engine to run the game. Its flexibility means you may spend time configuring rules, templates and export settings. If your engine has a strong built-in level editor, Tiled’s main advantage is portability across many frameworks and formats.
A practical next step: download it, open one of the example projects, and try Automapping on a small test map. If the exported format matches your engine’s importer, you can adopt it quickly; if not, check the documentation for custom export options before committing.
For a broader view of the project and its community, see Tiled.
How do I create a tilemap in Tiled for my game?
Tiled is a free, open-source level editor for building 2D tilemaps that you then load in your game engine. The basic workflow is: create a map, add one or more tilesets, paint tiles on layers, then export in a format your engine can read.
A practical first map
- Start a new map. Choose the tile size (commonly 16×16, 32×32 or 48×48 px) and the orientation: orthogonal (top-down or side view), isometric, or hexagonal. Tiled supports all three.
- Add a tileset. Import a tile image (or a sprite sheet) and set the tile size and spacing/margin so Tiled slices it correctly.
- Create layers. Use a tile layer for terrain, separate layers for decoration, collision, or foreground elements. Multi-layer editing lets you paint across layers without switching context.
- Paint your terrain. For large areas, terrain tools let you paint a ground type and have Tiled pick the right edge and corner tiles automatically. Automapping can place tiles based on rules you define, so patterns like walls or paths fall into place as you draw.
- Add objects. Object layers hold rectangles, ellipses, and polygons for spawn points, triggers, or collision shapes. Objects can be placed, resized, and rotated freely, and object templates let you reuse a configured object across maps instead of rebuilding it.
- Export. Tiled writes to Image, JSON, Lua, GameMaker (1.4 and 2.3), Defold, tBIN, and other formats, and many game frameworks read Tiled maps directly.
Choosing between the two main approaches
| Approach | Best for | Trade-off |
|---|---|---|
| Hand-painted tile layers | Small, art-directed levels; precise control | Slow to revise; repetitive work on large maps |
| Terrain + Automapping rules | Large or procedural-feeling levels; consistent edges and transitions | Rules take time to set up and debug |
Where Tiled fits and where it doesn't
Tiled is an editor, not an engine. It won't run your game, handle physics, or manage entities at runtime; your framework does that. Its strengths are flexibility (arbitrary tile sizes, multiple orientations, custom properties) and workflow features like quickly switching between projects, jumping to any file in a project, customizable keyboard shortcuts, and JavaScript extensions for custom formats, actions, and tools. Infinite maps that grow as needed suit open or streaming worlds, and a "world" file can organize multiple maps that connect.
A concrete scenario
Suppose you're building a top-down RPG in a framework that reads Tiled JSON. You'd make one 32×32 orthogonal map, add a grass tileset and a terrain set for grass-to-dirt transitions, paint the ground on a base layer, add a collision object layer with rectangles around trees and water, place enemy spawn points as objects with custom properties, and export JSON. Your engine reads the tile layers for rendering and the object layer for logic.
Next step
Open Tiled's documentation and work through a single small map end to end: new map → tileset → one tile layer → one object layer → export → load in your engine. That loop teaches more than reading about features. The official site is Tiled; if you want to see what others have shipped with it, the site lists games including Coromon, Carrion, Axiom Verge, and Shovel Knight, and points to more on itch.io.
Which game engines and frameworks can import Tiled maps?
Tiled exports maps in formats that many engines and frameworks already read, so "importing a Tiled map" usually means loading its exported JSON, Lua or image files rather than using a dedicated plugin. The page lists JSON, Lua, GameMaker (1.4 and 2.3), Defold and tBIN among its export targets, and states that Tiled is supported by many game development frameworks.
What that means in practice
- Web and JavaScript stacks: The JSON export is the common path. Phaser, MelonJS and similar libraries ship Tiled JSON loaders; you load the tilemap, then the tileset image, and place layers in your scene.
- Defold: Listed as a direct export target, so you can write map data in a format the engine consumes without a conversion step.
- GameMaker: Both the 1.4 and 2.3 export options are listed, which matters because the two versions use different project structures.
- Lua-based engines (e.g. LÖVE): The Lua export gives you map data as a table you can read directly in your game code.
- Custom or in-house engines: JSON and Lua are plain, documented formats, so a small parser is usually enough. Tiled's JavaScript extensibility also lets you add custom export formats if yours isn't covered.
A quick comparison
| Your situation | Likely route |
|---|---|
| Browser game with a JS engine | Tiled JSON + the engine's built-in loader |
| Defold project | Defold export |
| GameMaker 1.4 or 2.3 | Matching GameMaker export |
| Lua engine or prototype | Lua export |
| Proprietary engine | JSON/Lua export plus a custom reader, or a JS extension |
Next step: check whether your engine already has a Tiled loader before writing any parsing code. If it does, export to the format that loader expects (usually JSON) and keep the tileset image alongside the map file. If it doesn't, start with the JSON export — it's the most widely documented and the easiest to inspect while debugging.
How does Tiled's Automapping feature work for automatic tile placement?
Tiled's Automapping is a rule-based system: you describe which tile patterns should trigger which output tiles, and Tiled applies those rules across your map instead of you painting every tile by hand. The official description frames it as a way to "focus on level design" — you lay down rough shapes or terrain, and the rules fill in the correct tiles.
How the rules are set up
- You create a separate rules map containing input and output layers.
- Input layers define the pattern to look for; output layers define what gets placed where that pattern matches.
- Regions and indexes in the rules map tell Tiled how to compare the pattern against the target map and which variant of the output to use.
- Rules can match tile layers and object layers, so the same mechanism can place decorative objects as well as terrain.
What it is good at
- Autotiling terrain edges, corners and transitions between biomes.
- Repetitive decoration such as fences, paths, pipes or wall variations.
- Enforcing consistency across a large or infinite map, where hand-painting would be error-prone.
- Keeping art changes cheap: update the rule set, re-run it, and the whole map updates.
Trade-offs to expect
Rules take real effort to author and debug, and a bad rule can silently overwrite tiles you placed deliberately. Automapping runs as a batch operation over a region or map, not as a live brush, so the workflow is "paint roughly, then apply rules" rather than instant feedback on every stroke. Complex conditional logic is better handled by the JavaScript extension than by stacking rules.
A practical next step
Start with one narrow case — say, a single tileset's grass-to-dirt edges — build the rules map, and apply it to a small test map before committing to a full rule library. If you want to see the feature in context before building your own, the project's own documentation and news posts are the most reliable starting point: Tiled.
What are the differences between orthogonal, isometric, and hexagonal maps in Tiled?
Tiled supports three map orientations—orthogonal, isometric, and hexagonal—and the right choice depends on how you want movement, depth, and tile adjacency to read in your game. The page lists all three as supported map types, but it doesn't spell out their differences, so the following is general guidance rather than product-specific detail.
Orthogonal maps use a square grid viewed straight on. Tiles sit in rows and columns, movement is typically four- or eight-directional, and adjacency is trivially "up, down, left, right." This is the default for top-down RPGs, strategy games, and platformers where you want simple, predictable grid logic. It's the easiest to author and the least surprising for players.
Isometric maps use a diamond grid that fakes a 2.5D perspective. The grid is still logically square underneath, but it's drawn at an angle so tiles overlap in a way that suggests height and depth. This suits city builders, tactics games, and anything with a strong sense of elevation. The trade-off is that vertical position on screen no longer maps cleanly to grid rows, so depth sorting and click-to-tile conversion need care.
Hexagonal maps use six-sided tiles. Each tile has six neighbours instead of four or eight, which produces more natural-looking distances and less grid distortion for movement and range calculations. This is common in hex-based wargames and 4X strategy. The cost is that rectangular art and UI alignment are harder, and many players find hex grids less immediately readable.
| Orientation | Grid shape | Best for | Main trade-off |
|---|---|---|---|
| Orthogonal | Square | Top-down RPGs, platformers, strategy | Simplest, but can feel flat |
| Isometric | Diamond (angled square) | City builders, tactics, elevation-heavy games | Depth sorting and picking are trickier |
| Hexagonal | Hex | Wargames, 4X, range-based movement | Less intuitive for some players; art alignment is harder |
A practical next step: decide based on your movement model first, not your art. If distance and range matter a lot, hex is often the cleanest fit; if you want depth and verticality, isometric; if you want speed of authoring and clear grid logic, orthogonal. Then check that your target framework exports and renders the orientation you picked—Tiled exports to formats like JSON and Lua, but the engine still has to support the projection.
For concrete examples, the page notes that games such as Shovel Knight, Axiom Verge, and Coromon were made with Tiled, which gives you reference points across different genres. You can find more at Tiled and browse additional titles on itch.io.
Can I extend Tiled with custom tools or file formats using JavaScript?
Yes. Tiled's page_evidence lists "Extensible with JavaScript" under its Powerful Workflow section, with three specific capabilities: add support for custom file formats, write your own actions or tools, and automate your workflow. So both halves of your question — custom tools and custom file formats — are covered by the same scripting layer.
What this looks like in practice
A concrete scenario: your studio stores level data in a proprietary binary format that your engine reads at runtime. Rather than hand-converting Tiled maps every build, you write a JavaScript extension that teaches Tiled to read and write that format, so artists edit in Tiled and export directly to what the engine expects.
The three listed capabilities map to different needs:
| Capability | Typical use |
|---|---|
| Custom file formats | Import/export to an in-house or engine-specific format |
| Custom actions or tools | Add menu commands, custom painting or placement behaviour |
| Workflow automation | Batch operations, project-specific repetitive steps |
A useful next step
Before writing anything, check whether your target engine already has an official Tiled importer. The page lists exports to Image, JSON, Lua, GameMaker (1.4 and 2.3), Defold and tBIN, and notes that many game development frameworks support Tiled — so a custom format extension may be unnecessary work.
If you do need one, the practical decision criterion is this: write a JavaScript extension when the format is stable and the conversion logic is simple; consider an external converter script instead when the format changes often or needs heavy validation, since you can iterate on it without reloading the editor. For the extension route, start from the documentation rather than guessing at the API, and check the forum if the format involves anything unusual like binary chunks or nested references.
Fastly
Fastmail
User reviews (0)