All articles

Use a Unity 6.3 project with the Universal Render Pipeline (URP). Open Tools → QuickTile → Setup & Verify to check the project and import the starter content. The package also includes demo scenes in its QuickTile Starter Pack sample.

1. Open the reference scene.

   In Package Manager, select QuickTile and import QuickTile In-game Reference from Samples. Open Scenes → QuickTile Reference for the supplied Level 11 layout and the reference settings below. Keep its ground, cliff, grass and material settings for your first comparison. QuickTile Game 1 is a separate scene with its own saved level for customization. The sample README explains how to select the included URP pipeline, use Linear color space and enable legacy input or Both. See the reference settings.

2. Enable editing before entering Play.

   In the QuickTile Inspector, set In-game editor → When playing → In-game Editor. Save the Unity scene, then press Play.

3. Choose a tool on the left.

   The sidebar contains Select, Terrain, Path, Ledge, Wall, Bridge, Rail (BETA), Water, Dig, Texture and Objects. More opens the extra tools. The bottom bar holds Erase, Undo, Redo, Save and Load.

In Unity’s Hierarchy, select the object with the QuickTilemapEditor component, then expand it in the Inspector. With an existing QuickTile setup, Tools → QuickTile → Open Editor selects that object for you. Click the triangle beside a section to open its settings. The Inspector remembers which sections you have opened for that object.

The sections below follow the Inspector’s order. Choose one to jump to its explanation.

Header & More actions

The header contains the QuickTile logo and version, the Save level icon and the three-dot More actions menu. Below it, use the level selector, Previous / Next arrows or New level. New level keeps the current level in the list and retains the palettes.

Reload level

Reload the selected level from its saved file.

Restore autosave…

Choose an earlier autosave of the current level.

Show raw components

Show QuickTile’s helper components in Unity’s Inspector.

Reset layout for this object

Reset which sections and cards are expanded.

Setup and verify…

Open QuickTile’s setup and project checks.

How to use (included)

Open the documentation supplied with the package.

Website

Open QuickTile’s website.

Discord

Open the BEKKOLOCO community.

The save icon’s tooltip shows Save level (Ctrl+S). See saving and loading levels.

Level

Set the level’s Name and Style (3D or 2.5D beta). Center drawing on save centres the drawing in grid coordinates when it is saved.

Properties → + Add property adds a key and a String, Int, Float or Bool value for your game. All levels lists the saved levels and marks the current one. Its footer provides Reload, Restore autosave… and Delete. Delete removes the entry from the list and leaves its file in the project; it is disabled for the last level.

To find the current file, open Tools → Level file → File. See the reference level’s settings.

Themes

Each theme card groups its ground and construction styles. The card’s texture strip shows Ground, Cliff and Skirt. Use + New theme to create another theme. A new setup also offers a first theme or an empty drawing layer here.

Dig

Can be dug permission, walls and ceiling textures, floor texture and surface blending.

Texture paint

Paint layers, their texture scales, normal maps, blend sharpness and Keep vegetation.

Ground

Corner rounding, Contact blend, skirt, ground and cliff materials, texture settings and the theme’s plants.

Paths

Styles for dirt paths, ledges, ramps and tracks.

Walls

Wall and barrier styles.

Bridges

Stone and wood bridge styles, materials and dimensions for new bridges.

Stairs

Stair styles and their materials.

Liquids

River, lake and waterfall styles, materials, and Rocks & moss.

For example, open Themes → your theme → Bridges to edit a bridge style’s defaults. To change one bridge already drawn, use Tools → Advanced editors → Paths and that bridge’s card. See the bridge settings and code.

Theme options and theme-card actions appear where applicable. Some material, vegetation and style groups depend on the theme’s palette or content. See texture painting.

Props

Use + New prop to add an object to the placement palette. Open its card to assign a Prefab and choose Placement, Y offset, Random Y rotation, Place on ground, Follow grid scale and Follow deformation. Refresh placed objects applies the prop’s settings to its placed instances.

See placing and rotating objects.

Scene

Wind

Choose the Wind Zone and tune the movement shared by the vegetation.

Vegetation

Browse species and the global Population, Rendering and Advanced groups. These cover scattering, draw distances, detail and shading. See the reference values.

Water

Set automatic generation, riverbed dimensions and waterfall dimensions. Waterfall cliff rocks and Advanced settings appear here. Water materials and styles are in Themes → your theme → Liquids. See the water examples.

Dig holes

Set Rocky edges, Hole surface, available Rock lining, Destruction FX and Constructions destructible. See digging and wooden destruction.

In-game editor

When playing chooses In-game Editor for authoring or In-game for gameplay with your game camera. This setting applies in Unity Play mode and in builds.

For the linked editor rig, choose Camera and open Camera & controls, Painting, Toolbar & minimap, Saving, Input System or Advanced. Input System appears when its integration is present. Saving includes Auto Create Level, Default Level Name and Keep Levels After Play.

Select locates the rig in the Hierarchy. If the section shows Not set up, the current QuickTile has no linked editor rig. Component-specific groups appear once their components exist.

Camera controls · Code to switch to gameplay · Saving after Play

Drawing grid

Scene editing enables editing in Unity’s Scene view. View chooses 7 × 7, 16 × 16, 32 × 32, 64 × 64 or Custom. Custom exposes Width, Height and Apply for the displayed grid. Center recentres that view.

Scale ranges from x1 to x10 and scales the level. The grid’s editing controls include Draw, Erase, Dig, Fill Hole, Move, Select and Picker. See level scale and its C# example.

Tools

Advanced editors → Paths

Open each existing path or construction card to edit its dimensions, materials and points. Paths Options contains Colliders when the path semantics component is present. + New path creates a path of the chosen construction type.

Advanced editors → Tile layers

Inspect individual terrain layers. A layer’s Digging settings include Mode, Hardness, Max volume depth, Remove vegetation, Objects and Rebuild NavMesh.

Components

Browse QuickTile’s helper components, their enabled state and hierarchy location. Show raw components makes their individual Inspectors visible.

Maintenance

Rebuild terrain, Rebuild paths, Resync props and Reset layout.

Level file

View or assign the current level’s .bytes or .json file, with the level’s content counts.

Performance

Distance detail (prototype), and the Rebuild scheduler and Performance probe when present. See performance settings.

Danger zone

Clear all content removes the current level’s terrain, props and painted textures after confirmation.

MCP (Unity AI Assistant)

Configure the optional Unity AI Assistant connection.

Find a setting

The minimap gives an overview of the level. In Help, Back and Next tip browse the pages; Hide help closes the panel.

Click More below the main tools. It opens Hand, Flowers, Islands, Slope, Stairs, Barrier, River, Waterfall and Track.

• Hand: sculpt the ground
• Flowers: draw a garden
• Islands: select connected terrain
• Slope and Stairs
• Barrier and Track
• Rail: use the Rail button on the main sidebar
• River and Waterfall constructions

1. Choose Terrain.

   The side palette shows each terrain theme with its Ground and Cliff textures, plus a Water card. Click a card, then drag across the grid to paint tiles. Choose Water to paint a water island. With an island selected, the palette changes that island’s surface and keeps its shape and height.

2. Set the brush size.

   Terrain keeps the Brush − / Brush + size control. Use a small brush for edges and a larger one to fill an area.

3. Extend or stack.

   A selected island extends at its own height. Hold Ctrl / Cmd while painting on a top surface to stack a new layer.

Switch to Select to change a platform’s outline or height. To remove tiles, use Erase → Terrain.

Click a platform to show its white scene controls. Double-click it, or press F after selecting it, to bring it into view.

Use Terrain to add cells to the island, or Erase → Terrain to reduce its outline.

Click Base width without dragging to open the base shape choices, including Rocky. While an island is selected, choose a theme from the Terrain palette beside the toolbar. Ground cards preview their Ground and Cliff textures; Water switches that island to the default water surface. The choice changes only the selected island.

Drag a control and release to keep the edit. Use Undo if you want to try another shape.

Islands selects a connected group of terrain cells. Use Select and the island’s height and Move controls to change the connected platform.

1. Choose More → Hand.

   Aim at the ground you want to shape.

2. Drag upward or downward.

   Grab the ground and drag vertically to form a hill or a hollow. The top and its grass or rock fringe follow the relief; the cliff underside stays fixed. Release to keep the relief.

3. Refine the retained point.

   The point’s height icon stays available so you can adjust the same shape later.

Scroll over the hand preview to change its radius. You can also hover over the top of a selected platform to grab its sculpt handle.

Point radius, falloff, terrain noise and protected zones are deeper sculpt settings in the Unity Inspector. They are not extra horizontal menus in the current ingame interface.

1. Select a solid island.

   Click Hollow: No to create an enclosed empty interior with a floor, walls and ceiling.

2. Open an entrance.

   Choose Dig and cut through the outside wall. Only the shell needs to be removed to reach the room.

3. Build in the room.

   Aim at the interior floor or wall. You can draw walls and ledges inside, then edit them using their scene controls.

1. Choose Dig.

   The default brush removes a grid-aligned 1×1×1 volume. You can aim from above, from the side or from underneath.

2. Check the preview before clicking.

   Point at an accessible face. Move the camera closer if another surface blocks your view.

3. Work through the wall.

   Dig into a solid island to make a tunnel, or cut through a Hollow shell to enter its empty room.

The visible opening uses the terrain’s organic cut surface. The dig volume follows the grid; the hole’s rock edge does not need to look like a square doorway.

Dig block settings

A scripted dig block is a subtractive volume: it cuts an opening in the terrain. For a 1 × 1 × 1 m example, place an empty GameObject at the centre of the block’s top face. The cut extends 1 m downward and 0.5 m to each side, provided the terrain layer’s maximum dig depth allows it.

C# example: spawn a dig block

1. Add the script.

   Create DigBlockSpawner.cs, add it to a GameObject and assign Level, Top Center and Rule Index.

2. Spawn the cut.

   Choose Spawn dig block from the component’s context menu, connect Spawn to a UI button, or call spawner.SpawnAt(worldTopCenter) from another script. Put the volume where it overlaps solid terrain.

3. Fill it again.

   Call FillLast or choose Fill last dig block from the component’s context menu to remove the most recent cut created by this spawner.

Download DigBlockSpawner.cs

using UnityEngine;
using Bekkoloco.QuickTile;

public class DigBlockSpawner : MonoBehaviour
{
    public QuickTilemapEditor level;
    // Put this marker at the centre of the block's top face.
    // When empty, Spawn uses this GameObject's position.
    public Transform topCenter;
    // Zero-based index in level.tileRules, not the Paths list.
    [Min(0)] public int ruleIndex = 0;
    // World-space dimensions in metres: width, depth, length.
    public Vector3 worldSize = Vector3.one;

    private string lastVolumeId;

    [ContextMenu("Spawn dig block")]
    public void Spawn()
    {
        Vector3 position = topCenter != null
            ? topCenter.position : transform.position;
        SpawnAt(position);
    }

    // Call this from another script to choose the position at runtime.
    public QuickTileDigVolume SpawnAt(Vector3 worldTopCenter)
    {
        if (level == null)
        {
            Debug.LogWarning("Assign the QuickTile level first.", this);
            return null;
        }

        var volume = level.CreateDigVolume(
            worldTopCenter, worldSize, ruleIndex);
        if (volume == null)
        {
            Debug.LogWarning(
                "Choose a diggable terrain rule with Dig Mode " +
                "set to Volume or Both.", this);
            return null;
        }

        lastVolumeId = volume.persistentId;
        return volume;
    }

    [ContextMenu("Fill last dig block")]
    public void FillLast()
    {
        if (level == null || string.IsNullOrEmpty(lastVolumeId))
            return;
        if (level.RemoveDigVolume(lastVolumeId))
            lastVolumeId = null;
    }
}

Break wooden bridges and ledges

Choose Dig and click the visible wood where you want a break. Construction digging supports the built-in wood bridge styles and Wood ledges. The QuickTile Inspector’s Constructions destructible option is on by default; turning it off prevents new damage while keeping existing breaks.

On a wooden bridge, Dig opens a real gap in the deck and breaks the affected supports. At each broken edge, the last whole row of ordinary planks is removed. Earlier planks keep their original width and thickness. Large broken pieces replace that row at right angles to the normal planks, with different lengths and slight rotations.

On a hanging bridge, digging the deck removes planks and leaves broken pieces hanging from the retained cables. The main cables, their V-shaped lacing and the anchor posts stay when the deck is hit. Direct hits on a rope or post can still break it; the remaining rope pieces stay attached or hang from a surviving anchor.

A Wood ledge breaks at the area you dig, with damaged deck planks and supports matching its construction. The gap is also removed from the walking surface. With Destruction FX enabled, a Dig click briefly releases falling wood fragments.

1. Choose Texture.

   A vertical palette opens beside the tool sidebar. Click a texture preview to select it.

2. Draw on the terrain.

   Drag to trace the painted area, then release. The texture follows the existing ground surface. This tool creates no 3D path, mesh, stairs or raised terrain.

3. Edit the painted area.

   Select its trace to move the points and adjust its width and edges. Choose another texture to change that selected trace. Continue extends either endpoint.

4. Set up your layers.

   In the Unity Inspector, open Texture paint to choose each layer’s texture, scale, optional normal map, blend sharpness and Keep vegetation. Save the level to keep the editable traces and their layer choices.

Each paint layer has a Keep vegetation checkbox. Leave it checked to keep grass and other plants on the painted surface. Uncheck it for bare ground, such as dirt or paving. The supplied Reference scene uses grass at scale 0.1 with vegetation and Default-Checker-Gray at scale 0.6 without vegetation. Both layers use no normal map. With the supplied TopLit ground material, a layer’s normal map adds surface detail; leaving it empty keeps the ground’s existing normal.

Ground, Cliff and Skirt have separate textures. A copied ground can keep a different appearance: the reference scene includes a metal copy without plants or a grass skirt.

Previous levels retain their existing painted cells. New painting uses editable traces on the surface.

Which textures the palette shows

The Texture palette lists the level’s paint layers. The Inspector shows the same list: open Themes, the theme card, then Texture paint. After the ground’s blend channels, it also lists the layers only the Texture tool draws, each with Remove layer. Remove layer stays disabled while a texture trace, painted cells or plants still use the layer; erase them first. Give a layer a Name to show the same label in the Inspector and in the palette.

1. Choose Path and draw your route.

   Drag across the ground to trace it. Release, then select the route to edit its anchors and shape.

2. Reshape the existing path.

   Move its control points or drag its visible size and position controls. A raised path has Height, Width, Depth and Base controls. At a slope transition, Width, Length and Angle adjust the connection.

3. Extend either end.

   Click the round Continue control with the pencil icon at the first or last endpoint, then draw the next part.

Continue extends the same path and keeps its theme and style. Press Escape to cancel an extension. The same pencil control is available on eligible walls and other constructions.

Cross a cliff with a dirt ramp

When a path goes from one terrain layer onto a touching layer at least 0.25 m higher or lower, QuickTile builds a ramp there automatically. The dirt continues over the ramp, the ramp uses the ground’s own paint, and its grass fringe copies the island’s skirt: an island without a skirt gives a ramp without one.

1. Draw across the edge.

   Drag from one plateau, over the cliff edge, onto the other layer, then release. Each crossing between two touching layers gets its own ramp.

2. Select the path or click a ramp.

   Clicking a ramp selects its path and shows the controls on that ramp.

3. Adjust Width, Length and Angle.

   Drag either Width arrow on the ramp’s edges (0.25–8 m). Drag Length at the foot to set a fixed length (0.25–32 m). Drag Angle above the middle to change the slope (5°–75°); this returns to an automatic length. The value shows next to the pointer, and each drag is one Undo step.

Ramp settings

In the Unity Inspector, open Tools → Advanced editors → Paths and the path’s card: Transition width, Slope angle, Slope length (0 is automatic), Height transition (Slope or Stairs), Smooth ends and Side skirts set the same values. A ramp is never narrower than the path width + 0.3 m.

C# example: Control ramps from UI buttons

These methods act on the path the player has selected, with the same Undo steps as the scene controls. Assign the scene’s QuickTileRuntimePathEditor and connect these methods to your UI buttons.

using UnityEngine;
using Bekkoloco.QuickTile;

public class RampButtons : MonoBehaviour
{
    public QuickTileRuntimePathEditor pathEditor;

    public void UseRamp() => pathEditor.SetGroundPathTransition(false);
    public void UseStairs() => pathEditor.SetGroundPathTransition(true);
    // returns to an automatic length
    public void Steeper() => pathEditor.AdjustGroundPathSlopeAngle(5f);
    // switches to a fixed length
    public void Longer() => pathEditor.AdjustGroundPathTransitionLength(0.5f);
    public void AutoLength() => pathEditor.ResetGroundPathTransitionLength();
    public void Wider() => pathEditor.AdjustGroundPathTransitionWidth(0.25f);
    public void ToggleSmoothEnds() => pathEditor.ToggleGroundPathSmoothEnds();
    public void ToggleFringe() => pathEditor.ToggleGroundPathSkirts();
}

C# example: Set a path’s ramp settings

Change a specific path’s ramp fields and rebuild it. This does not record an Undo step. Assign the QuickTile component and path index, then choose Apply ramp settings from this component’s context menu.

using UnityEngine;
using Bekkoloco.QuickTile;

public class DirtPathRampSettings : MonoBehaviour
{
    public QuickTilemapEditor level;
    public int pathIndex;

    [ContextMenu("Apply ramp settings")]
    void Apply()
    {
        if (level == null || pathIndex < 0 || pathIndex >= level.paths.Count)
            return;
        QuickTilemapEditor.Path path = level.paths[pathIndex];
        if (path == null || !path.groundPath || path.IsTexturePaintPath)
            return;

        // ramp, or true for stone stairs
        path.groundPathUsesStairs = false;
        // 5 to 75 degrees, used while the length is automatic
        path.groundPathSlopeAngle = 20f;
        // 0 = automatic; 0.25 to 32 m = fixed length
        path.groundPathSlopeLength = 0f;
        // never narrower than the path width + 0.3 m
        path.slopeWidth = 2.5f;
        // eased profile; false = straight grade
        path.smoothTransition = true;
        // grass fringe where the island has a skirt
        path.slopeSideSkirtEnabled = true;
        // smallest height step that builds a ramp
        path.contextualHeightThreshold = 0.25f;

        // rebuilds this path's ramps and dirt paint
        level.RebuildPathMesh(pathIndex);
    }
}

Choose Ledge and draw along a cliff or an interior wall. A ledge can connect lower ground to the island’s top. Select it afterward to adjust its anchors, width and height.

Ledge settings

The ledge’s Style control offers the styles provided by its theme, including wood, stone and ground. Use Rail to change its railing where the style supports it. Try the ledge from the side to check its connection to the upper surface.

Ledges inside a hollow island work the same way: point at an interior wall and draw the route at the height you need.

Use Dig on a wood ledge to break its deck and supports. See wooden construction destruction and restoration.

C# example: Change the style of every ledge

QuickTilemapEditor.SetLedgeStyle changes a ledge’s style like the Style control; rebuild the path afterward.

using UnityEngine;
using Bekkoloco.QuickTile;

public class LedgeStyleSwitcher : MonoBehaviour
{
    public QuickTilemapEditor level;

    // Gives every ledge of the level the same look, then rebuilds it.
    public void RestyleAll(QuickTilemapEditor.LedgeStyle style)
    {
        for (int i = 0; i < level.paths.Count; i++)
        {
            QuickTilemapEditor.Path path = level.paths[i];
            if (path == null || path.pathType != QuickTilemapEditor.PathType.Ledge)
                continue;
            if (QuickTilemapEditor.SetLedgeStyle(path, style))
                level.RebuildPathMesh(i);
        }
    }

    public void Wood() => RestyleAll(QuickTilemapEditor.LedgeStyle.Wood);
    public void Stone() => RestyleAll(QuickTilemapEditor.LedgeStyle.Stone);
}

Choose Wall, draw the wall on a surface, then select it. Drag its height, width and point controls to change the construction. Walls can also be drawn on the floor inside a hollow island.

Choose the material and shape

Click the round Style control in the scene. Choose Stone wall for a solid wall or Wood fence for the light wood fence. The fence option has a fence icon.

Use the pencil Continue control at the start or end to extend the wall with the same style. Door and arch openings can be configured in the wall’s Inspector settings; an existing opening has its own editable geometry.

Example: connect two surfaces

1. Draw between two surfaces.

   Choose Bridge and draw between the surfaces you want to connect.

2. Select the bridge.

   Adjust its span, width, rise and depth with the scene controls.

3. Choose a style.

   Open Style and choose Wood rope or Stone. Inspect both landings from the side.

Open Style to choose Wood rope or Stone. Wood rope uses a wooden deck and rope rails. Stone creates the arched masonry bridge. Compatible stone arcades also expose a Vault control.

Inspect each landing from the side after changing the span or rise. A fixed-span stone bridge uses its endpoint handles rather than Continue.

Dig can break the wooden deck directly. The break follows the bridge design. See broken wood and hanging bridges.

Bridge settings

For the example below, use Stone, Width 1.5 m, Rise 0.32 m, Depth 1 m and railings enabled. Adjust these values to fit your landings.

In the Unity Inspector, open Tools → Advanced editors → Paths, then the bridge’s card. Wood settings include deck rise or sag, plank length, post spacing and rope railings. Stone settings include arcades, support depth, arch spacing, pier width and arch rise.

C# example: apply bridge settings

1. Create BridgeSettings.cs.

   Add the script to a GameObject and assign the level’s QuickTile component.

2. Choose the bridge.

   Set Path Index to the bridge’s zero-based position in the level’s Paths list. Index 0 is the first path, including other construction types.

3. Apply the example settings.

   Choose Apply bridge settings from this component’s context menu, or connect Apply to your own UI button. The script changes the existing bridge and rebuilds it.

using UnityEngine;
using Bekkoloco.QuickTile;

public class BridgeSettings : MonoBehaviour
{
    public QuickTilemapEditor level;
    // Zero-based index in the level's Paths list.
    public int pathIndex;
    public QuickTilemapEditor.BridgeStyle style =
        QuickTilemapEditor.BridgeStyle.Stone;
    [Range(0.5f, 4f)] public float width = 1.5f;
    [Range(-5f, 5f)] public float rise = 0.32f;
    [Range(0.1f, 8f)] public float depth = 1f;
    public bool railings = true;

    [ContextMenu("Apply bridge settings")]
    public void Apply()
    {
        if (level == null || level.paths == null ||
            pathIndex < 0 || pathIndex >= level.paths.Count)
            return;
        var path = level.paths[pathIndex];
        if (path == null ||
            path.pathType != QuickTilemapEditor.PathType.Bridge)
            return;

        // Keep the theme's materials when changing the bridge style.
        var ground = level.ResolveThemeGround(path.themeId);
        var namedStyle = level.ThemeStyles(ground).ByBridgeShape(style);
        level.StampPathStyle(path,
            namedStyle ?? QuickTileThemes.BuiltIn.ByBridgeShape(style),
            ground, creation: false);
        if (namedStyle == null) path.styleName = string.Empty;

        path.bridgeWidth = Mathf.Clamp(width, 0.5f, 4f);
        path.bridgeCurve = Mathf.Clamp(rise, -5f, 5f);
        path.bridgeHeight = Mathf.Clamp(depth, 0.1f, 8f);
        path.bridgeRailings = railings;
        level.RebuildPathMesh(pathIndex);
    }
}

Choose Rail (BETA) on the main sidebar, then Rail in its palette. This tool creates a round bar with gold ornamentation.

Example: three-point rail

1. Draw a rail.

   Choose Rail in the palette, then draw a route with at least two separate points. Select the result to edit it.

2. Shape the route.

   Move its points to set the height and direction. Rail points can sit in the air and retain their exact positions. Move the first or last point to change an endpoint.

3. Set its thickness.

   Open the level’s Tools → Advanced editors → Paths and the Track card for this rail. The scripted example below uses Width 1 and Subdivisions 8.

For this example, create three empty GameObjects named Start, Middle and End. Set their world positions to (0, 2, 0), (4, 3, 0) and (8, 2, 0). Assign them to the script’s Anchors array in that order. Place the markers clear of the terrain.

The actual rail includes end pearls, posts, arches and curls. Decoration that would intersect the ground is shortened or omitted automatically.

Rail settings

C# example: spawn a rail

1. Add RailSpawner.

   Download the script, add it to a GameObject and assign the scene’s configured QuickTile component to Level.

2. Assign the markers.

   Set Anchors to Start, Middle and End, in route order. Set Width to 1 and Subdivisions to 8. Two markers also work for a straight rail.

3. Create it.

   Choose Spawn rail from the component’s context menu, connect Spawn to a UI button, or call spawner.Spawn() from your game script.

Download RailSpawner.cs

using UnityEngine;
using Bekkoloco.QuickTile;

public class RailSpawner : MonoBehaviour
{
    public QuickTilemapEditor level;
    // Assign at least two markers, in route order.
    public Transform[] anchors;
    // At Scale x1: bar diameter = width * 0.20 metres.
    [Range(0.05f, 10f)] public float width = 1f;
    [Range(1, 20)] public int subdivisions = 8;

    [ContextMenu("Spawn rail")]
    public void Spawn()
    {
        if (level == null || level.targetTilemap == null ||
            anchors == null || anchors.Length < 2)
        {
            Debug.LogWarning("Assign a configured level and at least two markers.", this);
            return;
        }
        foreach (var anchor in anchors)
        {
            if (anchor == null)
            {
                Debug.LogWarning("Assign every marker before spawning.", this);
                return;
            }
        }
        for (int i = 1; i < anchors.Length; i++)
        {
            if ((anchors[i].position - anchors[i - 1].position).sqrMagnitude
                < 0.0001f)
            {
                Debug.LogWarning("Separate consecutive markers.", this);
                return;
            }
        }

        var path = QuickTilemapEditor.CreateDefaultPath(
            QuickTilemapEditor.PathType.Track, null);
        path.trackStyle = TrackStyle.Rail;
        path.enableTrackMesh = true;
        path.trackWidth = Mathf.Clamp(width, 0.05f, 10f);
        path.trackSubdivisions = Mathf.Clamp(subdivisions, 1, 20);

        for (int i = 0; i < anchors.Length; i++)
        {
            // Preserves world XYZ; free rail points do not snap to terrain.
            level.InsertPathWorldPoint(path, i, anchors[i].position);
        }

        int pathIndex = level.InsertAuthoredPath(path);
        level.RebuildPathMesh(pathIndex);
    }
}

1. Choose Water and draw a river.

   Drag on the terrain. Release to select the stroke. New strokes use organic banks.

2. Move and resize it.

   Drag the white cross to move the stroke. Its side arrow changes the width; the depth, bank and water-drop handles adjust the riverbed and surface.

3. Draw a lake.

   Close the water contour. When Make a lake? appears in the scene, choose Yes to fill its interior.

Continue the flow downhill

With Auto Water enabled in the scene settings, an open river outlet can generate a waterfall. The sheet follows the supporting cliff until a vertical face, overhang or gap, then falls freely. A receiving surface sets its arrival height.

Let objects open the falling water

A rock, a character or any prop can part a waterfall: the falling sheet opens below it with a foam rim, in the Scene view and in Play.

1. Add the component.

   Select the object in the Hierarchy and choose Add Component → QuickTile → Water → Waterfall Interactor. No collider is needed.

2. Fit the sphere.

   Set Radius so the cyan gizmo sphere covers the object. Use Center Local to move it, for example up to a character’s chest.

3. Place it in the fall.

   The sheet opens from the top of the sphere down to the bottom of the fall. Set Radius to 0 or disable the component to close it again.

C# example: Open waterfalls around objects

The interactor works in Edit mode and in builds. Setting its properties republishes the opening at once.

using UnityEngine;
using Bekkoloco.QuickTile;

public class WaterfallObstacle : MonoBehaviour
{
    // e.g. a character's chest
    public Vector3 center = new Vector3(0f, 1f, 0f);
    // before the object's scale; 0 closes the opening
    public float radius = 0.6f;

    void Awake()
    {
        // One interactor per GameObject: reuse it if the prefab already
        // has one.
        if (!TryGetComponent(out QuickTileWaterfallInteractor obstacle))
            obstacle = gameObject.AddComponent<QuickTileWaterfallInteractor>();
        obstacle.CenterLocal = center;
        obstacle.Radius = radius;
    }

    // At most QuickTileWaterfallInteractor.MaxInteractors (4) are active
    // in the scene.
    public static int ActiveCount =>
        QuickTileWaterfallInteractor.PublishedInteractorCount;
}

Water islands

A water island is a painted block of water. Select it and use its round Bed control to show or hide the sand and pebble bed.

The Current control switches the current on or off without changing the outline or waves. Loop closes or reopens an eligible river. Choose Water again when you want to start another drawing.

River and Waterfall in More are construction path types. Select the path in the Unity Inspector and click Edit water materials to open its theme’s Liquids settings. These examples use the theme’s provided water and waterfall materials. Use the main Water tool for editable water strokes, organic banks and lake contours.

1. Choose More → Flowers.

   Drag on a ground surface that has flower species configured in its texture palette.

2. Release to select the garden.

   Drag the white cross to move the whole patch. Drag its side arrow to change the stroke’s width.

3. Draw another patch.

   Choose Flowers again to start a new stroke. Save the level to keep its flower arrangement.

Flower species and density come from the level’s vegetation settings. The flowers use a simple leafless stem with grass shading and wind, while keeping their petals.

1. Choose Objects.

   The object palette opens beside the sidebar. Select a configured object, then click or drag to place it on a surface.

2. Adjust the object.

   The palette hint lets you click again to rotate by 45°. Select a placed object to adjust its position with the visible gizmo. Check the result from another camera angle.

3. Keep it attached to the ground.

   Objects configured to follow the terrain retain their height offset when the ground changes.

Use Erase → Objects to remove objects without removing terrain or texture paint.

Add Light Cookie Scroller to your Directional Light to animate its cloud cookie. Configure the component in the Inspector, or assign it to the script below.

1. Assign the scroller.

   Create CookieSettings.cs, add it to a GameObject and drag the Directional Light’s existing Light Cookie Scroller into its Cookie field.

2. Choose the movement and scale.

   Speed changes the scrolling direction and rate. Scale sets the cloud texture scale. The script applies these values when the scene starts.

C# example: Configure cloud shadows

Assign the existing Light Cookie Scroller on the Directional Light. This example sets the movement speed and cloud scale. These are scene settings.

using UnityEngine;
using Bekkoloco.QuickTile;

public class CookieSettings : MonoBehaviour
{
    // Assign the existing scroller on the Directional Light.
    public LightCookieScroller cookie;
    public Vector2 speed = new Vector2(0.5f, 0f);
    [Min(0.01f)] public float scale = 2f;

    void Awake()
    {
        if (cookie == null) return;
        cookie.scrollSpeed = speed;
        cookie.cloudScale = Mathf.Max(0.01f, scale);
    }
}

Click Erase on the bottom bar and choose what you want to remove. The target picker keeps an erase operation focused on the selected type.

Undo reverses the previous edit. Redo reapplies it. Switch out of Erase when you want to draw again.

1. Open Save.

   Choose New save… and enter a name, or select an existing level to update it.

2. Confirm the save.

   Click Save selected / new and wait for Saved: level name. Selecting a name alone does not save.

3. Restore a level.

   Open Load, select a level, then click Load selected. Save the current edits before loading a different level.

New level saves the current work first, then creates an empty level with the same palettes.

See the complete Unity Inspector menu to find Level, Themes, Props, Scene, In-game editor, Drawing grid and Tools.

Open QuickTile Reference for the Level 11 layout and reference settings below. QuickTile Game 1 keeps its separate initial setup and independent saved level. Keep the reference settings for your first comparison. The captures use the same setup, with separate examples added to demonstrate each tool.

Reference scene values

These values reproduce the reference scene. Keep them for your first comparison, then adjust them for your own level.

Ground, cliff and paint settings

The theme’s Ground settings control its shape and material. Ground, Cliff and Skirt texture slots can be changed independently. Texture paint layers add their own texture and blend settings. A copied surface can have an independent appearance.

Interior materials

The theme’s Dig section defines the walls and ceiling separately from the floor. Adjust the floor’s texture scale and the shader’s slope blending here when you want a different cave appearance.

Distance detail

Tools → Performance → Distance detail (prototype) is optional and off by default. Eligible terrain, built-in wood bridges and compatible vegetation use cached detail levels as they get farther from the camera. Keep the default off while comparing the original scene, then enable it to assess the result in your own level. It also needs additional mesh memory.

In edit mode, two menus sit at the top right, beside New level and Help. The style menu offers 3D; 2.5D (coming soon) is greyed in game, while the Inspector’s Level → Style still offers 2.5D (beta). The Scale menu, Scale x1 to Scale x10, is the same setting as the Inspector’s Drawing grid → Scale.

Scale xN zooms the whole level: tiles, dirt paths and their ramps, raised paths, bridges, texture density. Path widths, lengths and heights keep the values you set: they are read at Scale x1 and multiplied. The Terrain brush preview always covers the cells you paint.

On the Directional Light, Light Cookie Scroller controls the moving cloud shadows. Its Scroll Speed and Cloud Scale settings can also be changed from a script. See the light-cookie example.

C# example: Change the level scale from your own UI

With the ingame editor in the scene, call the toolbar so its Scale menu stays in sync. Without it, set the scale on the QuickTile component and apply it. Neither records an Undo step.

using UnityEngine;
using Bekkoloco.QuickTile;

public class LevelZoomButtons : MonoBehaviour
{
    // the ingame editor's toolbar, if any
    public QuickTileRuntimeToolbar toolbar;
    public QuickTilemapEditor level;          // the QuickTile component

    // Hook to a UI Button with an int argument (1 to 10).
    public void ZoomTo(int scale)
    {
        scale = Mathf.Clamp(scale, 1, 10);
        if (toolbar != null) { toolbar.SetGridScale(scale); return; }
        if (level == null || level.gridScale == scale) return;
        level.gridScale = scale;
        // rebuilds terrain, paths and bridges at the new scale
        level.ApplyGridScale();
    }

    // 1 at Scale x1, N at Scale xN. A Grid scaled by hand with Scale x1
    // still reads 1.
    public float Zoom => level != null ? Mathf.Max(1, level.gridScale) : 1f;
}

If a tool does not respond

Check that the scene is in In-game Editor mode, close the Help panel, leave Erase, and select the intended tool again. For a blocked dig operation, check the theme’s Can be dug permission.

If a save is missing

Return to Save, choose a name, confirm and wait for Saved:. A Failed: message means the operation did not complete. In Unity, also check Keep Levels After Play and the Console for an import error.

Need help with your setup? Join the BEKKOLOCO Discord and share the function and result you are trying to achieve.

At rest, a QuickTile level costs rendering, not scripts. On a large test level (565 terrain cells, 20 paths, a river and 44,600 plants), one frame drew about 725 draw calls and 300,000 triangles, while all QuickTile scripts together took under 1 ms. Start with the render settings below; check each change by eye, because they change the image.

The demo pipeline is created by Tools → QuickTile → In-Game → Generate Complete Demo Scene or Apply Meadow Render Quality. Running either again resets its shadow cascades and distance to 2 and 60 m.

Editing while playing

Editing gestures rebuild geometry, so they cost more than a frame. On the test level: painting or erasing a terrain cell 0.3–0.4 s, digging a cube 0.6–0.9 s, releasing a stroke next to a river 2–2.5 s, switching an island to or from water 1.6–3.6 s. Loading a large level took 5–8 s: show a loading message around level loads.

Heavy and light geometry

Wooden rope bridges are detailed: on the test level, six of them held about half of the level’s triangles. Use them where the camera comes close. Dirt-path ramps keep only the rows their shape needs: on three test ramps the redesign went from 7,542 to 2,335 triangles and rebuilt twice as fast.

To measure your own scene, open Tools → Performance → Performance probe in the QuickTile Inspector and tick Show overlay, or Log reports to print them to the Console.

C# example: Switch to gameplay mode

Set the level to gameplay mode and turn off Distance detail. Use SetGeometryLods rather than changing the field: it also clears cached detail levels and rebuilds.

using UnityEngine;
using Bekkoloco.QuickTile;

public class PlayOnlyLevel : MonoBehaviour
{
    public QuickTilemapEditor quickTile;

    void Start()
    {
        // Same as "When playing" = "In-game": no editing tools, minimap
        // or handles.
        quickTile.RuntimeMode = QuickTilemapEditor.RuntimeUsage.InGame;

        // Keep Distance detail off.
        if (quickTile.enableGeometryLods)
            quickTile.SetGeometryLods(false);
    }
}

Use the Bekkoloco.QuickTile namespace. Create a C# file with the same name as the example, add its component to a GameObject, and assign the referenced components in the Inspector.

Choose an example below. Each one links back to the tool or setting it controls.