Advanced blocks

Note: every block here is inserted from the / menu (type /, keep typing to filter, Enter to insert). The Blocks page lists all of them in one line each; this page picks up where that leaves off.

Databases & tables

Nomima has three table-shaped blocks. They look similar but come from opposite directions: one you fill in by hand, two that build themselves from data you already have.

Authored database — /table

The everyday table, where every row is a record and every column has a type. Insert it (“Table / Database”), name it in the title row, then Enter drops into the first cell. A fresh table starts with four columns — Item (text), Owner (person), Due (date), Status (status) — and three empty rows.

• Typed columns. Click a column header to set its type: plain Text, Date, Number, or any Smart Tag type (Person, Status, Project, a custom type…). In a typed column, what you type becomes a real Smart Tag pill — start typing a name and the same @/# suggestions you get in prose appear, scoped to that column's type. A column can also allow multiple entries per cell, or stay single (suggestions stop once the cell holds one pill).
• Pills index per row. Each row is its own block with its own identity, so a @person or #project in a cell is indexed against that row — it shows up in search, the Knowledge Graph and Smart Views exactly like a pill written in a task. This is the non-obvious part: a database isn't a spreadsheet island, its cells are first-class content.
• Status & completion. A row's checkbox stamps a #complete pill into its Status column (or the first cell if there's no status column) and clears any other status; unchecking strips it. Put #complete on the table title and every row completes at once.
• Totals. The calc strip under each column offers type-aware footers: Sum / Average / Min / Max on number columns, a done-count on status columns, and filled/total count on anything. A second per-row total (sum / average / filled) can run down the right edge with a grand total in the corner.
• Sorting & layout. The column menu sorts the rows in place (select-type columns sort by their defined option order — High › Normal › Low — not alphabetically). Drag a header's edge to resize a column; blanks always sort last, either direction.
• Keyboard. Tab/Shift Tab walk the cells in reading order, Enter adds a row below (pressing it on a wholly empty last row steps out under the table instead, so blanks never pile up), and ↑/↓ hop between rows and out to the title.

Pasting a table from a web page, Google Docs, Notion or Markdown drops in as an authored database automatically — the header row becomes your columns, each row a record.

Entity table (derived) — /entity-table

Not authored rows — a live view of your entities. An entity table lists every entity of one chosen type, one row per entity, and shows their attributes as an editable grid. Pick the type from the header dropdown; any Smart Tag type qualifies — Person, Company, Project, or any custom @/# type you've defined (it defaults to Person).

• Columns come from the type. The grid's columns are that type's field schema (the fields you set up for it in Settings), followed by any ad-hoc attributes that turn up in the data — so an attribute you added from an Entity card always surfaces here too. The leading name cell shows each entity's avatar (photo, favicon, or type icon) plus how many notes mention it.
• Edits round-trip. Editing a cell writes straight through to that entity's durable attribute store — the same one the Entity card and the Knowledge Graph read. Change a person's role here and the change shows on their card and everywhere else; nothing is copied into this note.
• Sort, group, filter. Sort by any field (or by name / mention-count); group rows under a field's value; and filter with attribute predicates — is, is not, contains, >, <, is set, is empty — combined with match all (AND) or match any (OR).

Query table (derived) — /query-table

The most powerful of the three, and the least obvious: a saved search whose rows are blocks. Instead of rows you type, a query table shows every block anywhere in your vault that carries the pills you filter on — and it keeps itself current as you write.

Binding it to pills. A new query table is empty. Click Add filter and pick a pill from the list (it draws from the same @/# registry the editor uses, and shows how many blocks carry each). Each filter you add is one pill — a @mention or a #hashtag. That's the whole binding: the table is “every block that has these pills”.

• All vs. Any. With two or more filters, an All / Any toggle appears. All means a block must carry every filter (AND); Any means at least one (OR). One filter needs no toggle.
• What a row is. Each row is a single matching block — a task, a paragraph, a callout, a database row, anything. It's shown with its own inline pills rendered as coloured chips, plus a glyph and name for its source notebook. Click a row to jump straight to that block in its note; tick its checkbox to mark it complete (in place, wherever it lives).
• It's live. The query re-runs whenever the vault changes and whenever you return to the window, so the table always reflects reality — add #launch to a note across the vault and it appears here on its own.
• Refinements. Scope a filter to a specific database column (“@Dana in the Owner column”) instead of anywhere in the block; add a live date window (Today, This week, Next 7 days, Overdue, This month, or a fixed range); sort (query order, newest, oldest, recently edited, open first, by notebook); hide completed blocks; or group results by notebook.

Tip: a query table filtered to #launch with hide completed on becomes a live “still open for the launch” list that never needs manual upkeep.

Dashboard & widgets

A Dashboard (/dashboard) is a live grid of small widgets that report on your whole vault; a Widget (/widget) is a single one of those you can drop anywhere in a note. Both read from the same place — the index of every block you've written (its tasks, dates, pills, notebooks) — and both refresh on their own as you work.

• What a widget can show. Each widget is one small query rendered as a visual: a big number, a ring (a share out of a total), bars, a donut, a trend line, a heatmap, a word cloud, or a list. It can count tasks, reminders, dated items, pills, notes, actions, or any block, and slice them by status, notebook, day, entity type and more.
• Adding one. On a dashboard, click a + tile in the grid; on a standalone widget, click the pencil. Either opens the widget editor in a docked panel on the right. Build it the quick way — pick when / who / topics / which notebooks — or drop into the conditions builder for exact filters, then choose a visual. A gallery of one-click presets (Overdue, Due today, Content by type, Activity heatmap, Top people, Hashtag cloud…) is there too.
• Smart Tag filters know their type. Whenever you filter by a Smart Tag — the Quick builder's who / topics pickers, or a Smart Tag condition in the conditions builder — each entry shows its entity type with its icon and label (e.g. @Alex · Person). If one name exists as several types, you can pick it per type or choose its Any type catch-all; every type also gets an “Any Person”, “Any Project” … option to match a whole type at once. A name that's unique stays a plain name filter, and widgets built before this still work unchanged.
• A fresh dashboard starts empty. The /dashboard block inserts with no widgets — add your first from the + tile in the grid (build it by hand, or drop in a one-click preset). If you want a ready-made set of vault stats without configuring anything, the standalone Stats view arrives pre-filled with a curated dashboard instead.
• Sizing. The dashboard is a four-column grid of square cells; widgets are 1×1 or 2×1. Drag widgets to rearrange them, and drag the dashboard's bottom edge to add rows (up to six). A standalone widget resizes freely from its corner, and shrinks to fit if you drop it into a narrow column.
• Title & completion. Both blocks have an editable title that accepts Smart Tags; a #complete in the title marks the block done like any other.

Kanban

A board of draggable cards (/kanban). The thing to know up front: the columns are fixed — To Do, In Progress, Done, in that order. You don't create or reorder columns, and a card's freeform tags don't decide where it sits.

• The one automation. A card is in the Done column if and only if it carries a #complete pill. Drag a card into Done and Nomima adds that pill for you; drag it back out and the pill is removed, but the card stays in whatever column you dropped it in. Equally, type #complete onto a card anywhere and it flies to Done on its own — and if you instead delete #complete from a card sitting in Done, it flies back to the column it came from. The board and your notes can therefore never disagree about what's done.
• Other tags do nothing to placement. Any other status you write on a card (#blocked, #pending…) is just a visible tag — it stays put, it doesn't move the card.
• Counts & completion. The header shows an active-of-total count. A card's checkbox marks it complete the same way the pill does. Put #complete on the board title and every card sweeps into Done at once; remove it and they all come back.
• Adding cards. Type into an empty card and press Enter (or Tab) to move on to the next authorable column — Done is never a typing target, since cards only reach it by being completed.

Gantt

A timeline of tasks with start and end dates (/gantt). The rows are authored by hand, not pulled from your tasks — a new chart arrives with three sample rows you edit or replace. There are no dependencies between tasks: each bar is simply the span between its own two dates, and moving one never shifts another.

• Two ways to set dates, always in sync. Flip the chart to Edit to get a row of fields per task — name, start, end, assignees. Or work on the bar directly in the preview: drag it to move the task, drag an edge to resize, or click an edge to pick a date from a calendar. The bar is always exactly the gap between start and end.
• Zoom. The chart rests at Fit (the whole timeline in one view). Tap Day, Week or Month for a fixed scale while you make precise edits — this zoom is transient and snaps back to Fit when your pointer leaves the chart.
• Assignees are @mentions. The assignee field uses the same people registry as the editor's @ menu: type a name and a matching, colour-coded dropdown appears; Enter or a comma adds another (the @ is optional). They render as coloured mention chips on the task. Note they live as the task's own field rather than as pills in the note body.
• Completion. A task is done via its checkbox or a #complete tag in its name; the header shows “done of total”. #complete on the chart title completes every task at once.

Mermaid diagrams

The Diagram block (/mermaid) renders Mermaid — you write the diagram in text and Nomima draws it. Mermaid covers flowcharts, sequence diagrams, class and state diagrams, entity-relationship diagrams, mind maps, its own Gantt syntax and more; whichever type you want, you write its standard Mermaid source.

• Live edit. The block toggles between Edit (a source box that opens empty, showing a graph TD; A[Start] --> B[Done] hint as ghost placeholder text until you start typing) and Preview (the rendered diagram). It redraws as the source changes and follows your light/dark theme.
• When it can't parse. Nomima first tries to quietly repair a couple of common slips (a literal \n, unquoted labels with parentheses) and re-render. If it still can't, you get a clear “Couldn't render this diagram” panel with the error message and an Edit source button — never a broken graphic.
• Also. A Copy source button lifts the text out; the title row accepts Smart Tags and #complete; Shift+Enter in the source box hops out to the note below.

Heads up: this block assumes you know Mermaid syntax — it's a code block for diagrams, not a visual editor. If you're new to it, keep the Mermaid docs open while you write. For a drag-and-draw canvas instead, use Drawing.

Drawing

A freeform sketch canvas (/drawing), powered by Excalidraw, for diagrams, annotations and doodles that don't fit any structured block.

• Tools. The full Excalidraw drawing toolkit is here — rectangles, diamonds, ellipses, arrows and lines, a freehand pencil, text, and the style panel for colour, stroke, fill and font. It's pared down to drawing: the app-level file/export/theme menu is hidden and the separate image tool is off, because the canvas lives inside your note rather than as a file you manage.
• Persistence. Everything you draw is saved with the note automatically as you go — the scene rides along in the note itself, so it's there (and offline-ready) when you reopen it. There's no separate save step and no export/download action; to reuse a sketch, copy the drawing block.
• Resize & theme. Drag the block's bottom edge to set its height. The canvas matches your light or dark theme. Its title row takes Smart Tags and a #complete like the other blocks.

GitHub repo

A live status card for a code repository (/github). Insert it and drop in a repo — as owner/name or a GitHub URL — and Nomima keeps a compact dashboard of that repo up to date inside your note.

• What it shows. A stat strip of stars, forks, open issues and open PRs; a facts row with the latest release, default branch, primary language, license and when it was last pushed; and a CI badge in the header carrying the latest GitHub Actions result (passing / failing / running).
• Tabs below. Under the facts sits a row of tabs: Commits (a graph of recent commits), Docs (up-to-date library documentation, via Context7), DeepWiki (an AI-generated repository wiki), README (the repo's rendered README) and Languages (a byte breakdown of the repo's languages). Switching tabs is view-local — it never edits the note.
• The Docs & DeepWiki tabs are opt-in. They read from optional outbound services (Context7 and DeepWiki) that ship off. The first time you open one, the tab explains what it sends and offers a one-click Enable; turning it on sends only the repository name to fetch its docs. Both need a connection for that first fetch, and a long page shows just its beginning with an Open the full page button into the in-app web view.
• Live, self-refreshing & offline-ready. The card loads on its own and re-fetches when you reopen the note; a refresh button in the header forces an update on demand. What it fetches — the stats, commit graph, README and languages — is cached in the note, so the card paints instantly on reopen and stays readable offline, with an “Offline · showing cached data” banner marking how fresh it is. The Docs and DeepWiki tabs are cached too: each is pulled over the network once per repo revision, then served instantly and offline on every later view — the header's refresh button forces a fresh fetch when you want the very latest.
• Needs a connected GitHub account. The block reads GitHub through the token from your connected account — set one up in Settings → Connectors (see References & citations). Until then it prompts you to connect. (The Docs and DeepWiki tabs don't use GitHub — they're separate services.)

Note: the header title and the “Open on GitHub” action open the repo in Nomima's in-app web view, and links inside the README and doc tabs open there too. Collapse the block from its chevron to keep just the title row when you don't need the full card.