Editing widgets — one menu, one edit mode

Turn on Edit board and point at a widget to reveal its ⋯ menu, drag handle and resize corners. Open Edit widget for a real settings dialog with a live preview. Turn edit mode off and your board is a clean poster again.

Everything on a board is a widget, and every widget can be inspected, moved, resized and restyled. You never have to guess what something is, where its numbers come from, or how to shift it two columns to the left.

Edit board — the switch for all of it

A board has two modes. Reading your board (the default) shows a clean poster — no menus, no handles, no resize corners, just your widgets doing their thing (habit ticks still tick, links still open, view rows still work). Editing your board reveals everything you need to rearrange it.

Turn edit mode on with the pencil button at the end of the board's tab strip (hover it and it says Edit), or the Edit board row in the board menu. The pencil stays lit while you're editing — press it again (or Esc) when you're finished, and the board goes back to being a clean poster. Adding a new widget with the + button beside it turns edit mode on automatically, since you'll usually want to nudge the new arrival into place.

Both buttons sit outside the tab strip's scroll, so however many boards you have, Add and Edit are always where you left them.

Edit mode doesn't light up all thirty widgets at once. Point at a widget and its own controls appear — the ⋯ menu, the ⋮⋮ drag handle, the resize edges, its outline — and they fade again when you move on, so you can still see the board you're editing. Whatever you're dragging keeps its controls until you let go. On a touchscreen there's no pointer to follow, so every widget keeps its controls visible while you're editing.

The ⋯ menu — three items, nothing more

In edit mode, the widget you're pointing at shows exactly one ⋯ chip, and its menu is deliberately short:

Edit widget — the settings dialog below. Every widget has one.
Edit JSON — opens that widget's own settings dialog straight to its JSON tab.
Remove from dashboard — takes it off the board (the chart stays in your library).

Everything that used to live in this menu — width and size presets, In-a-card/Flat, which section a widget belongs to, how dense an embedded list is, opening the collection or view behind it, duplicating a widget, deleting it for good — now lives inside Edit widget itself, one click deeper but never hunted for in a long list. "Where's this data from?" moved to the board's own menu, since it was never really about one widget. See below for exactly where each setting ended up.

A container (a box that holds other widgets) works the same way, but its own ⋯ hangs off a small labelled "⋯ Container" tab on the frame itself, so it never competes with a child widget's own chip for the same corner.

Edit widget — one dialog for every type, and everything lives in it

Edit widget opens the same kind of dialog whatever you clicked — a chart, a heading, a picture, a container, an embedded list, a pinned entry. The dialog is a fixed size, so switching tabs never makes it jump around. A chip at the top names exactly what you're looking at — "Habit calendar", "Container", "View embed" — and if there's a collection, view or entry behind it, a small link next to the title jumps straight to it. Your settings are on the left, a live preview on the right that shows exactly what the board itself shows, at the board's real size and theme, scaled down to fit — updating as you change things. A container previews with the widgets inside it, arranged the way the board arranges them, so switching it between Stack and Grid is something you watch happen before you save. Three tabs, and the rule is simple: anything the widget does is reachable from one of these tabs.

Settings — everything about what this widget is, top to bottom: first what's specific to its type, then Size (width and height, with one-click suggested sizes), On phones (half width, full width, or hidden), and finally Duplicate and Delete. Charts get their full builder here — what they count, the date range, filters, colours — so there's no second dialog to go looking for. A picture gets which collection it watches, the picture itself, when it changes (rules that swap the picture as your data moves — see Pictures), and how it fits and is aligned. A panel gets the tiles — the icons, text and pictures — that make it up. Text gets its words, the values those words can read — including which entry each value comes from, so a widget can show a different quote every day (see Which entry a value reads) — and a smaller second line underneath. A divider gets its colour. A container lists what's inside it: every widget in the frame, by name, each one click away from its own settings, with arrows to reorder them and a way to lift one back out onto the board — and once you're editing one of those, a back link in the top-left corner, named for the frame, takes you straight back to the container (it's there whenever a widget lives in a container, however you opened it). An embedded list gets which view (and, when a global collection holds several, which of its saved views this slot shows), how much room this cell gives it, and the view's own layout. A pinned entry card gets which collection it follows, which entry (that one, Latest, or Today), and which card draws it.
Style — the same style controls on every kind: Type (which of your theme's fonts the widget's words are set in, and a separate one for its title), margin and padding, background (colour, gradient, texture, or a picture with a wash over it), border, corner radius, shadow, glow, accent colour, a Frame toggle (In a card / Flat), where the content sits in a tall cell, Content scale (shrink or grow everything inside the widget without changing how much space it takes up on the board), and the title bar — plus a picker for any named board style you've set up.

Every control shows the value the widget actually renders with, not just the ones you set on this widget: if a value comes from the board's default or from a named board style, you'll see the real value with a line saying where it came from, and changing it here overrides it for this widget only. Once a value is the widget's own, a small Reset appears to hand it back. Presets and numbers are two ways of saying the same thing — click Tight and the number box moves with it. And if the widget's JSON holds something the form can't express, the form says so by name ("Also set in JSON: corners") instead of quietly throwing it away the next time you touch that control.

If the widget wears a designed skin, a Custom look section shows it's there, lets you jump to its source, and remove it. See Designing boards for what each knob does.
JSON — the whole widget written out in full: settings, style, size and (if it has one) its skin, all in one document. Every kind gets this tab now, including embedded lists and pinned entries.

An embedded list: this slot, and the view itself

An embedded list's Settings tab is split in two on purpose, because the two halves belong to different things.

This slot is this board's business: the Shape (rows, a table, or a gallery of pictures), how full each row is, Entries — the most entries this cell draws, which is a cap on entries, not a count of rows — and whether the cell has room for a title bar.

This view's layout is the view itself, badged as shared, because the same saved view can sit on several boards and they all follow it. Here you get the view's real layout controls, the same ones its own settings offer: scale, padding, row height, text colour, checkbox look, and whatever suits how it's drawn. Shown as a gallery, that's the picture lattice:

Columns — at most this many across.
Card width — the narrowest a card is allowed to be. Squeeze the widget and the gallery drops to fewer columns rather than shrinking your pictures to stamps.
Rows — how many rows fill the height this widget has. Anything past them scrolls, and no entry is ever hidden.
Gap, Corner radius, Aspect, Image fit and Caption for the rest of the look. (Set Rows and the aspect stands down — the row height decides how tall a card is.)

The gallery controls show up whenever the slot draws a gallery, even if the view itself is a plain list or feed. What's on screen is what you can change.

Edit view… is still there for everything else the view owns — its filters, sorts and which fields show.

The forms and the JSON are two views of one thing, live in both directions. Change the bar colour in the form and you'll watch the colour appear in the JSON tab; type a value into the JSON and the form and the preview follow as you type. If you type something invalid, you get an inline note and your work is kept — nothing is thrown away.

Moving and resizing — edit mode only

Drag handle. In edit mode, the widget under your pointer shows a ⋮⋮ handle — grab that to move it. Dragging is deliberately not "grab the card anywhere", because your cards can carry their own tap actions and a checkbox has to stay tappable.
Corner resize. Pull the bottom-right corner; the right and bottom edges resize in one direction only. It snaps to whole grid cells, and it stops at the smallest and largest sizes that type of widget can still look good at.
The card follows the landing spot, not your cursor. While you drag, the widget sits on the dashed outline showing where it will land, lifted just enough to read the outline underneath — so you're always looking at the result — including on a Compact board, which floats that spot back up while you're still moving.
Everything makes way. Drop a widget onto another one and the board rearranges around it. On a Free board — the default — the widget you landed on moves into the space you just left, so the two simply swap and the rest of the board stays put. On a Compact board the drop slots in and everything below shifts along, then floats up to close any gaps.
Resizing always works. Pull an edge or the corner and the neighbours move out of the way — even on a board so full there's no free space to grow into. Nothing is ever refused for lack of room.
Gaps: your call. Board settings → Layout is the only switch: Free keeps the gaps you leave, Compact closes them for you. Widgets can never overlap either way.
Drop into a container. Drag a widget over a container and it highlights; let go and the widget joins it. Drag it back out to return it to the board. Widgets inside a stacked container reorder by dragging.
Undo. Every move and resize is instant and offline-safe, with an Undo on the toast that restores the whole arrangement, not just the widget you touched. Esc cancels a drag in progress — press it again with nothing in progress and it exits edit mode entirely.

None of this is reachable outside edit mode, on purpose — a board you're just reading can't be nudged by accident.

One Add widget picker

The + button at the end of the board tabs (and Add widget in the board menu) opens one searchable picker: Chart, List / View, Entry card, Heading, Text, Image, Divider, Panel, Container, or From your chart library. Pick one and you land in the right editor with a live preview.

A new widget lands at the end of the board at a good default size for its type — so adding something never disturbs what you've already arranged. On a Compact board it then tucks itself up into the first space that fits.

Phone layout

Boards reflow automatically on phones: reading order, wide widgets full width, narrow ones half, containers travelling whole. To take control, open Board menu → Phone layout… — the board rendered at phone size, editable:

Drag a card to change the phone order.
Half / Full switches its phone width.
Hide removes it from phones; hidden widgets wait in a tray so you can bring them back.

The same three settings live in the On phones section of a widget's Edit dialog. Either way, only the phone view is written — your computer layout can't be changed from there, which is why the two never drift apart.

The Board data panel

Board menu → Board data… lists every data source on the board in one place: each widget with its collection or view, its row limit, and its live count — plus health notes like "Limit hides 15 rows" or "View not found" so surprises explain themselves.

The board menu

One menu for the whole board: Rename, Change icon, Add widget, Edit board (or Done editing, while you're already in edit mode), Board data… (the "where's this data from?" view across every widget on the board), Phone layout…, Board settings… (layout, background, gradients, the board's own theme, skins), Edit board with AI, Edit dashboard (JSON), New dashboard (starting another board is a thing you do to your set of boards, so it lives here rather than as a second + on the strip), Move left / right, Delete. There's no Tidy up — a Compact board closes ranks by itself, and a Free board keeps the gaps on purpose.

Two ways to edit, one truth

Everything the clicks write, the JSON shows — and everything the JSON writes, the clicks reflect, live. The dialogs cover the common options; Edit in JSON and Edit dashboard (JSON) are always one click away for everything else, strictly validated with inline errors so a typo can't wreck a board.