Digitable tools

Architect

Panel on the left, canvas in the middle, the model in the language on the right. What you draw turns into category-theory declarations and is checked right away by the same compiler that backs flang check. What you write is laid back out as shapes.

Canvas and model

Whole tasks

Arrows and objects

Sets

There is no difference among them, and that is not an omission: a difference is a crescent, and the geometry reader knows only a circle inside a circle and a labelled lens. A button would drop a shape the page cannot read back. A set on the canvas is hatched while an object frame is not, and this is not decoration: a set has an inside, an object does not. That is why the three cases read before their labels do — where circles overlap the hatching doubles and the lens is darker than either; a nested circle is doubled all over; circles apart leave no dark spot anywhere. Circles are deliberately not dashed: on this canvas a dash already means a derived arrow — a composition — and besides, a dash changes only the boundary, while embedding and common part live in the area.

A sticker is a rectangle with a label, a column is an editor frame: both are native here, so stickers drag, recolour and undo like everything else. The board lives in the address of the link, not on a server and not in this browser. Whoever gets the whole link gets the board; a tab closed without a built link saves nothing. While the mode is on, the model in the language is not read from the canvas: thirty stickers would make thirty declarations and as many complaints.

Layout Retrospective Four columns of a conversation about the stretch just finished. Roadmap Four columns by time and not a single date: now, next, later, and an explicit "not doing".

Into column Colour

Link to the board

Load a board from a file

Three links, three different promises. Read what actually travels: the wrong link says nothing about being the wrong one — that is discovered at the other end, once the time is already spent.

A link to the board

THE BOARD ITSELF travels: it lives in the address fragment, after the «#», and exists on no server at all. The limit is 2000 characters, roughly 120 stickers; beyond that no link is produced and you are told by how much it overran. This is a snapshot, not shared work: edits made at the other end never come back here.

A shared session

A ROOM KEY on the workbench travels, not the canvas. You draw together in real time, but the room lives on the workbench and the link takes you there: the session cookie is SameSite=Lax, so a socket opened from the portal would arrive without it. We will not weaken the cookie for convenience — it is an access check, not a setting.

A conversation

THE CONVERSATION ROOM travels, and nothing else: words, not the canvas. The chat lives on chat.digitable.life — a separate service, and it cannot see the canvas at all. Inviting someone to the canvas and inviting them to the conversation are two different invitations, and never one link.

Whatever is selected is what travels. Nothing selected — the whole canvas goes; a part selected — only that part, together with the labels inside the shapes. .digitable is our own format and the scene itself: the very file that used to travel as .excalidraw, plus a note carrying the model in the language. Rename it to .excalidraw and it opens in Excalidraw (excalidraw.com, the Obsidian plugin); dragged onto the canvas it is taken without renaming. The .excalidraw files exported earlier still open here. .fp is the model in the language, exactly the one in the column on the right: the specification of the drawing, read by a person and by the compiler. The extensions .flang, .fp, .фп and .фланг are equal to it; Cyrillic file names break for some people, hence .fp by default; a directory walk (flang test) sees only .flang. SVG is for foreign boards: Boardmix, Miro, draw.io and Figma do not accept the .excalidraw format, but they do take SVG; ours also carries the scene inside itself, so it comes back into Excalidraw losslessly. PNG is just a picture at twice the screen size: everyone takes it, FigJam included, but it opens back nowhere. The sticker board has its own file in the «Board» drawer — that one comes back only here.

Open a drawing file (.digitable, .excalidraw or our SVG)

The editor opens by itself and costs about 430 KB over the wire.

The model in the language

Reference for drawing

How drawing works here

This is not a whiteboard for diagrams in general. What you draw here is a model in our language: every shape is a declaration, and the drawing is read straight away by the same compiler that backs flang check. Its answer is printed under the model panel.

There are two ways to draw. The tools of the language sit in the editor toolbar itself, above the canvas: object (key O or 2), set (N or 3), morphism (M or 4), composition (C or 5). Each switches on already set up — the right shape, the right line style, the right pen colour. Next to them, in the same toolbar, is the canvas work: select (V or 1), hand (H), label (T or 6), eraser (E or 7) and the «keep the tool» lock (Q), so you do not have to switch back after every shape. The keys work on a Cyrillic layout too — the editor looks at the physical key, not at the letter. The second way is to drop in a whole ready-made piece: the templates in the left column and the library of the language (the button in the top right corner of the canvas). The templates fall into three groups — whole tasks (a syllogism as text, the same one in circles, a traffic light), arrows and objects (a morphism, a composition, a square, a pair for an isomorphism, an identity, an object) and sets (an embedding, a common part, a union); each one says what it starts. Undo, redo and zoom are at the bottom of the canvas.

The screen is laid out as three columns: panel, canvas, model. They do not shrink to fit the window — the canvas column is already the narrow one, and squeezed it turns into the stub the page was once rebuilt because of. So whatever does not fit runs off the edge and the screen travels along the ribbon: the rail above the columns shows where you are and carries you to the neighbour. On a wide monitor there is no rail — there is nowhere to travel. The idea is taken from our own window manager, digitwm, where windows live on a ribbon of columns just like this.

Colour on the canvas speaks about trouble, not about the norm. Accepted shapes used to glow green — and on a working model that meant everything was green, so the colour singled out nothing. It is the other way round now: what is accepted keeps the palette colours, and red marks a shape whose declaration the compiler complained about. There are usually none of those, or one, and it is seen at a glance. Unfinished work is not scolded: a box without a label has not declared anything yet. The positive answer is printed in words under the model panel — «accepted, 5 shapes out of 5». A shape you coloured by hand is left alone.

The words of the language are shown as examples rather than as a list: thirteen cards — eleven constructions (a category, an object, a morphism with an identity, a chain, a functor, a bifunctor, an isomorphism, a monoid, a group, a theorem, a monad) and two cases built out of them (a syllogism and a traffic light). The button next to an example puts it into the model panel. What turns into what on the canvas is in the «What a shape becomes» table.

There is no live co-editing here, and there is no point looking for it in the menu. Two people on one canvas at the same time means a live room: a server holding the connection between browsers. Excalidraw has such a room, but it lives in its own application, and the portal takes only the editor from it — the built file does not contain a single line about sockets. What does work today: Save writes the scene to a file, Open takes someone else's. The same file carries the diagram into a chat — for instance Digitable Chat, which is ours and sits next door. That is exchanging snapshots, not working together, and calling it shared access would be untrue.

The editor here is ours: a fork of Excalidraw written up for the Digitable language. What is left of Excalidraw is the format — a scene can be saved and opened in any Excalidraw editor, and the other way round, because an object is still a box and a morphism is still an arrow. Everything else is ours: the toolbar speaks the words of the language rather than «rectangle» and «diamond»; so do the palette, the library, the menu and this help. The diamond, the line and the pencil are absent from the toolbar on purpose: they do not translate into declarations. The canvas shortcuts are shown by the «?» key.

What a shape becomes

On the canvas	In the language	What the compiler checks
A labelled box	`объект «Имя»`	the name is not taken by another object
The second and further lines of a box label	`«сумма»: деньги`	the field parses as a record field with a known type
A labelled solid arrow	`морфизм «Имя» из «А» в «Б»`	both ends are declared objects
A loop on a box	`единица «А»`	the object is declared
A dashed arrow	`морфизм «Имя» это «г» после «ф»`	the codomain of the first arrow matches the domain of the second
A circle inside a circle	`// вложение «Б в А» из «Б» в «А»`	nothing yet: the line is printed as a comment, and the circle does not light up green
Two overlapping circles with a label in the common part	`// пересечение «Имя» из «Б» и «В» в «А»`	nothing yet: both circles must lie inside a third one, and the common part must be labelled

The dashed style is not a matter of taste: in commutative diagrams it marks the derived arrow — the one whose existence follows from the others. A composition is exactly that arrow: it is not drawn on its own, it comes out of the path.

The page already reads Euler circles: a circle inside a circle is an embedding, two overlapping circles with a label in the common part are a common part, circles apart are simply two sets. But this is not a declaration yet, and the page is not to blame: the copy of the language this page carries does not know these words. Neither of the two set words is in the keyword table of copy 0.4.7. The language itself does have them, and this was checked by a run: binary 0.7.10 parses both forms and names them — embeddings, intersections (a flang check run on 5 September 2026; the contract is flang/cat/SETS.md). It is the copy that lags — 0.4.7 against the released 0.7.10 — not the language. So what was read is printed into the panel as a comment, behind a //. The compiler passes such a line over in silence, the circle never turns green, and promising an accepted parse here would be a lie. The circle itself does declare an object, just as a box does — and that is accepted. The three templates in the «Sets» group drop in exactly the geometry the parser recognises: they show how deep a circle has to go in, where the label of the common part belongs, and why the circles of a union do not overlap.

Examples across the whole category-theory surface

Thirteen cards: eleven on constructions of the language — one per word — and two on cases built out of them. Four of them can be drawn on the canvas: an object, a morphism, an identity and a composition; only those have a shape. The rest live in the source, and this page will not invent a shape for them. Every example here passes flang check when the portal is built — with the copy of the language the page itself ships (0.4.7). The real binary, 0.7.10, answers differently, and that cannot be left unsaid: it returns 0 for four cards out of thirteen, and tells the other nine «checked NOT ALL THE WAY», then names what it does not judge: morphisms, functors, bifunctors, isomorphisms, monoids, monads. The numbers come from a run on 5 September 2026 — flang check of release 0.7.10 over each of the thirteen cards — not from copying an older measurement. That is a limit of the language, not of the page, and it is named in the compiler's own words.

A category

The boundary of the conversation: names inside it are unique, and an object is data with types. An indentation-surface model starts here.

категория «Продажи»

  объект Покупка
    сумма является деньгами
    «постоянный клиент» является признаком

An object

An object of a category is a type. Type equality is nominal, by name: two objects with identical fields stay different.

объект «Заказ»
  «номер»: строка
  «сумма»: число

A morphism and an identity

An arrow does not perform the transition, it declares that the transition is allowed. A loop on an object is an identity; without it the functor laws cannot be stated.

объект «Заказ»
объект «Отгрузка»

морфизм «отгрузить» из «Заказ» в «Отгрузка»
единица «Заказ»

A chain

The same composition, written in reading order: first this, then that. For a long path it is the only readable form — «c» after «b» after «a» reads inside out. The compiler checks the joins the same way in both forms.

объект «Заказ»
объект «Отгрузка»
объект «Счёт»

морфизм «отгрузить» из «Заказ» в «Отгрузка»
морфизм «выставить счёт» из «Отгрузка» в «Счёт»

цепочка «оформить заказ»
  сначала «отгрузить»
  затем «выставить счёт»

A functor

A mapping of one category into another in full: objects to objects, fields to fields, morphisms to morphisms. That is why a transition between two models can be checked instead of retold in a comment.

объект «Запрос страницы»
  «номер страницы»: число

объект «Условие выборки»
  «смещение»: число

функтор «Страница в выборку» из «Запрос списка» в «Хранилище»
  объект «Запрос страницы» отображается в «Условие выборки»
    поле «номер страницы» отображается в поле «смещение»

A bifunctor

A functor of two categories at once: a pair of objects maps to an object, a pair of morphisms to a morphism. This is how you declare what is assembled out of two things — a pair, a correspondence, a product.

объект «Заказ»
объект «Отгрузка»
объект «Пара заказов»
объект «Пара отгрузок»

морфизм «отгрузить» из «Заказ» в «Отгрузка»
морфизм «отгрузить обе» из «Пара заказов» в «Пара отгрузок»

бифунктор «Пара» из «Продажи» и «Продажи» в «Пары»
  объекты «Заказ» и «Заказ» отображаются в «Пара заказов»
  объекты «Отгрузка» и «Отгрузка» отображаются в «Пара отгрузок»
  морфизмы «отгрузить» и «отгрузить» отображаются в морфизм «отгрузить обе»

An isomorphism

A claim that two representations are one thing in two shapes. The arrows must meet crosswise, and each end must have an identity declared.

объект «Заказ»
  номер: строка

объект «Накладная»
  номер: строка

морфизм «выписать» из «Заказ» в «Накладная»
морфизм «по накладной» из «Накладная» в «Заказ»
единица «Заказ»
единица «Накладная»

изоморфизм «Заказ и накладная» из «Заказ» в «Накладная»
  прямой морфизм «выписать»
  обратный морфизм «по накладной»

A monoid

A carrier, an operation and a unit. The laws need not be written: the shape of the construction already states them, and associativity and neutrality are checked on a grid of values taken from the examples of the operation.

моноид «Умножение чисел»
  носитель число
  операция «Умножить»
  единица 1

тотальная функция «Умножить»
  принимает левый: число
  принимает правый: число
  возвращает число
  левый умножить на правый

A group

There is no separate word for a group in the language, and that is a find rather than a gap: a group is a monoid with an inverse declared. One extra line — the inverse element — adds invertibility to the laws already in force.

моноид «Сложение чисел»
  носитель число
  операция «Сложить»
  единица 0
  обратный элемент «Противоположное»

тотальная функция «Сложить»
  принимает левый: число
  принимает правый: число
  возвращает число
  левый плюс правый

тотальная функция «Противоположное»
  принимает значение: число
  возвращает число
  0 минус значение

A theorem

A statement about data that gets checked: what is given, where to look for the evidence, which morphism we travel by and what comes out. The «in the data» line is what turns reasoning into something checkable.

категория «Исполнение заказа»

  объект Заказ
    номер является строкой
    «готов к отгрузке» является состоянием «Готов к отгрузке»

  морфизм «Готовый заказ можно отгрузить»
    если «Готов к отгрузке»
    то «Отгрузить заказ разрешено»
    по закону «Отгружаем только подтверждённое складом»

  теорема «Заказ ЗК-7781 можно отгрузить»
    дано Заказ имеет «готов к отгрузке» равное да
    в данных заказы найти где номер равен «ЗК-7781»
    по морфизму «Готовый заказ можно отгрузить»
    следовательно «Отгрузить заказ разрешено»

Monad

A type that knows how to wrap a value and how to flatten two layers into one. It is declared on the type, the way a monoid is declared on its carrier: «возврат» names η, «соединение» names μ, and both lines point at ordinary functions. Inside a body the «в монаде» block binds steps that may each fail to answer — instead of the ladder of matches that grows with every step.

тип «Возможно» от «А»
  вариант «Есть» содержит значение: «А»
  вариант «Нет»

монада «Возможно» от «А»
  возврат «Обернуть»
  соединение «Сплющить»

тотальная функция «Обернуть» от «А»
  принимает значение: «А»
  возвращает «Возможно» от «А»
  вариант «Есть» с значение равным значение

тотальная функция «Сплющить» от «А»
  принимает вложенное: «Возможно» от («Возможно» от «А»)
  возвращает «Возможно» от «А»
  разбор вложенное
    случай вариант «Есть» с значение как внутри
      то внутри
    случай «Нет»
      то вариант «Нет»

A syllogism

All men are mortal, Socrates is a man — therefore Socrates is mortal. The morphism here is not a step between data but a law, and the theorem applies the law to this particular Socrates and names where the evidence is to be found. THIS text has no shape: a category, a law-morphism and a theorem are not drawn on the canvas — the whole answer is the verdict under the panel. A syllogism can still be drawn, and Euler circles are exactly what it is drawn with: the «A syllogism in circles» button puts Socrates inside People inside Mortals on the canvas. The two cases do different work: this one PROVES the conclusion with a theorem, that one SHOWS it — and there the conclusion is precisely the third embedding, visible in the drawing yet not declared in the model.

категория «Силлогизм»

  объект Человек
    имя является строкой
    «человек» является состоянием «Человек»

  морфизм «Все люди смертны»
    если «Человек»
    то «Смертен»
    по закону «Все люди смертны»

  теорема «Сократ смертен»
    дано Человек имеет «человек» равное да
    в данных люди найти где имя равен «Сократ»
    по морфизму «Все люди смертны»
    следовательно «Смертен»

A traffic light

States are objects, transitions are morphisms, «stay on red» is an identity, «through amber to green» is a composition. Four words of the language on one recognisable task, each of them visible as a shape. What is NOT written here: that red cannot go straight to green. All that is written is that no such morphism is declared — and a prohibition is a statement, and it needs a theorem, as Socrates did.

объект «Красный»
объект «Жёлтый»
объект «Зелёный»

морфизм «зажечь жёлтый» из «Красный» в «Жёлтый»
морфизм «зажечь зелёный» из «Жёлтый» в «Зелёный»
морфизм «погасить» из «Зелёный» в «Красный»
единица «Красный»
морфизм «через жёлтый к зелёному» это «зажечь зелёный» после «зажечь жёлтый»

What this page does not do

Euler circles are read, but not from pixels. A circle inside a circle is an embedding, overlapping circles are a common part, circles apart are simply two sets. The overlap alone declares nothing: nudge a shape by two pixels and an «intersection» would appear where nobody meant one. So a common part is declared only when a label sits inside it (a common part must be named, and there is nowhere else to take the name from), while a circle that went almost all the way in gets an honest «not understood, please clarify» instead of an invented relation. Only the ellipse carries geometry: a rectangle inside a rectangle is a grouping habit, not a notation. The words вложение and пересечение exist in the language and have shipped: binary 0.7.10 parses both forms (checked by running flang check on 5 September 2026). It is the COPY the page carries that lags — 0.4.7 in static/js/vendor/flang/, against the released 0.7.10. So what was read is named in an aside BESIDE the model rather than as a line inside it: a comment in the body of a model declares nothing and looks like a declaration somebody switched off. The aside will disappear on its own, with no edit to the page, on the day the vendored copy of the language catches up with a release.
A set difference has no shape. An intersection, an embedding and a union are drawn as circles and read back — three templates in the «Sets» group stand on that. A difference is not: A without B is a crescent, and the geometry reader knows exactly two forms, a circle inside a circle and a labelled lens. A crescent is neither, and a button dropping one would put a shape on the canvas that the page cannot read back. Today «A without B» can only be said in words in the panel — as a comment, like everything else about sets.
An isomorphism is not inferred from a pair of opposite arrows. A pair of arrows there and back is not an isomorphism: an isomorphism asserts that their compositions equal the identities, and that is the author's assumption, not a property of the drawing. You can write it in the panel and the compiler will check it; inferring it from a picture is another matter.
A green verdict is the compiler's answer, not a warranty for every word of the model. The FTS model compiler (static/js/vendor/fts/) — the one this page hands a model that starts with the category word — checks a theorem's inference in earnest: nine corruptions of the syllogism — a conclusion the law does not give, a reference to an undeclared morphism, a premise that misses the object, a field that does not exist — are rejected with a named cause. The TYPE of a field, however, it does not check: имя является драконом is accepted, and «драконом» becomes the field's type. Measured on 9 August 2026 against release 0.4.7: an unknown word, a typo in a known type and a reference to an undeclared object are all three accepted, and the verdict line on them is the same as on a sound model. The page deliberately does not start a second check of the language — two checks of the same thing drift apart silently — so the boundary is named here: «accepted» means «the compiler did not object», and field types are not part of that.
A model that starts with the category word is FTS, the earlier surface, and a DIFFERENT compiler judges it. The page picks that compiler by the first significant word (static/js/flang/surface.js) and does not hide the choice: the verdict says so — «FTS model «Name»: accepted». This matters beyond history. Today's language binary, flang check 0.7.10, ACCEPTS such a model with code 0 and reads it as a module with no functions: a run over the eight reference models of /learn/fts/ on 5 September 2026 gave 8 out of 8 with code 0 and «functions 0». flang check --proof spells it out: «no declared functions», «no declared laws», and about the theorem — «declared, not proved: the old form of a theorem, a legacy of FTS, is parsed, but nobody derives anything from it». So a green answer from the real binary on an FTS model means no checking at all, and leaning on it is not allowed. A checkable rule on flang is written today as a spec — the fspec/ directory of the language repository.
«Does it follow?» answers about a path, not about truth. The panel under the model looks for a composition along the declared arrows and prints it — that is the Barbara syllogism: «all men are mortal; Socrates is a man» gives g ∘ f. The answer has two hard limits. First: «there is no path» means «not derivable from what is declared», not «false» — the absence of a derivation is not a statement. Second: an arrow declared by hand between the same two ends and the composition found here are DIFFERENT arrows until their equality is declared; the language has no form for «declare that these are equal» at all — equality is declared by the category on an object and computed on a grid of examples. Negation, «some» and exclusive premises are not what a category takes, and this page does not call itself a checker of logic.
Source highlighting works in the panel, not on the canvas. Text inside an Excalidraw shape has one text field and one strokeColor for the whole element: the format has no room for per-range markup, and the text is drawn with a single fillText call. A label inside a box cannot be coloured word by word without rewriting the editor. Colour on the canvas says something else, and says it with the whole shape: whether the compiler accepted its declaration.

What’s new

New here1

Easier now3