boxblock wiki

#contents

• getting started
• movement, camera, and controls
• blocks, materials, colors, and shuffle
• tools
• clipboard and blueprints
• stamps
• worlds and save data
• tpll
• settings and customization
• import, export, and sharing
• interface appendix
• power-user patterns

#getting started

boxblock is a browser-based 3d voxel modeller. you move through the world in first person, place and erase blocks directly in space, and switch to specialized tools when you need fills, lines, ellipses, movement, copy/paste, terrain sculpting, or georeferenced tpll chains.

the default experience is simple enough to start building immediately, but almost every major system also has submodes, hold behaviors, and workflow shortcuts.

#the basic loop

1. create a new world or load an existing one.
2. choose a block size, material, color, and optional stamp.
3. place, erase, or paint directly in first person.
4. switch to a structural tool when you need volume, symmetry, duplication, terrain work, or georeferenced footprints.
5. let the active world autosave locally, or export the result when you need a file.

#what the app remembers

some data belongs to the current world, and some data belongs to the browser app as a whole.

world-level data includes:

• placed blocks and terrain edits
• heightmap regeneration data when the world was created from a heightmap
• the current world name
• tpll history and related world-space anchors

app-level local data includes:

• saved local worlds
• saved blueprints
• stamps and stamp folders
• palette edits and saved colors
• shuffle presets
• hotkey edits
• settings

#the fastest way to get comfortable

if you are new to the app, the most useful things to learn first are:

• how first-person building and pointer lock work
• how to switch into top-down mode with shift+tab
• how fill, line, and paste turn small work into large work
• how copy, blueprints, and stamps solve different reuse problems
• how local autosave differs from exported json and glb files

related topics:

• movement, camera, and controls
• tools
• import, export, and sharing

#movement, camera, and controls

boxblock is designed around direct world movement. even when you are using structured tools, the feel of the app comes from how quickly you can swap between moving, aiming, adjusting a preview, and committing an action.

#pointer lock and the cursor

clicking the viewport enters pointer lock so the mouse controls first-person look. esc can release pointer lock, close prompts, or cancel the current multi-step tool depending on context.

holding tab reveals the cursor so you can interact with the palette without fully leaving the building flow. n hides or shows the side panels entirely.

#first-person movement

gravity and noclip change how movement behaves. gravity keeps movement grounded, while noclip turns movement into free-flight editing.

#top-down mode

top-down mode uses its own plane controls and movement behavior.

top-down mode is best for large layouts, exact layer work, repeated paste placement, and keeping long straight edits aligned.

#view and mode toggles

some keys do not place blocks, but they still change how you work:

#hotkeys

the defaults matter because many systems assume you can move between them quickly:

#hotkey editing

the hotkeys modal groups actions into tools, movement, and modes. available actions:

• change one binding
• unbind one binding
• reset one binding
• reset every binding

the modal also marks binding conflicts visually.

#blocks, materials, colors, and shuffle

before you think about specialized tools, it helps to understand the “building state” you are carrying at any moment. box size, material, color, shuffle state, and active stamp together determine what new blocks look like and how some editing actions behave.

#block sizes

small blocks can carve into larger ones. when neighboring blocks fully fill a larger cell with the same appearance, the app can merge them back up for performance. size affects editing resolution and how block data can collapse back into larger forms.

#materials

m cycles materials forward and shift+m cycles backward. leafy and plant-heavy scenes are also affected by the bushiness setting, so material and rendering settings can overlap.

#colors and the main palette

the main swatch grid is the default palette. it is the fastest way to switch between common colors, and the color picker covers custom tones beyond the swatches.

common color actions:

• e cycles palette colors forward
• shift+e cycles backward
• r chooses a random color immediately
• q can sample color from a block in the world

#define palette and saved colors

the palette system is editable. the define palette modal manages persistent palette data and custom swatches.

you can:

• export palette json
• import palette json
• add a swatch
• delete all swatches
• reset the default palette
• delete an individual swatch by double-clicking its hex entry

this is a global creative preference system, not a per-world color bank.

#shuffle mode

shuffle mode randomizes placement colors from a chosen subset. it is useful when you want variation without manually switching colors after every block.

core shuffle controls:

• k toggles shuffle mode
• edit shuffle enters shuffle set editing
• add all includes every visible palette color
• remove all clears the current shuffle set

while editing a shuffle set:

• clicking or dragging across swatches includes or excludes them
• six shuffle slots appear
• clicking a filled slot loads that saved set
• saving to a slot makes the set reusable later
• a deletion gesture can clear a saved slot

if restrict r key to shuffle set is enabled, random-color actions use the shuffle set even when shuffle mode itself is off.

#the active stamp slot

the stamp preview under the block-size controls is the currently armed stamp slot. it matters because stamps can become part of normal placement and because paint has a stamp mode.

the slot supports two main actions:

• click the preview to open the stamp library
• click the small x to clear the active stamp

related topics:

• stamps
• tools

#tools

tools cover single-block edits, region selections, path work, and previewed volumes before commit.

#placing and erasing

the app starts in a combined place/erase workflow by default. when combined place/erase is enabled:

• rmb places
• lmb erases

if that setting is turned off, place, erase, and paint become more distinct toolbar states.

fast repeat behavior is controlled by settings:

• fast mode (hold) enables held repetition
• fast mode delay controls how long it takes to start repeating
• fast mode speed controls the repeat rate

this makes simple placement feel immediate at first, then automatable when you hold the button down.

#paint

paint is the appearance-editing tool. at its simplest, it recolors blocks. depending on the active mode and settings, it can also apply stamps or change material.

default paint behavior:

• applies the current color
• optionally also applies the current material if paint also sets material is enabled

paint submodes cycle with h:

paint also has a spread system. [ and ] change spread from 0 to 2.5, widening the brush footprint.

connected paint uses the same family logic as connected delete:

• x runs connected paint on the aimed cluster
• shift+x uses looser matching

if hold paint tool is enabled, paint can remain armed after one-shot paint actions.

#pick

pick copies the aimed block’s building state into your current selection. in normal use, q picks:

• block size
• color
• material

variants:

• shift+q picks color only
• while fill is armed, q runs planar flood from the aimed cell

pick is one of the fastest ways to stay in flow because it lets the world itself become the palette.

#move

move is a selection-to-ghost workflow for relocating or reusing existing structure.

basic move flow:

1. enter move mode
2. set the first corner
3. set the second corner to define the selection

once the selection becomes a move ghost, you can:

move can hand off its current bounds into fill or paint.

#fill

fill is one of the deepest tools in the app. it starts as a region tool, but it can place, erase, paint, planar flood, extrude, and either optimize blocks or regenerate heightmap terrain depending on the world.

basic fill flow:

1. set pos1
2. aim pos2
3. commit with f, enter, or the mouse

fill submodes cycle with h:

while fill is armed:

fill also interacts with settings:

• hold fill tool keeps the tool armed after apply
• remember last operation restores the last fill submode
• extrude paints new blocks changes how newly created extrude output inherits appearance

fill is one of the main structure-building tools in the app.

#line

line draws structural paths. it is useful for walls, traces, guide edges, footprints, wires, pipes, and face-to-face trusses.

line has four real modes:

wire is the visual cable mode. it uses exact ray hit points instead of snapped block cells, supports multi-point runs, and creates smooth tube geometry with the current color, material, and active stamp. wires are visual-only: they save with the world and export to glb, but they do not collide with the player and are not included in clipboard copy, move clipboard, paste, or blueprints.

truss is the structural mode. it creates one solid bridge at a time, keeps it as world geometry after placement, and accepts full and half block faces. truss picks reach up to 200 blocks.

single and chain use the curved-segment controls:

wire mode uses exact-point controls:

truss mode changes the input layer:

pick is truss- and wire-aware. picking a truss reopens line in truss mode and carries over that truss inset. picking a wire reopens line in wire mode and carries over its width, droop, material, color, and stamp.

paint and erase work on wires as whole objects. painting changes the wire appearance in one undoable action. erase/delete removes the whole wire in one undoable action.

if remember last operation is enabled, line remembers whether you last used single, chain, wire, or truss. if hold line tool is enabled, line, wire, and truss placement stay armed after commit.

#ellipse

ellipse is the curved-volume tool. it can make domes, spheres, and cylinders in either shell or frame form.

h cycles through six current states:

while ellipse is armed:

if remember last operation is enabled, ellipse remembers the last state you used.

#copy

copy turns part of the world into clipboard data. it is the gateway to paste and also the basis of blueprints.

copy flow:

1. set corner 1
2. aim corner 2
3. commit the copy

while defining the copy region:

• arrow keys expand in x/z
• shift+up/down changes height
• the tool modifier increases the step size

#paste

paste reuses the current clipboard as a movable preview. it is one of the highest-leverage tools in the app because it can repeat, reorient, and relocate structure very quickly.

default paste controls:

top-down paste adds more explicit plane movement:

paste also respects settings:

• hold paste tool keeps paste armed after commit
• repeat preview shows both repeat count and direction

#terrain sculpt

terrain sculpt is the brush system for reshaping terrain-like forms more organically than fill or line. it is armed with 9 or the erode toolbar button.

brushes cycle with h:

extra controls:

• [ and ] change spread from 0 to 4
• holding tool input repeats the sculpt action
• simpler erode tool reduces sculpt complexity

#place under and exact y

u is a vertical support tool. by default it:

• places a support block directly under you
• snaps you on top of it
• can be held to keep extending upward

shift+u opens the y prompt for an exact support height.

#debug face

/ opens the aimed-face debug tool. it is mainly a utility for inspecting face information, but it is still player-facing and useful when you need to understand what surface the app thinks you are aiming at.

#connected actions

x is one of the most context-sensitive inputs in boxblock.

connected actions are stamp-aware, so they do not only think in terms of raw geometry.

related topics:

• clipboard and blueprints
• stamps
• power-user patterns

#clipboard and blueprints

clipboard data and blueprints solve the “reuse this thing again” problem, but they are not the same feature.

#clipboard

the clipboard is temporary structure data captured by copy. paste depends on it. if you copy a new region, the clipboard changes.

the clipboard is your current working duplicate.

clipboard copy can include trusses as well as blocks. trusses are copied when both of their endpoints are inside the copied region. wires are intentionally not copied into the clipboard.

#blueprints

blueprints are saved clipboard snapshots for reusable assemblies.

typical blueprint flow:

1. copy a region into the clipboard
2. open blueprints
3. name it
4. press save clipboard
5. later load that blueprint back into the clipboard and paste it wherever you want

blueprint modal actions:

blueprints keep trusses too, not just placed blocks. wires stay world-level geometry and are not saved into blueprints.

#blueprints vs worlds vs stamps

these three systems all preserve creative work, but they preserve different kinds of work:

related topics:

• tools
• stamps
• import, export, and sharing

#stamps

stamps are one of boxblock’s most important advanced systems. they are texture-like overlays that can be attached to block faces, used during painting, edited inside the app, organized into folders, and moved between libraries through zip export and import.

#what stamps change

stamps matter in normal play in three main ways:

• the active stamp slot in the left palette
• paint stamp mode
• saved and exported block, truss, and wire appearance

new trusses and wires use the current color, material, and active stamp. later, paint and pick can change or sample their appearance the same way they do for other build surfaces.

stamps are part of how block, truss, and wire appearance is defined.

#the stamp library

the stamp library is the browsing and management layer for stamps. you can open it from the toolbar or from the active stamp preview in the left palette.

the library supports:

• folders
• drag-and-drop organization
• bulk selection
• duplication
• deletion of custom stamps
• zip import
• zip export
• image upload
• creation of new custom stamps

bulk actions include:

#built-in stamps and custom stamps

built-in stamps are there to use directly. custom stamps are the editable layer. that distinction matters because custom stamps can be moved, deleted, duplicated, and reorganized in ways that built-ins cannot.

#the active stamp

the active stamp is mirrored in two places:

• the active stamp chip in the stamps modal
• the stamp preview under the block-size controls in the left palette

arming a stamp does not automatically place anything. it changes what placement and paint can do next.

#the stamp editor

the stamp editor is split into three broad work areas:

top-level editor actions:

#drawing modes and editor tools

stamp editor drawing modes:

stamp editor tools:

spray also has uniform and additive toggles. uniform makes the spray distribution even, while additive lets repeated passes hit the same pixel during one stroke. q still works as the editor eyedropper. it picks from the stamp surface and then returns to the last active editor tool.

editor history and transforms:

#color controls

the editor’s color card includes:

• direct color input
• hue slider
• saturation slider
• lightness slider
• opacity slider
• recent-color strip

in rebalance, those sliders become temporary adjustment controls instead of brush-color controls:

• hue becomes a centered hue shift
• saturation becomes a centered saturation shift
• lightness becomes a centered lightness shift
• contrast appears as a centered contrast shift
• opacity becomes a centered alpha shift from -100 to 100

rebalance affects only visible pixels on the active stamp surface. negative opacity fades existing alpha down toward transparent, and positive opacity pushes it up toward opaque. apply commits the preview as one undo step, and reset discards it.

#material blend

material blend controls how the saved stamp mixes with the block color and material underneath it. it is stored as stamp metadata, so changing it does not rewrite the stamp pixels. existing blocks using that stamp, future placements, and glb export all use the selected blend.

available material blend modes match the crop blend set:

• normal
• multiply
• screen
• overlay
• darken
• lighten
• color dodge
• color burn
• hard light
• soft light
• difference
• exclusion
• hue
• saturation
• color
• luminosity

#placement modes

placement mode controls how the stamp is used on block faces.

important rules:

• directional is only directly editable in standard
• half grid is only available for standard
• trim swaps the left side into a center fill tile, a top-left trim 8x8 editor, and a read-only mirrored 16x16 preview
• mirror 3x3 is hidden in combo
• combo replaces the normal tile view with a face-map workflow

second-texture behavior:

the second-texture picker includes search, folder navigation, preview, and clear actions.

#trim mode

trim is the connected-border placement. it is for outlines, wrapped borders, and trims that should react to neighboring faces instead of behaving like a normal repeating tile.

trim editor layout:

trim authoring rules:

• paint center fill when you want to change the face interior
• paint top-left trim 8x8 when you want to change the border and corner art
• boxblock mirrors and rotates that 8x8 corner into the other three corners automatically
• draw modes and tools are shared, and whichever trim canvas you click receives the paint action
• trim history and transform actions stay in sync, so undo, redo, clear, invert, cw, ccw, flip h, and flip v operate on the trim editor state together
• clearing the trim corner back to the base corner effectively removes the trim
• upload image and crop still target the center fill tile
• runtime rendering, atlas baking, and glb export all use the same generated trim result

trim limitations:

#half grid, directional behavior, and combo faces

these options control how stamps tile and orient on block faces.

key ideas:

• half grid scales a standard stamp into a half-grid repeat pattern
• mirror 3x3 changes how tiling preview mirrors
• directional changes whether orientation matters
• combo stamps replace single-tile logic with a 3x3 face workflow
• import faces from library is specific to combo stamps

#imported images and crop workflow

importing an image opens the crop panel, where you decide how an external image maps into stamp space.

crop controls:

blend modes:

• normal
• multiply
• screen
• overlay
• darken
• lighten
• color dodge
• color burn
• hard light
• soft light
• difference
• exclusion
• hue
• saturation
• color
• luminosity

#stamp import and export

the stamp system supports both one-off image import and full library transfer.

zip export is the right path when you want to move a stamp library, archive it, or edit folder-backed stamp data outside the running app.

zip import and export keep placement metadata too, so trim stamps carry both the center fill tile and the authored trim-corner data.

related topics:

• blocks, materials, colors, and shuffle
• import, export, and sharing

#worlds and save data

worlds are the main container for building data in boxblock. every block, truss, or wire you place, erase, paint, save, or export belongs to the active world.

#local worlds and autosave

the active world lives in browser-local storage and autosaves while it is dirty. if you close and reopen the app later on the same machine and browser profile, your local worlds can still be there.

the save button downloads the current world as a json file for backup, transfer, or manual archiving. the worlds modal manages worlds already stored in the browser. world data includes trusses and wires along with normal block edits.

#creating a world

the new-world flow supports three world types:

world creation is also where you set some important starting values:

• flat worlds let you choose a starting ground color
• heightmap worlds let you choose the source image, max height, and terrain color
• tpll scale in the other section controls the meters-to-blocks conversion that future tpll projection uses in that world

#heightmap worlds

heightmap worlds create terrain from an imported grayscale image, with darker values producing lower terrain and lighter values producing higher terrain.

important rules:

• heightmap input is capped at 512 x 512
• the source image should be grayscale
• the world stores regeneration data so the terrain can be rebuilt later through fill regen

heightmap worlds are useful when you want terrain based on an imported source image.

#terrain regeneration

terrain regeneration is a world feature used by heightmap worlds. when a world has saved heightmap regen data, fill mode can rebuild terrain inside a selection.

fill z behavior depends on the world:

• heightmap worlds restore terrain from the saved heightmap data
• flat and void worlds optimize blocks inside the selected area instead of regenerating terrain

this matters because terrain edits are otherwise just normal edits. once you carve, paint, smooth, or build into terrain, the heightmap regen system is what remembers what “original terrain” means for that world, while non-heightmap worlds use the same shortcut for block optimization.

#managing local worlds

the worlds modal is the local world manager. available actions:

• create a new world
• import one or more world json files into local storage
• load a stored world
• rename a stored world
• export a stored world as json
• delete a non-active stored world

related topics:

• clipboard and blueprints
• tpll
• import, export, and sharing

#tpll

tpll is the app’s coordinate-chain workflow. it takes geographic input, projects it into the current world, keeps a chain of reference points, and can draw a trace footprint from the placed points.

#opening tpll

\ opens the tpll prompt. opening it exits pointer lock so you can type. esc closes the prompt, and clicking outside it also closes it.

the prompt now always includes clear string. that clears the visible tpll string but keeps the internal tpll anchor, so the next pasted string can keep using the same local georeference. there is no separate hold tpll tool setting anymore.

#tpll examples

paste coordinate sequences like these. elevation is optional per point. ;x; starts a new closed segment, and ;r; starts a new open segment. those markers embed trace footprint behavior in the string.

without elevation:

47.6021623, -122.3326166, 47.6018512, -122.3333891, 47.6018295, -122.3333998, 47.6018187, -122.3323108

with elevation:

47.6021623, -122.3326166; 12.84, 47.6018512, -122.3333891; 8.37, 47.6018295, -122.3333998; 8.21, 47.6018187, -122.3323108; 10.88

multi-building without elevation:

47.6021623, -122.3326166, 47.6018512, -122.3333891, 47.6018295, -122.3333998 ;x; 47.6029020, -122.3319000, 47.6027110, -122.3321400, 47.6026400, -122.3319800

multi-building with elevation:

47.6021623, -122.3326166; 12.84, 47.6018512, -122.3333891; 8.37, 47.6018295, -122.3333998; 8.21 ;x; 47.6029020, -122.3319000; 14.10, 47.6027110, -122.3321400; 13.90, 47.6026400, -122.3319800; 14.05

open road segments:

;r; 47.6021623, -122.3326166, 47.6018512, -122.3333891 ;r; 47.6021823, -122.3325966, 47.6018712, -122.3333691

sequence behavior:

• a pasted sequence is capped at 3000 points
• large pasted strings place marker points in batches so long imports stay responsive
• one pasted string still lands as one undoable input
• elevation follows a point as lat, lon; elevation
• points with and without elevation can be mixed in one pasted string
• ;x; starts a new closed segment, which is the main way to separate buildings inside one paste
• ;r; starts a new open segment, which is useful for roads, alleys, paths, and clipped coords road exports
• strings can mix ;x; and ;r; in the same paste
• if a pasted string contains multiple ;x; segments, each ;x; segment closes itself when it has enough points to form a loop
• ;r; segments stay open at their ends
• if a single segment repeats its first point at the end, the sequence is treated as closed automatically
• for a single unbroken segment, the close checkbox can still force the closing segment
• explicit ;r; segments stay open even if close is enabled
• when ;x; or ;r; is present, segment markers matter more than the close checkbox
• ;x; and ;r; strings draw their embedded trace footprint even when trace footprint starts off

#anchoring and scaling

tpll needs a local anchor.

the main rules are:

• the first tpll point uses the player’s current position as the world anchor
• tpll scale from the new-world modal controls meters-to-blocks conversion
• if a new point is more than 10000 meters from the last tpll site, the app creates a new tpll origin site

those rules give tpll a persistent local georeference inside the world.

the intuitive way to think about tpll scale is this:

• tpll does not scale the raw latitude and longitude numbers directly
• it first turns the geographic delta from the current tpll anchor into east/north meters
• then it multiplies that meter result by tpll scale to place x and z in the world
• if your pasted point includes elevation, tpll multiplies that elevation by the same scale for vertical placement too

so at tpll scale = 1, 10 meters in the source data becomes about 10 world units. at tpll scale = 1.5, the same 10 meters becomes about 15 world units. that applies to horizontal footprint spacing, and to explicit elevation y from the string when elevation is present.

#where and coords bridge

where is available once tpll has enough anchor information to convert the current player position into real-world coordinates.

when it is available, where copies a lightweight coords deep link for the current player position to mistys.art/coords.

example:

https://mistys.art/coords#p=47.6021623,-122.3326166

opening that link loads coords, seeds a session with that point, centers the map, and opens the normal right-click popup so reverse geocoding starts immediately.

because the link is generated from your current world position through the active tpll anchor, it takes the current site and tpll scale into account. if tpll rolls into a new site after the 10000 meter limit, where follows that new site too.

#elevation, placement, and trace footprint behavior

tpll uses the input text itself as the source of explicit elevation. if an elevation is present for a point, tpll uses it. if no elevation is present for that point, tpll still projects the point and falls back to the world/player-side height logic available in the current app.

important trace footprint rules:

• arrived points can place marker blocks
• trace footprint is off by default for manual point-by-point entry
• when trace footprint is on, manual points draw from the last tpll point or anchor
• the trace footprint is drawn one block above the placed points
• the trace footprint uses half-block links between points
• reference-only points are excluded
• ;x; keeps separate buildings from stitching into one continuous footprint
• ;r; keeps road and path segments open so bounded imports do not cap themselves closed
• multi-building pasted strings auto-close their own ;x; segments
• enabling close adds the closing segment for a single unbroken segment, but not for ;r; segments
• long pasted strings stay in one workflow up to the 3000-point cap

the important idea is that the visible chain and the underlying reference are not exactly the same thing. deleting a visible reference chip does not necessarily destroy the internal geo anchor. this is what allows later pasted strings to keep continuity with an established reference unless a new world or a distance reset forces a new site.

#a typical tpll workflow

1. move the player to the area that should become the first local reference.
2. open tpll with \.
3. paste a coordinate or coordinate sequence. add ; elevation after any point that should carry explicit height, add ;x; anywhere you want a new closed building segment to begin, and add ;r; anywhere you want a new open road or path segment to begin.
4. use chips to revisit, reorder, or trim the visible chain.
5. use close when you want a single open segment forced into a loop.
6. use clear string when you want to wipe the visible string but keep the internal anchor for the next paste.
7. use where when you want to jump from the current tpll field position into coords for map-side inspection.

related topics:

• worlds and save data
• power-user patterns

#settings and customization

the right settings panel controls how boxblock looks, how quickly tools repeat, how movement feels, and how much helper information is visible. some settings are cosmetic, but many change the feel of the app significantly.

#rendering and visual aids

these settings mostly control scene readability while you build.

#tool behavior settings

this group controls repetition, persistence, and modal behavior.

#movement and physics

these settings are especially important if you use the app for long sessions. small changes can make building feel either precise and calm or fast and loose.

#terrain and foliage

#day and night

day and night settings are presentation controls, but they also affect how readable surfaces and colors feel while you work.

#helper actions

the settings panel also contains the launch points for other editor-wide customization tools:

• edit hotkeys opens the hotkeys modal
• define palette opens palette editing
• delete all local data wipes local worlds, blueprints, stamps, palettes, and settings

the delete-all-local-data action is the most destructive player-facing action in the app, because it clears both creative content and personal customization stored in the browser.

related topics:

• movement, camera, and controls
• blocks, materials, colors, and shuffle

#import, export, and sharing

boxblock has several different data paths because different creative tasks need different file formats. sometimes you want a world backup, sometimes a portable model, and sometimes just a palette or stamp library.

#choosing the right format

#world json

there are two world-json workflows:

use world json when you want editability, transfer, or backup. use local worlds when you want convenience and autosave.

world json keeps trusses and wires, so structural and cable-heavy builds can round-trip without turning those members into loose approximation blocks.

#glb export

export glb creates a glb snapshot for external tools such as blender, unity, unreal, or any other gltf/glb-capable pipeline.

glb includes truss and wire geometry too.

glb is the right choice when you want model data for external tools.

#palette json

palette json belongs to the palette system only. it does not contain worlds or stamps.

#stamp zip

stamp zip export belongs to the stamp library, not to a single world. it is the right path when you want to carry folders, stamps, and stamp metadata between copies of the app or archive a working library.

#screenshots

press the backtick key to copy a screenshot to the clipboard. the viewport confirms this with the copied! toast.

related topics:

• worlds and save data
• stamps

#interface appendix

the wiki is organized around systems and workflows, but sometimes you still need to know where something lives. this appendix is the compact interface map.

#top toolbar

#left palette

#viewport overlays

#right settings panel and status bar

the right panel contains rendering settings, tool behavior settings, movement and physics settings, day/night controls, and buttons for hotkey editing, palette editing, and the full local-data wipe.

the status bar shows:

• current player position
• current block count
• a reminder that n restores the side panels

#player-facing modals and panels

#power-user patterns

#learn the stateful tools

fill, line, ellipse, and paint all benefit from remember last operation. when that setting is on, those tools reopen in the last submode you used.

#use fill for more than box selections

fill can:

• place
• erase
• paint
• planar flood
• extrude
• optimize blocks or regenerate heightmap terrain

those modes cover a large part of terrain and structure work.

#use copy, paste, and blueprints as separate layers

copy and paste are immediate working tools. blueprints are the library layer on top of them.

#connected actions save huge amounts of time

x, shift+x, and paint-mode connected actions are worth learning early. they are especially strong when combined with stamps, because matching is more intelligent than plain geometric flood logic.

#top-down mode is a real editing mode

shift+tab changes how zoom, bracket keys, paste nudging, and plane-based placement behave. if you build large footprints, road layouts, or repeated paste structures, top-down mode is part of the core toolset.

#use place-under for vertical work

u is one of the fastest support-building tools in the app, and shift+u gives it exact-height control. it is useful for towers, scaffolding, and getting yourself to the height where the next operation should begin.

#use stamps as part of surface design

trim, pillar, facade, combo, directional, and half grid all change how a stamp behaves across block faces. those options are useful for structure and surface planning, not only decoration.

#keep file formats in their lanes

use:

• local worlds for convenience
• world json for backup and transfer
• glb for external 3d pipelines
• stamp zip for stamp libraries
• palette json for palette sharing