Designer documentation

taybl models a physical table, not a rules engine. Designers arrange components and zones; players resolve the rules themselves.

The Studio is where you build a game. Six tabs — Preview, Details, Layout, Components, Files, Publish — cover everything from playtesting the table to sharing it with players.

Every file a game holds, after it has been built. Add art in bulk, replace a file in place so every component using it updates at once, say what each file is, cut a sheet, and import the pages of a print & play PDF.

Components are the physical object types on the table — pieces, cards, dice, tokens, and sheets. One entry is one type; it is an infinite template, and copies come from setup placements and deck membership.

A piece is a physical figure — a meeple, mini, pawn, or marker. It can carry movement hints (UX-only) and a non-rectangular shape, but taybl never enforces how it moves.

A card is a component that flips between a front and a shared back. It can belong to a deck `group`, and a big unique deck can be authored compactly with `variants`.

A die is a randomiser with two or more faces. Each face has a `value` and an optional art binding; taybl rolls it but never interprets the result. Players can also set a die to a chosen face by hand, without rolling.

A token is a small generic marker you drop and leave — a chip, coin, or counter. `isResource` hints that it’s a tradeable resource; a `valueBinding` turns it into a live counter.

A sheet is a printed pad players write on rather than move — a Yahtzee score card, a D&D stat sheet, a Clue notepad. Its blanks are `statBlock` stats; the `sheet` field lays them out, either as printed rows or as fields you place yourself. A new pad gets a home automatically and opens from the table menu’s Sheets panel.

The optional refinements every component kind shares — a non-rectangular `shape`, a multi-cell `footprint`, drag `behaviors`, attachable markers, and a live `valueBinding` number.

A zone is a meaningful region that holds components — a draw pile, a hand, a board. It carries meaning and behaviour, but never a position; that lives in the layout.

A zone’s role is its semantic purpose — draw pile, hand, discard, play area, and so on. It drives the right-click menu and a few sensible defaults.

Scope decides whether a zone exists once at the table (shared) or once per seated player (perSeat) — the difference between a communal discard and each player’s own hand.

Arrangement is how a zone lays its contents out physically — a neat stack, a fanned hand, a grid of cells, a loose scatter, an open freeform surface, or a single slot.

Visibility decides who can see a zone’s contents — public, owner-only, or everyone-except-owner. It is the one thing taybl truly enforces: hidden contents are redacted server-side.

A grid turns a zone into a structured board — a chessboard, a hex map, a point-to-point network, or an open tile lattice. It pairs with role grid and arrangement grid.

A deck is a component-group of cards that share one back image. A component-group is a named set of components (any kind) with a shared back and a per-member quantity, placeable into a zone as a unit. Build them in the Component Groups panel.

A landing rule (dropPolicy) says how the first thing dropped in a space differs from the second — face up then tucked sideways, centred then in the corner. Setup placements walk the same list.

A setup variant can change what a zone IS, not just what gets dealt into it — a discard pile that rests face-up in one variation and face-down in another. Players pick the variation on the setup screen; the zone behaves that way for the whole game.

Layout is where every zone physically sits on the table, and where the seats are. It is kept separate from zone definitions so your placements survive regeneration.

Seats are the player positions around the table. Each has an index and an angle, where 0 is the far edge and 180 is the near edge. seatLocal zones rotate to each seat.

The Studio’s Layout tab is a canvas editor with three modes — Arrange (geometry), Setup (the opening sequence) and Sheet (bulk component editing) — a left browser, a right inspector, and a header toolbar for mode, phases, undo/redo, reset, and save.

Drag to move, corner handles to resize, and a handle to rotate; edges snap with alignment guides (hold Alt to disable). Marquee-select, then align, distribute, match, group, lock, duplicate, delete, or nudge.

The right-hand inspector changes with your selection: a zone, a component (with faces and a convert-kind control), a component group (a deck), a grid or graph board, the table, or a setup step.

Setup mode shows the opening as one timeline — the board-build placements first, then your authored steps — on a reorderable rail. Select an item to preview and edit it; a switcher previews each setup option.

The Layout Editor’s third mode is a spreadsheet over your whole game: a tab per component kind, plus zones, setup placements, setup steps and automation, dropdowns and checkboxes in the cells, bulk art add and replace by filename, and an Excel export that carries the tabs and dropdowns with it.

Write straight on the felt — a pile name, a track heading, a title across the board. Give the same label an automation and players can press it.

Automations are named, reusable jobs — shuffle a deck, deal hands, sweep three board cells into the discard. Setup runs some at game start; a button runs some on click. You write each one once.

Setup placements describe what is on the table when the game begins — which components start in which zones, how many, face up or down, and for which seats.

One ordered list of typed setup steps — variant, identity, pool, draft, and auto — is the authored source of truth for everything players (and the table) decide before the first turn.

Setup automation is the short sequence of steps that runs once at game start — shuffle a deck, deal opening hands, set starting properties — plus the options players pick before play begins.

Phases are an optional ordered list of staged layouts — they swap which zones are visible and where they sit as the game moves through steps like drafting or a scenario reveal. They are layout, not turn enforcement.

A selection is a click-to-pick interaction inside a phase — players choose some zones or components from a pool, and the picks drive setup distribution of components into supply zones.

A grant is the identity-assignment escape hatch on a component selection — picking a component can confer ownership and placement of it (and its property-matched siblings) onto the player who picked it.

Players read your uploaded rulebook — the table’s Rules button opens that file directly. The reference block is plain-language rules text you write by hand, and it is what players get when there is no rulebook to open.

Fill in the storefront on the Details tab — title, description, photos, buy and crowdfunding links, plus up to six custom link buttons of your own — then choose who can play from the Publish tab: private, alpha (a secret share link for playtesters), or beta (listed in the catalogue). You can keep editing afterward.

How many people play your game, for how long, how many come back, and how many finish — plus an honest account of which of those numbers are exact and which are estimates.

The play surface at a glance — a full-bleed felt with the table menu, the players, your hand and the supply floating over it. taybl is a table, not a rules engine: you resolve every rule by hand with drag and the rulebook the Rules button opens.

Zoom, pan, and fit the table to the screen; rotate the whole view 90°; rubber-band a group of components with Cmd-drag (or Shift-drag); peek at one component by resting the pointer on it; hold a key to magnify and edge-scroll; and use the table tools — pen, ruler, note pads, and the Sheets list.

Drag to move, or click a component and then click where it should go. Double-click to turn something over. Click a die to roll (a zone of nothing but dice rolls the whole tray at once), or set a die to a chosen face by hand without rolling; click a sheet to open it, click a digital timer to start or pause it, and right-click for the verb menu — flip, rotate either way, roll, set a die’s face, peek, tap, lock, inspect, duplicate, adjust a counter, tint, and remove. Plus the enlarge overlay and filling in a sheet.

Draw the top card by dragging it (or press D); deal one to every seat; shuffle by shaking a deck mid-drag. Bags draw a random item. The container inspector lets you peek, reveal, reorder, and search a pile.

Your private cards live behind the hand button in the bottom-left corner — point at it and they rise out of the bottom edge, click to pin them open. Others see only backs and counts. The supply button in the top-right corner opens the shared pools everyone draws from.

End turn advances a shared marker (taybl never forces it) and is hidden when you are playing alone; Undo steps back through the last few actions, one press at a time, and lives in the taybl menu with no keyboard shortcut. The history panel logs every move as a shared record, but only Undo takes anything back. Hot-seat mode hides the table between passes.

Talk to the other players without leaving the tab. Voice is opt-in per session, works in the waiting room as well as at the table, and connects players directly to each other rather than through taybl.

You do not need an account to play. Open any public game on your own device, or take a seat at someone else’s table from an invite link. An account is only needed to host a table or to build a game.

Pick a time to play a game and let other people sign up for it. A scheduled session has its own page and link, emails a reminder about an hour before, and becomes a real table when the host starts it.