The workshop

The workshop in detail: the window of the platform, the panels, the windows of the graph, the pulpit, the library and the assistant, the look of nodes on the canvas, the pulpit of a program and its look. Where to begin — Getting started.

Introduction

The document describes the make-up of the workshop — the window of the platform in Windows — and of the pulpit of a working process. The owners: the function ui (the link and the window), the function canvas (the document of the pulpit), the function graph (the meaning of shared objects). First steps — Getting started, the protection of the window — Protection, 3.10, the methods — Methods of the workshop and the pulpit.

1 The purpose of the workshop

The workshop is the window of the platform. In the workshop a person adds modules, builds graphs and pulpits and uses them. There is one workshop per instance; inside it, in the host — the middle between the panels — windows open.

The pulpit is a full graphical interface of a working process.

What the workshop does for the person:

• the pulpit is shown in one window of the platform in two ways: on the step «View» of the graph window inside the workshop, where it is built, and over the whole window, without the frame of the workshop — on the face of the program, where the program is used (6.6). The pulpit is not taken out as a separate program;
• several working processes are open in the workshop at once; a program that is on does not change;
• several programs may be on at once, each event causes a run (The program: graph and runs, section 2);
• O.G.A.S. is a program, not a service: a closed window goes to the icon by the clock, and the platform works on — programs remind and take messages; it is stopped by «Leave» in the menu of the icon, after confirmation (2.1). There is no automatic start: after the computer restarts, programs do not work until the person starts O.G.A.S.;
• the workshop itself calls the person with a notification about a question of a program and about a failed run, not about the end of a run (2.2);
• the bars along the edges are sections by meaning: on the left «Workshop» — making — and «Platform» — administration, with the library of everything the person has; on the right — the panels of programs the person put together themselves, by their own categories; the logo of a section is a sign without an action; there are two journals — of the program and of the platform (section 4, 5.6).

2 The window in Windows and the function ui

The platform works in WSL2, and the window is a Windows program. The workshop is the program ogas-window.exe on Tauri 2 and the system WebView2. The function ui is a Linux OS process marked interactive in its description:

1) it waits for a connection on 127.0.0.1 (the port ui.window.port; 0 — any free port at each start) and makes a session token; 2) it starts the window program (WSL can start Windows programs from Linux) and passes it the port and the token on the command line; 3) it takes one window: the first message is ui.window.hello with the token, otherwise the connection is closed; 4) it passes the requests of the window to the kernel through its own connection, and the events of the kernel to the window as the notification event; 5) it keeps for the window the name of the program whose face a start asked to show (6.6), and tells an already open window of such a request.

The messages are the same JSON-RPC 2.0, one per line, as on the bus, only over TCP. The window can reach the methods of the functions, and of the kernel methods only core.status, core.health, core.event.subscribe and core.shutdown. The methods ui.window.* are answered by the function ui itself. Leaving the workshop (2.1), after the person confirms, sends core.shutdown, and the instance stops. Stopping the instance closes the window and removes the icon by the clock. An HTTP server, a browser client, Electron and a Linux window through WSLg are not used.

Why not a Linux window through WSLg. Switching the RU/EN layout is not passed to a WSLg window (Weston sets the layout once per session), and there is no fractional scaling, no Windows input methods and no screen narrator. In a Windows program these work as usual.

Where the window program lies. The path is set by the setting ui.window.exe (as WSL sees it); when the setting is empty, bin/ogas-window.exe from the delivery is used, then the result of make window in the sources. The working folder of the window is on a Windows disk. If WSL cannot start Windows programs, the window does not open, and the instance works through the command line.

2.1 The icon by the clock

A closed window goes to the icon by the clock, and the platform works on (table 5 there).

• To close is to hide. The «close» button on the strip on top and on the face of a program, Alt+F4 and closing from the taskbar hide the window: the window program stays, and in the Windows notification area, by the clock, stands the O.G.A.S. icon with a hint. Nothing stops and nothing is lost: unsaved edits, what is typed and the layout wait in the hidden window.
• The icon. A click on it brings the window back as it was hidden; the menu of the icon is «Open» and «Leave».
• Where the window is. The first time in a start, a hidden window says where it went — with a notification in the corner of the screen (2.2): the platform works by the clock, to leave — from the menu of the icon.
• Leaving. «Leave» shows the window and asks whether to really leave, naming what will be lost — unsaved edits, what is typed, a run that is going — and that programs will be switched off and will not remind. Agreeing sends core.shutdown, and the window program closes together with the instance.
• Starting the shortcut again shows the hidden window, as it opens a failed one anew (The make-up of the platform, 3.6.3).
• While there is no icon. The icon appears when the window page has given it its words in the language of the interface. Before that — and if the page did not come up — closing asks the question of leaving: the window does not disappear without an icon to bring it back by.

There is no automatic start: after the computer restarts, programs do not work until the person starts O.G.A.S.

2.2 Notifications

A notification — of a program (the node «Notify», The program: graph and runs, 24.6) or of the workshop itself — stands where it will be seen:

• over the window, at the top right under the strip — when the person is in the window: it is visible, not minimized and has the focus;
• in the corner of the screen, at the bottom right over the taskbar — when the window is hidden by the clock, minimized, or the person is in another program. This is a separate small window without a frame over the others; it does not take the focus, and the person goes on typing where they typed.

The four latest are seen at once, each for 12 seconds. Over the window a click on a notification removes it. In the corner of the screen a click brings the O.G.A.S. window back, and the cross on a notification removes it without opening the window; when no notifications are left, the corner window closes.

What the workshop itself calls about:

• a question of a program — the title is the name of the program, the text is the question;
• a failed run — the name of the program and the cause of the failure.

About a question of the program that is in the window now there is no call over the window: it is already outlined there, and its tab is marked (6.8). About its failure there is no call in the workshop — it is named on the strip on top — but there is one on its face, where there is no strip. In the corner of the screen both are always called about: the person is not at the window. There is no call about the end of a run; there is no sound.

A notification is not kept: whoever did not see it, did not see it. While the platform does not work, there is nobody to call.

3 The window page

The interface is a page built into ogas-window.exe: HTML, CSS and JavaScript modules without a bundler and without a ready interface library (functions/ui/window/ui/). The second page is the notification window in the corner of the screen (notice.html, 2.2): it keeps nothing of its own but shows what the window program passed it, in the colours and font of the workshop. Buttons, fields and lists are made by its own code. The page is updated by its own code, which changes only the elements that changed, so the focus, the cursor and input through input methods are kept on redraw. The field of the graph is drawn in SVG.

Input, layouts, input methods, screen scaling and the screen narrator are given by WebView2. The accessibility of the workshop: every action can be done from the keyboard (5.1), the focus is visible, the contrast of both schemes is checked, icon buttons have words for the narrator; the canvas of the graph and the sheet of the pulpit are not read by the narrator as a whole. The contrast of the default colours of both schemes and of the pulpit theme is checked by make ci: letters differ from their background at least 4.5 times, a line that marks something and the edge of a field — at least 3 times (WCAG 2.1, 1.4.3 and 1.4.11). The sizes ui.* are set in CSS pixels, screen scaling is applied by WebView2. The default font is built in (DejaVu Sans). ui.font.source = system — the Windows interface font, file — a file from WSL: the function ui reads it and gives it to the window with the method ui.window.font.

The page may take scripts, styles and fonts only from the window program itself, images — from it and from addresses with the data inside them; the page does not go to the network. This is the content policy of the window (functions/ui/window/tauri.conf.json); the window shows the pictures of a pulpit at such addresses (Protection, 3.12).

4 The frame

The levels of the workshop (rule 2.5 of Rules of development):

workshop (the window of the platform)
  area: brand, strip on top, left side, right side
    bar → subsection of the bar
  host
    bottom bar: capsules of folded windows
    window on the host (kinds of windows — table 1): capsule tab and body
      body: column on the left, work area, panel of the chosen
        category → subcategory → row or command

The frame: capsule bars along the edges and capsule tabs on the windows; the windows on the host move freely. The window has no Windows frame, all areas are drawn by the page:

• the brand — the top left corner;
• the strip on top — the name of the program, the state and messages; on the right the buttons of the Windows window (minimize, maximize, close). Dragging the strip and the brand moves the window;
• the left edge — the bar «Workshop», making: «Graph», «Modules» — the modules of the program on the screen — «Program journal», «Assistant» (5.7) and «Create»: a new program opens at once in the graph window; under it the bar «Platform», administration: «Library» (5.6), «Platform journal», «Settings», «Profile» (5.10), «Language», «Theme», «Help» — the documentation on the site ogas.space in the browser — and «Leave» (2.1);
• the right edge — the panels of programs: each is a category the person made and named in the library, with the icons of the programs they put on it (5.6). A click on an icon opens the built program: its face takes the window, and the program is switched on (6.6). The platform itself puts nothing on a panel.

The bars are sections by meaning, not by how the code is made. Above the items of a section stands its logo: the sign of the section, and with labels its name as well; it opens nothing and is not pressed — on these bars and on the bars over the canvas of the graph (5.4). The items open things; the labels are opened by a strip at the side, the bar is folded by a chevron. A window names in its description the bar of its section and its place in it, but does not head the bar. There are no program buttons — run, stop, retry, input — on the bars: they are on the pulpit, on the face of the program and in the control bar over the canvas of the graph (5.4). - the host in the middle — the windows; over its bottom edge — the bottom bar with folded windows (section 5).

A bar is one capsule in three states:

• folded — the logo of the section and the folding arrow (chevron);
• unfolded — under the logo a column of icons of subsections with separators, a narrow strip at the side that opens the labels, and the chevron;
• with labels — the same capsule, wider, the icons get names.

A bar of the right edge is the same, mirrored: the icons by the outer edge, the labels toward the host. The chevron points where the capsule will go. The bars of the left edge are not set up; the panels of the right edge, their names, order and the programs on them the person puts together in the library (5.6). Folding and labels are kept until the workshop is closed.

The sizes of capsules are counted from the cell ui.layout.cell in sixtieths of the cell: the logo 40, the tile of a subsection 32, the step of a subsection 44, a separator 2 by 33, the strip of labels 17, the chevron 27, the rounding 9. The height of a window tab is 0.8 of a cell.

The code of the frame is kept apart from the content of the windows: shell.js (areas, bars, windows and gestures), faces.js (the faces of capsules), windows.js (the geometry of windows), lib/look.js and style.css (tokens), lib/glyphs.js (signs). The body of a window by section 5 is drawn by host/frame.js, and each window on the host is a file of its own in host/ that only fills its parts: a change of the settings window does not touch the graph. The pulpit is drawn by pulpit/surface.js — one code for the step «View» and for the face of a program (6.1), knowing neither the frame nor the body of a window; the face of a program is face.js. Rules 2.1 and 2.5 apply (Rules of development).

5 Windows on the host

A window on the host is a capsule tab on top (the name, the buttons of the window, the folding chevron) and the body of the window under it.

• Kinds of windows — by table 1. One window of each kind is opened; several kinds are open at once.
• Several processes are open at once. Each open process has its own windows of the graph and the program journal — one of each kind — and the tab of such a window names the process: «Graph · Comic». Two graphs are put side by side and looked at together. Each process keeps its own: documents, what is chosen, what is typed, the history of edits, runs; what came from the platform for one process goes into it, whatever process the person edits at the time. The process worked with is the one whose window the person pressed last: a press in a window of a process makes its process the current one before anything in the window answers the press. The strip on top, the bars «Workshop» and the keys speak of the current process: «Graph» and «Program journal» open the window of this process, the window «Modules» shows its modules. A process chosen in the bar, in the library or with a panel of programs opens beside the open ones, and an open one comes forward; a new and an imported process open beside as well.
• The buttons of a tab: first the actions of the window (the graph has «Save» and «Validate», the step «View» «Save»), then «minimize», «full window» and «close». «Save» of each window writes the document of its owner and only it: the graph — the graph of the process, the pulpit — the pulpit; a refusal of the owner is told in the window whose document it did not take.
• Actions with a window: moving by the name, resizing by an edge, maximizing over the whole host, folding by the chevron into a capsule in the same place, minimizing by «minimize» into the bottom bar, and closing. A press on the name that led nowhere is a click: the window comes forward and stays as it stood. A window carried out of being maximized over the host takes its former size, and its name stays under the pointer.
• A window is its tab and body, not the rectangle around them. The empty place in the row of the tab, to the right of the capsule, does not belong to the window: the tab of a window behind, seen in this place, can be reached — a press on its name brings that window forward, its buttons and chevron work.
• A question of the workshop — about closing, about leaving a process, about a new and an imported process — lies over all windows, however many times they are brought forward: windows lie over each other only inside the host.
• A window folded into a capsule is its capsule: it takes as much room as that. It is carried anywhere the capsule fits, up to the very edge of the host; it is under the pointer only where the capsule is, and covers its neighbours with nothing invisible. Unfolded where the capsule was carried, the window stands inside the host.
• The bottom bar. A window minimized with «minimize» leaves the host as a capsule — the name and the chevron — into a row over the bottom edge of the host, from left to right in the order the windows went there. The height of the host does not change from it: the capsules lie over the windows under them. A click on a capsule or opening the window from a bar returns the window to its former place and size. With no minimized windows the row is not shown.
• A window stands where it was put, and is as large as it was made: nothing gives it a place or a size by itself. Let go at an edge of the host, in its corner, over another window — it stays where it was carried, and the other window as it stood. A window changes its edge only by the grip of that edge, and no other window moves then.
• Drawing to edges is the only help for a window: to stand evenly. When an edge of the window being carried comes nearer than 12 points to an edge of another window or of the host, the window goes up to it: stands close beside (side to side, top to bottom) or level (top to top, side to side). The edges of windows that stand beside draw it — not of those far above or below along the line; of two edges within reach — the nearer. The size of the window does not change. An edge being pulled is drawn the same way. A window maximized over the host or folded into a capsule draws nothing, and a capsule is not drawn.
• When the host changes its size — the workshop window was stretched or shrunk — the windows keep their shares of the host: a window that took half the host still takes half, those that stood beside stand beside. A layout takes a host of another size at a start the same way.
• Closing a process — its last window — with unsaved edits first asks, as closing the workshop does: leave without saving, or stay (in place of a question on going to another process: the other opens beside, and nothing is lost). A process that did not open gets no window: the open ones stay, and the refusal is named. Closing the workshop names the loss of each open process, with several — with the name of the process.
• The host may be empty. The host opens no window by itself: at a start with no saved layout and after all windows are closed it is empty and says in its middle where windows are opened from — a program on the panel of programs or in «Library», a new one with «Create». All windows, the journal too, the person opens from the bars. The reason: a graph window with no process shows nothing, and the workshop works with no windows — programs switched on go on, their faces open.
• The layout of windows is not written into the documents of a process; a window of a process remembers whose it is, and at the start the processes the windows of the layout showed are opened. The layout is kept between starts at the user level, so that each start does not begin with moving windows. It is kept by the function ui in config/layout.json, beside user.json (File formats, 7.1): which windows are open, where, in what order and what is with them — maximized, folded in place, in the bottom bar. The page writes the layout when it has stopped changing, and at once — before the platform is stopped with the close button of the window or «Leave» on the bar «Platform». At the start the windows stand where they were left, and if the host has another size — in the same shares of the host. With no saved layout the host is empty.

The journal is a window like the others (its data are given by the function observe): it has no fixed place on the host, it moves, is drawn to edges, is maximized and closed. The journal shows the latest records as a page, and the button «Show more» above them adds older ones while there are any: the journal is not shortened, and its whole history can be reached from the window.

5.1 The body of a window

The body of each window on the host is made the same way:

• The column on the left — the categories and subcategories of the window. A category with a name folds. A click on an item chooses what to show in the area, and for the graph and the pulpit — what to put into the area. A kind of node is put on the canvas by dragging too: the item is carried out of the column, its name follows the pointer, and the node stands where it was let go — in the body of a frame or in an unfolded group, if let go over it; an item let go past the canvas puts nothing. A node put by a click lies the same way: a click on an area with a kind of node in hand puts the node into it, rather than choosing it. In the graph window the column also shows the allowed links of the chosen node (5.2).
• The work area on the right — what is worked with: the graph, the rows of the journal, the settings of a subsection, a list of modules or runs.
• Over the work area, by its left and its right edge, a window may keep its own bars: the area scrolls under them. In the graph window these are the bars of the canvas (5.4).
• The panel of the chosen appears when an element is chosen in the area, and stands over the lower part of the area, with a margin from its edges and to the right of what the window keeps over the area: the panel does not cover the bars of the canvas. A panel the person put by hand also moves to the right of them and keeps its size as far as the area allows. Wherever an element is chosen, the area under the panel does not move; under the last element of the area room is left to scroll it out from under the panel. The panel has tabs, each window its own: for example, «Information» and «Edit». To the left of the tabs is a cross to «close».
• The panel is moved and stretched: whoever likes can put it at the side. It is moved by the free part of the strip of tabs and stretched by an edge or a corner; the panel stays inside the work area and does not get smaller than 240 by 120 — as much as the tabs and the row under them need. The place and size are remembered by the kind of window and outlive a restart (File formats, 7.1); when the area has become smaller, the panel stays in it. A double click on the strip returns the panel to its place at the bottom. Under a panel the person put themselves, the area leaves no room under the last element: the person moves it away.
• The panel closes with the cross, the key Esc and a click on an empty place of the area; the choice is taken off with it. Esc first closes the panel, and the next Esc folds the window; Esc does not unfold a folded window — the chevron opens it. Choosing another element changes the content of the panel.
• The canvas is endless: it has no edges and no size of its own, it fills the work area, and the area does not scroll — the canvas is carried. Nodes stand anywhere, to the left of and above the origin too. The grid of dots on the canvas moves with it when it is carried and zoomed. A process opened for the first time in a session is shown from the start of what stands on it, with room for the bars by the left edge; after that the canvas stands where it was carried.
• The scale of the canvas of the graph window is changed with the mouse wheel — toward the pointer: the place under the pointer stays under it — and with the tools «Larger» and «Smaller» — toward the middle of the area — and «Whole graph» in the tool bar of the canvas (5.4). The step is a quarter, the limits from a quarter of the true size to two; «Whole graph» puts the whole graph into the middle of the area, beside the bars, and does not make a small graph larger than its true size. The number of the scale is named by the status line. The scale and the place of the canvas are a view, not an edit: they are not written into documents, are kept until the workshop is closed, and the graph of a program that is on is looked at in any scale.
• The canvas is moved with the mouse: a press of the left button on an empty place of the canvas and dragging move the canvas after the pointer — so one looks at what lies further, as far as one likes in any direction; a press that went nowhere stays a click on an empty place and takes the choice off. The middle button moves the canvas from anywhere, over a node too. With a kind of node in hand a left press puts the node rather than moving the canvas.
• Nothing lies over another's. An area — a frame and an unfolded node of nodes — holds only what lies in it, and no node lies on another. After an edit that puts, moves, links, builds, takes apart, folds or unfolds, of two that came to lie on each other one gives way together with everything in it: what the hand has just put or moved stands where it was left; an area goes down from under what stands above it — as an unfolded node moves its neighbours aside; the rest goes right or down, whichever is shorter. What gave way may come to lie on a third, and then that one gives way. The graph of a program that is on does not move: only the view changes in it.
• Several nodes in the graph window are chosen by pressing with the key Ctrl or Shift: a press adds a node to the chosen or takes it out, the panel stays at the node chosen first. The chosen nodes are dragged, built into one node with the tool «Build into a node» and removed together with the key Delete; a frame moves together with its body. A press without a key on a node outside the chosen chooses it alone. Nodes are also chosen with a frame: dragging over an empty place of the canvas with the key Ctrl or Shift stretches a frame, and the frame let go adds to the chosen everything that lies in it whole: nodes and folded groups — an open group stays an area, and its nodes are taken one by one; dragging without a key moves the canvas, as usual. A group is chosen, marked and moved the same way: by pressing on a folded group or on the area of an unfolded one; it moves with everything in it. Delete removes the group with everything in it. The tool «Build into a node», taken with nodes chosen, builds them at once and gives way to «Selection»; taken with nothing chosen, it waits for a node. What is built stands at once as one compact node in the place of the first of the built, and what stood to the right and below comes nearer into the place they took.
• Notes and points on links:
• a note — a text on the canvas about one's program: what is done here and why. It takes no part in a run; it is put from the column («Note»), moved, stretched, edited and removed like a node, and, like a node, it covers nothing. The text is written in the panel; on the canvas under a head in the colour of notes (ui.color.head_note) it stands line by line, from two to eight lines, a long one scrolls;
• a point on a link — a place a link is led through to go around; it adds no meaning (The program: graph and runs, section 3, rule 8). A double click on a link puts a point where the path grows least; a point is carried by hand, a double click on it removes it; each action is a step of the history. Between points a link goes with one turn; the points of a link both of whose ends are being carried travel with the nodes. In the graph of a program that is on, points are neither put nor moved.
• Delete removes what is chosen in the window in front: a node or several chosen nodes, a link or a link of the interface — in the graph window, the chosen elements — on the step «View»; in other windows the key does nothing. The graph of a program that is on is read-only (Getting started, 7): Delete does not remove a node, and Ctrl+Z and Ctrl+Y take back and repeat the edits of the pulpit without touching the graph. Enter in a field of the pulpit ends the input and writes the variable, like leaving the field; a run does not begin on Enter — only an event begins it.
• The arrows shift what is chosen in the window in front: elements over the sheet on the step «View» (6.3) — by a step of the sheet, with the key Alt — by a unit; nodes, groups and graphic nodes on the canvas of the graph window — by a cell of the grid, with Alt — by a point, and each press is a step of the history; when nothing is chosen on the canvas, the arrows carry the canvas itself. In an input field the arrows stay the keys of the field, in other windows they do nothing.
• Everything done by hand can be done from the keyboard:
• Tab and Shift+Tab go over everything that acts: buttons and fields, rows of the column and the journal, the label of a window and the strip of the panel, nodes, groups, links and their points, the signs on the label of a node and the eyes of the face, graphic nodes and links of the interface, elements and frames of the sheet of the pulpit, rows of a table, the picture of a question. What has the focus is outlined in the accent colour; a window the focus comes into comes forward, and its process becomes the current one;
• Enter or space choose, like a press, and with Ctrl or Shift mark one more;
• on the label of a window the arrows move the window, with Shift they pull its right and bottom edges, Enter folds and unfolds it; on the strip of the panel the arrows move the panel, with Shift they change its size, Enter returns it to its place;
• a kind of node or a module chosen in the column by a key stands in the middle of the visible part of the canvas and is chosen; nodes are linked through the column — «Link with what is there» and «Add and link» (5.2);
• Insert on a link puts a point in the middle of its longest leg; a point is moved with the arrows and removed with Delete;
• which built node to put a node or a group into is chosen with the row «In the built node» on the tab «Details» (by hand — dragging with Alt); a frame of the sheet of the pulpit is moved with the arrows with everything in it;
• a question about an area: the first press of an arrow puts a quarter of the picture into its middle, then the arrows move the area, with Shift change its size; points and the brush are led by a sight: for points Enter is «this one», Shift+Enter «not this», Backspace removes the last; for the brush space paints, the arrows with Shift paint on the move.
• The width of the column is ui.layout.side_w, the height of the panel ui.layout.detail_h, the margin of the panel from the edges of the area two ui.space.pad, on the right — from the scroll bar of the area, if there is one, the colours ui.color.side, ui.color.work and ui.color.detail (Settings, section 8).

The make-up of the body of each window is given in table 1.

Table 1 — The make-up of the bodies of windows

For a node and a group the panel opens on «General»: the first thing to know about a box on the canvas is what it does and why it stands there. The tab the person went to stays chosen for the next node too.

«General» is read first: the name and the description — or words that there is no description. These are the person's words, and there are no others on the tab: what a kind or a module says of itself is opened by the sign «?» in «Details». Under them is one sign — «Edit». By it the words become fields — the name and a description of several lines (The program: graph and runs, section 4) — and under the fields stand three signs: «Default» — return the name the node carries by itself and remove the description, at once; «Save the changes» — put what is typed into the node; «Leave editing» — go back to reading, leaving what is typed unsaved. Enter in the name field saves, like the sign. For another node the information is read again. In the graph of a program that is on there is no sign «Edit»: the words are read but not edited.

«Edit» of a node and a group — in rows, by parts. The parts of a module node: «Module», «Parameters», «Seen on the node» — which parameters stand on the node as rows (5.3) — and «Node» — the fields of the node itself; for a node of the platform — «Parameters», «Seen on the node» and «Node»; for a group — «Inputs», «Outputs» and «Variables». A part with no rows is not shown. A row is a name, a field and two signs at the end of the row: «Return the default value» and «Save the changes»; the ends of the fields of all rows stand on one line. A hint opened by the sign «?» stands under its row, and the row stays in place. In a narrow panel — one put at the side — the name of the row stands above the field, the signs stay at the end. The row of the module has no return sign: the module has no default. What to give a node started alone is typed in the fields of events on the canvas (5.5).

For a module node «Details» show the ports from the manifest, and «Edit» — the module of the node and a field for each of its parameters by the schema of the manifest; an empty field shows the default (Modules, section 10). The sign «?» at a tool, a kind of node, a port and a parameter shows the hint from the dictionary of the owner: for a module — module.<id>.input|output.<port>.help and module.<id>.param.<name>.help, for nodes of the platform — the texts graph.* of the function of the graph.

The fields of the node itself — what the person sets for a node besides its parameters: the memory of a module node and the overlap rule of a node of a service (The program: graph and runs, sections 5, 13). Which fields these are, and at which module a field makes sense, is said by the kind of the node (node_fields, Methods of the graph, section 1); the window keeps no list of its own and does not show a field that means nothing at this module. An empty field removes the field from the node, and the owner's rule holds: a memory of its own, overlap queue.

What is typed in the panel goes into the document when the person saves. So a node, a group, a variable of the program and the label of a slot of the pulpit are edited — the rule is one, and the rows are the same (Rules of development, 2.9):

• while a row is not saved, what is typed stands in it, and the node keeps the former; the row is marked, its sign «Save the changes» is highlighted. One saves with this sign or Enter; each row is saved by itself;
• «Return the default value» acts at once: the node is left with no value, and the owner's rule holds; the name and type of a variable and the module of a node have no default, and no such sign;
• saving and returning are a step of the history each. What is saved stands in the document on the screen, and «Save» of the window writes it into the file, which the window says;
• a text that has not yet become a value — half a list — is not saved: it stays in the row, and the window says why;
• the name of a variable is saved by the function of the graph together with everything that names it: nodes, parameters, the faces of groups, the place on the pulpit and the remembered value follow the name (The program: graph and runs, section 7). The window says how many nodes followed the name and names the processes where a call gives a value to the former name; a refused name stays in the row, the refusal is told in the words of the function of the graph;
• another type of a variable begins with its own empty value; the pulpit is written even with the program on, so the label of a slot can always be edited.

What is typed and not saved is not lost (Rules of development, 3.1.5). When the panel goes to another node or closes, it stays waiting in the panel of its node: the window says so, the node carries a dot before the sign of its kind, and on coming back what is typed stands in its rows. A variable has its dot after its name in the column, a slot of the pulpit — after its label on the strip. «Save» of the graph writes the graph as it stands in the window, «Save» of the pulpit — the pulpit: what is typed and not saved is not in them, it stays in the panel, and the window says so. After a step back, a save and a paste the panel shows what stands in the document, and what is typed and not saved stays in the rows. Going to another process and closing the workshop ask about it and name it among what will be lost.

The memory of a module node is named by «Details» in the same place as the node: whether it is its own or shared — then with its name and the nodes that share it — and what of it is saved: the size, the time and whether a module works with it now (module.state.list, Methods of modules, section 2). The button «Clear the memory» is there when anything is saved; it calls module.state.clear, and a refusal of the owner — the memory is held by a module that is up — is told in the window.

Switching the program on, events, stopping, retry and resume are shared objects of the graph in the window of the process, in the control bar over the canvas of the graph (5.4) and on the pulpit, not buttons of the frame. There is no second run button with a meaning of its own.

5.2 The allowed links of the chosen node

When a node is chosen in the graph window, two groups of allowed links appear in the column on the left:

• «Link with what is there» — nodes already standing on the canvas;
• «Add and link» — kinds of nodes of the platform and installed modules that are not on the canvas yet.

A row of the list is not a node but a port: a module that takes a picture and a text out of a file stands in the list as two rows. So the person chooses not a module but the result they get, and the port for the link is defined uniquely. A row names both ports in the order the packet will go — success → join.input; types, descriptions and marks are shown in the panel.

The make-up of the lists is set by the function of the graph (process.node.candidates, Methods of the graph), not by the window: the rule of compatibility is one and the same for the list and for the check of the graph. Only links that are truly allowed come into the list.

The panel of the chosen shows a candidate the same way as a node from the canvas: what it is, what the chosen port gives (module.<id>.output.<port>.help, for nodes of the platform graph.kind.<kind>.input.<port>.help and .output.<port>.help from the folder of the kind), what type the data are and what the receiver will do with them. As separate marks — «this input already has a source» (a merge will appear) and «this is a cold input» (the node does not wait for it). The panel holds no ratings and no recommendations: the platform tells only what it knows.

Choosing a port. A press on the point of an input or an output that led nowhere chooses this port: its node is chosen, the row of the port is outlined, both groups of the column show only the links of this port, and their heading names the port; on the canvas the ports of the other side that fit it are highlighted — inputs for a chosen output, outputs for a chosen input — and nodes without such ports step back, as when a link is drawn. Dragging from an output draws a link, as usual. A press on a node, on an empty place of the canvas or choosing another thing takes the choice of the port off.

The choice does not shift by itself. A node chosen on the canvas stays the anchor: the column is tied to it while the person looks through the candidates. A click on a row shows the candidate in the panel but does not rebuild the lists. Linking makes the new node the chosen one, and the column is rebuilt around it.

5.3 The look of a node on the canvas

On the screen a group is called a node: what is built of nodes is a built node, and the workshop does not say the word «group». The tool is «Build into a node», the actions on the label are «Unfold», «Fold», «Take the node apart», in the control bar — «Make a separate process» (5.4), the default name is «Node», and where a built node has to be told from an ordinary one — «built node». «Group» stays a term of the documents and the format (Terms).

Everything that stands on the canvas has one form:

• the label above the left edge of the node, from the point where the rounding of the corner ends — so there is no gap under its lower corner; the state badge stands the same way above the right corner. On the label is the nesting mark at what has something lying inside (The program: graph and runs, section 17) and, at a chosen node, a block of actions with icons; a node without nesting and not chosen has no label. The actions: delete (the hint of the icon names the key Delete too; the panel of the node says nothing of keys), copy, at a folded group — unfold, at an unfolded one — fold, at a group also take apart (The program: graph and runs, 17.1). Making a group a separate process is an action of the control bar (5.4); a refusal the window tells in the words of the cause and names what it is about — nodes, variables or links. An action applies to everything chosen. In the graph of a program that is on a group has only «unfold» and «fold»: they change the view, not the document, and the view holds while this process is open;
• the head — the name of the node and to the right of it the sign of its kind; in an area — a frame and an unfolded group — the name stands at the start of the head: an area may be wider than the window. The colour of the head tells what node it is: for a node — the family of its kind (beginning and end, work, flow, data, waiting — Kinds of nodes, Appendix A), for a group — its own, a sixth. The label is of the same colour. The colours are the settings ui.color.head_* of both schemes (Settings, section 8); there is no red, green or amber among them — they are taken by signals. Besides the colour, the sign of the kind tells what node it is. The shades are defaults; the person changes them in the settings;
• the rows of ports — first the inputs, then the outputs, then the variables the node works with, for a group — the variables of its face. A row of a port holds the name of the port and the point of a link: for an input on the left border of the node, for an output on the right. A row of a variable holds its name and a mark on the border, a square on the corner: on the left for a variable that is read, on the right for one that is written, on both sides for one that is both (The program: graph and runs, 17.1). A frame shows its ports on the borders of its area, and has no row of a variable;
• the rows of parameters — after the variables, as rows «name: value», stand the parameters the person marked in «Edit» of the node, in the part «Seen on the node»; by default none stands. The value is the one set, otherwise what holds without it; a choice is named by its word, one taken from a variable — by the variable. The row is read-only: it has no point of a link and no eye, the parameter is edited in the panel. So the graph is read without opening the panel at every node. What is seen on the node is a view of the graph, not the program: it is marked in the graph of a program that is on too, the mark is written into the saved document at once, does not count as a step of the history and makes no edit that has to be saved;
• the switch «to the face» — an eye sign in each row: an open eye — the row is on the face, a crossed-out one — it is not. A press puts and takes off the mark; a variable is marked the same way. For what lies in a group the mark refers to the nearest group; a folded group is a node of the group around it, and its rows are marked for the outer face. At a node and a folded group of the top level the eye puts a mark ahead — for the face of the node they will be built into (The program: graph and runs, 17.1); the hint of the eye says so. A folded group shows as rows only its face: to put on it what is inside, it is unfolded. A refusal of the graph to take the mark off a port through which a link goes outside is told in words. A folded node does not show the rows of what lies in it, so «Edit» of a built node says where the face is marked;
• a folded frame is drawn in the form of a node: on its label, as on a node of nodes, «Fold» and «Unfold» and the nesting mark, if something lies in its body; the rows are only its ports, by which it is met from outside; what lies in the body is taken off the canvas, and the links to it come to the side of the frame. It is folded and unfolded in place, like a group, with the same giving way of neighbours; in the graph of a program that is on — only for the view;
• a folded group is drawn in the same form, and its rows are its face; what lies in it is taken off the canvas, and the links come to the rows of the face. A group is folded and unfolded in place: when it unfolds, what stands to the right of it and under it moves away by the size of its area, and when it folds, comes back; what lies in the group itself does not move. In the graph of a program that is on the document does not change: the group unfolds for the view, and the neighbours give way to it in what is seen — by the same rule; a program that is off shows the document. An unfolded group and a frame are an area of the canvas with a body inside: the head goes across the top of the area, a frame's border is dashed, a group's solid. A link is drawn from a row of the face of a folded group too: it goes from the port of the node behind this row.
• carrying across a border — a node or a node of nodes taken with Alt is carried from one node of nodes into another: while it is carried, the area it was taken from does not stretch after it, and the node it will lie in — the deepest under the pointer at the same place of the canvas — is highlighted; let go, it lies in it, and outside nodes of nodes it comes out to the level of its place. The face follows the links (The program: graph and runs, section 17). Without Alt carrying only moves: an area stretches after what is its own, and nothing leaves it and nothing enters another's.

Names:

• of a node — its own, set by the person in the panel, or by default: the kind in words, for a module — the name of the module, for a call of a process — the name of the called process (The program: graph and runs, section 4). There is one name on the head; while there is no own one, the default name stands in the middle of the head, and under an own one it is said in small letters what node it is;
• of a group — one: that it is a built node is told by its sign, its head and its level;
• of a port — from the owner: for a kind — its dictionary, for a module — its own (Modules, table 2); the person may give a name to a row of the face;
• there is no identifier on the head — it is a word of the document, not of the person: it is told by the hint of the head and by «Details». The hint of the head is the name, the identifier, the kind and the description of the node, if there is one. A dot before the sign of the kind — there is something unsaved in the panel of the node.

A call of a process. Its ports are the inputs and outputs of the called process under the names the person gave them; in «Edit» — the choice of the process and a field for each of its variables, an empty field shows the value the variable begins with by itself (The program: graph and runs, section 18). In a run a call shows the loudest of what the nodes of the called graph do, like a folded group.

Links go at right angles from the point of an output to the point of an input and go around nodes. The colour of the line is the type of data of the output it comes from: text, picture and file have colours of their own (ui.color.type_*), a link with any data (json) and a link whose type the owner of the port did not name are drawn in the colour of a link of the graph. The point of the port is filled with the same colour, and the hint of the port names the type in a word. Dashed — a link from a variable or a constant, a bright and thick line — a highlighted one (5.4).

Which way a link goes is shown by an arrow: at the input the line ends in a triangle that touches the point of the input and grows with the thickness of the line; a dashed link has an arrow too. An input that several links come to is a row taller for each of them, and each link has its own point: different data come by different links, and the node takes what came first. An output whose links go to several nodes keeps one point, and a little further from it stands a fork point the lines part from: every node gets one and the same copy. The hint of the input names the number of sources, the hint of the fork — how many nodes get the data.

A link is chosen by a press: a chosen link is wider than the others, and the panel says what it joins — from where and to where, by node and port, what data it carries and through how many points it is led — and holds the button «Delete the link»; Delete does the same. The nodes stay, deleting is a step of the history. Choosing a node, a group or an empty place of the canvas takes the choice of the link off. In the graph of a program that is on a link is chosen to be read, but not deleted.

Signals. When the person draws a link, the ports it may be brought to glow green, and the rest are dimmed. A port under the pointer it may not be brought to is red, and the reason is named in the words of the function of the graph: the types of data do not match, the same node, no links enter the node, such a link already exists, the link would cross the border of a frame not through its ports or close a ring outside a frame, a link of another sort already leads to the input; when only the face of a group is in the way — the link would cross its border through a port that is not on the face — the window names this group and says what to mark. An input that already has a source is amber: it can be linked, a merge will appear. In a run the node that works is highlighted; a failed node and a node waiting for the person's answer blink; a node waiting for a signal or for time, and a module node whose step waits its turn at the module, are highlighted steadily. A signal is never given by colour alone: it has a sign or a form as well.

The state of a node in a run is shown by two signs:

• a badge above the right corner of the node with the sign of its state: working, waiting for a signal or for time, waiting its turn at the module, waiting for the person's answer, failed, done, stopped. The words of the state are in the hint of the badge and in the panel of the chosen;
• a ring around the node while something is going on in it: steady at a working one, one waiting for a signal or for time and one waiting its turn, blinking at one waiting for the person and at a failed one. A done and a stopped node carry only a badge: a finished run leaves the canvas calm.

The body of a node does not change its colour with a run: it is ordinary or chosen. A folded group shows the loudest of what its nodes do: a failure before a question to the person, a question before work and waiting; when nothing goes on — that the run passed through it. The state of a group in words — «standing», «working», «error», «partly», «done», «stopped» (The program: graph and runs, section 17) — is named by its panel. Whoever asked the system to remove motion sees no blinking: the state is told by the badge and the colour of the ring.

What a node does the window learns from the run it follows: that a step of a module waits its turn at the module, began and ended, and that a branch stood still, is told by the event node.changed, the rest by the checkpoint, which the window reads again at each such event (Exchange with the kernel, section 7). A window that came to a run already going did not hear the beginnings of steps: about the steps of modules going or waiting their turn it asks process.run.status (Methods of the graph). A packet at a module node whose step is not said to be going waits its turn.

5.4 The bars of the canvas

Over the canvas, by its left edge, stand two bars: on top the tool bar, under it the control bar. Both are the same capsule as the bars of the workshop (section 4), at three quarters of their size: they stand over the work, not beside it. The canvas scrolls under them, and at the start of scrolling the left edge of the graph stands to the right of the bars — at any scale: the room for the bars does not shrink with the canvas. Each bar folds down to its head and shows its labels itself, like any bar: the labels are opened by a strip at the side, folding by the chevron, and the logo of the bar is a sign without an action.

The control bar holds the commands of the program and the actions on what is chosen where the graph is built and looked at in work: what is built is switched on, run and stopped without leaving the canvas, and on the canvas one sees which node works (5.3). The bar holds:

• the switch of the program — on and off;
• for each event of the pulpit — «Run», «Stop» and «Retry»; when there are several events, a command names its own;
• «Go on» — when a run is not going and the graph allows it to be resumed, and beside it «Confirm the retry» — when it asks the person's consent to that (The program: graph and runs, section 14);
• after the commands — the state of each event in its colour; on a press it is told in words in the strip on top;
• highlighting — «Linked» and «Of the same kind»;
• «Build into a node» — builds the chosen nodes into one node;
• «Make a separate process» — the chosen built node becomes a separate working process, and in its place stays a node that calls this process (The program: graph and runs, 17.1). There is no such action on the label of the node.

These are the same shared objects of the program and the same commands as on the pulpit: the list of commands is one, and there is no second button with another meaning (Rules of development, 2.9). «Run» of an event of the pulpit gives the event what is typed on its node (5.5). A command that cannot be carried out now — a run of a program that is off, a stop with no run going, a retry when the last run of the event did not fail — is dimmed; pressed, it says the reason in words. The value of a variable of a program that is on is written in the field of its node on the canvas and in «Details» of its panel — so a variable a parameter takes and whose node is not on the canvas is written too; a variable pressed in the bar «Pulpit» opens there. A question of a run is answered on the node «Question», output is shown by «Show» nodes (5.5); on the pulpit all this stays. The window of the process keeps only the history of runs. While no process is chosen, there is no control bar.

A program is switched on as it is written. While the graph in the window is changed and not saved, the switch of the program does not switch it on and says that the graph is saved first: otherwise the written program would work while the window showed an unsaved graph as its graph — and it could no longer be edited: a program that is on does not change (section 1). The rule is one for all places where a program is switched on: the control bar and the pulpit. A program can always be switched off.

Steps. A program is built in one window — the graph window. In its top right corner stand three signs of steps: «Graph» — the working graph, «Graph of the interface» — a canvas of its own with reflections and graphic nodes (6.8), «View» — the sheet of the interface, where elements are laid out and dressed (6.3, 6.5). The sign of the step the person is on now is highlighted; pressed, the sign of another step changes what the window shows, in its place: the size, place and panel of the window stay. What is chosen goes from step to step: a graphic node is an element on the sheet, and back. Each step remembers its own zoom and shift. The graph is not shown beside the sheet: on the step «View» the graph is not needed, and when it is, one goes back to it by the sign. There is no separate pulpit window and no item «Pulpit» in the bar «Workshop». On the step «View» a program that is on shows real values on the sheet.

The tool bar holds the tools of the graph — «Selection», «Link», «Larger», «Smaller», «Whole graph» — and the search. The column of the window does not have these tools: an action has one place. The column keeps what is put on the canvas — kinds of nodes, installed modules, variables and processes — and the allowed links of the chosen node (5.2).

Modules in the column stand as the section «Modules» under the kinds of nodes: each installed module is a ready node by its name, in the order of the names. Pressed, a module is a tool that puts its node; carried onto the canvas, it is put where it was let go. The node stands at once with its module and is named by it (echo_1); there is no need to choose the module in the panel. There is no faceless kind «Module» in the column. While there are no modules, the section says so, and its row opens the window «Modules», where they are installed.

The search by name looks for a node on the canvas by its name — its own or the default one — and by its identifier; capital and small letters are alike. The search field is opened by the sign «Find» in the tool bar or the key Ctrl+F; it stands over the canvas beside the bars. What is found is highlighted, the rest is dimmed, and the field says how many are found, and after a choice — which of them is chosen («2 / 3»); Enter chooses the next node found and scrolls the canvas so that the node stands in the middle of what is not covered by the bars and the panel, Shift+Enter the previous one; after the last comes the first. The found ones go in the order the graph is read: from left to right, and in one column from top to bottom. Esc closes the search before it takes off the selection; pressing «Find» again closes it too. The search field takes no room over the work: the panel does not shift because of it. A node inside a folded built node is found by the built node: it is the one highlighted and chosen.

Highlighting is switched on and off by a press and is counted from what is chosen; «Linked» is on from the start. While a link is being drawn or a port is chosen, the highlighting of the bar steps back: the canvas highlights what fits them, and highlighting must not dim a fitting node.

• «Linked» — the nodes and links on the paths through the chosen node: everything that leads to it and everything that goes from it. Branches that share only a source with it are not highlighted;
• «Of the same kind» — nodes of the same kind as the chosen one; for a module node — nodes of the same module.

What is highlighted stands out, the rest is dimmed: a highlighted link is thicker and brighter, a highlighted node has a second border — an outline outside its own, so that what is highlighted is seen even where there is nothing to dim. A chosen group counts as everything in it; a folded and an unfolded group is highlighted if at least one of its nodes is. While nothing is chosen, nothing is dimmed. The graph of a program that is on is highlighted and looked at in any scale, but not edited: «Link» and «Build into a node» are not available there.

5.5 Checking in the graph

What is built is checked where it is built: trying is part of building a working process, not something that follows it in another window. For this, everything a process is given data with and shows them with stands on the canvas (The program: graph and runs, section 24):

• a node of an event, a question, a variable and a constant carries an input field: text is typed, and a file, a picture or a sound is chosen right on the node. The node «Wait for a signal» carries a field to send a signal by hand: to whom — by the key of a waiting branch, what to send and «Send a signal»; when nobody waits, the node says so. What is typed goes on along the link, so the middle of a graph can be checked, not only the whole process from the start;
• a display node shows on the canvas what came into it: a text is read, a picture looked at, a sound listened to.

These nodes are part of the program: the graphic nodes of the interface are bound to them (6.8), and the finished program takes and shows data through them too.

The cause of a refusal is seen in the graph: under a failed node a short cause in words, on the tab «Details» of its panel — the details: the code, the words of the module, the run. Under the node — no more than two lines, whole with the code — in the hint; the words are those the refusal itself named, and for a refusal of a module without such words — what the module wrote: that is the cause; for a refusal of the platform — the words of its code. A folded built node tells the cause of the node inside. A step that failed and passed on retry shows no cause. Trying is by hand: data are given and the result looked at.

The course of a step of a module is seen on the node: while a step of a module goes in the run the window follows, a bar runs along the bottom of the node — the share of readiness the module sends with the notification progress (Modules, section 7); the hint of the bar names the share in percent. A module that sends no course gets no bar: the node is simply marked as working. A new step of the node starts the bar from the beginning, a finished step removes it. So a long step — loading a model, drawing a frame — does not look stuck.

What the graph can do right on the canvas:

• the program is switched on, run and stopped in the control bar (5.4); a working node is marked on the canvas (5.3); a node and a group are started on their own from the panel;
• «Show» under the rows of the ports shows what came: text with line breaks, a number, a list by items, a record as rows «field: value», a picture, sound and video with a player; a file of another kind and a file larger than 64 MiB — by name and size; the whole of the same is seen in the hint;
• the fields of an event — a field for each thing it takes: text, number, «yes/no», list and data are typed right on the node, and the sign «Run» starts the event with what is typed; a timer, a clock and switching on have no fields — the data are given by the source. An event with a file field and no file chosen does not start;
• the field of a constant edits its value in the graph: what is typed is marked until it is entered with Enter, and is taken back with a step back; in a program that is on the field is closed;
• the field of a variable in a program that is off shows the initial value, in one that is on — what the program holds, and writes what is typed;
• a question is shown on its node: what is asked, the answer field, «Answer» and «Decline», for «yes/no» — «Yes» and «No»;
• files. A picture, sound, video and file are chosen in the field of an event, a constant, a variable and a question: the file is passed to the process in parts, its name stands in the field, a reference in the value; the file of an answer goes to the run that asks.

5.6 The library

The library is the window of everything the person has: programs — built here and taken in — installed modules, neural networks and pieces of interface. Here a thing is made, taken in, handed out, deleted, and where it is seen is decided; it is built in the workshop. The library is the first item of the bar «Platform».

• The column on the left — «Programs», «Modules», «Neural networks», «Pieces of the interface», «Sources» and «Panels on the right»: the panels of programs the person made, and «New panel».
• Programs. Above the list — «Create a program» and «Take a program in» from a folder (Building, installing and maintenance, 5.6). A chosen program has the panel of the chosen: «About» — the identifier, on which panels it stands, whether the column of the graph offers it; «Open» — its face (6.6), «Open in the workshop» — the graph window with it, «Hand the program out» — into a folder, «Delete the program» — after a question that names what goes with it; «Where seen» — the mark «On the panel «…»» for each panel and «In the column of the graph — to build other programs from it»; «Networks» — which neural networks the modules of the program take by default, a row per network with the modules that take it, whether it is in the folder of networks and, if it is not and the module named where to take it from, — «Download» (5.6, «Sources»). «Site» — what ogas.space says of the program: its version on the showcase, reviews with the author's answer, known and solved bugs with the author's word; «Leave a review» — for a program that is on the showcase: whether it works, words, incognito, while the window puts in the version, the platform and the video card itself; «Report a bug» — what was done, expected, happened, a piece of the journal; «Offer to the showcase» — a title, a description, the number of a request if this answers it; for the author of the thing — «Answer under the review», «A word on the bug» and «Solved in the present version». All of it goes as a parcel of the profile (5.10); without a profile the tab leads to the window «Profile».
• Modules. Above the list — the name of a new module, «Create a module» and «Take a module in»: the module folder that was sent is put into the data folder and its path named; the window first shows what the module will bring — its name in words, the version, files and size, what it will download when the environment is prepared, whether it is already here — and writes nothing; only a module that is not here is taken in, and, like making one, after the question of trust; the print of the copy is compared with the one shown (module.inspect, module.import, Methods of modules). A chosen module has: «About» — description, identifier, version, «Hand the module out» — its folder into exports/modules/<id> of the data folder — and «Delete the module» after a question — a module a program holds is not deleted, and the status line names the programs; «Where seen» — «In the column of the graph». Making a module and installing the environment of a program are code without a sandbox, so before the first such action in a session the workshop asks about trust, from whichever window it was asked (Protection, 3.1). «Site» — the same as for a program.
• A panel of programs is a category the person makes themselves: its name, its place among the panels («Panel higher», «Panel lower»), the programs on it in their order, and «Delete the panel». A program is put on a panel with the sign «+», moved with the signs «higher» and «lower», taken off with a cross. One program may stand on several panels. A program taken off a panel and a deleted panel of programs do not delete anything: the programs stay in the library.
• Nothing is put by itself. A new and a taken-in program stands only in the library until the person puts it on a panel. Before the first edit there is one empty panel named by the word of its section, «Programs»; like any, it is renamed and deleted.
• The column of the graph offers programs — to insert the graph and to call (The program: graph and runs, section 18) — and modules, except those the person hid in the library. Programs and modules are offered until hidden: a new program is built of ready ones. What is hidden stays installed: a node already standing in a graph works, and a call that already names a program keeps it.
• The library is kept by the function ui in config/library.json, beside the layout (File formats, 7.3); it is written whole after each edit. A program or module deleted from the workshop leaves it by itself; a program whose folder was removed by hand is not shown on a panel.
• Neural networks and other big data modules of different programs use lie in the library in one copy, with no copies at each module, in the folder of networks — a subfolder for each kind (Modules, section 11). Above their list — the folder of networks as Windows sees it — a file or folder of a network or a link to them is put there — the field «Folder of networks», where another folder to take them from is named (the setting modules.models_dir), and «Look at the folder again». Below — the kinds, each with the modules that take it, and the networks of the kind with their size and the modules that take them when a node chose no other; in the panel of a network — the kind, the size, whether it lies as a file, a folder or a link, and «Delete the neural network» after a question: a network a module takes by default is not deleted, and the status line names the modules. The information of a module holds the kinds of networks it takes, with the default network.
• Pieces of the interface — containers of the graph of the interface with everything in them, kept to put them into other programs (6.8). Here they are seen — the name, how many containers and graphic nodes — and deleted after a question; they are made and put in the graph of the interface.
• The set of built nodes is the library. A built node is a program of the library, and the column of the graph offers to put it in two ways with an explicit choice: by insertion — as a copy of its own, edited without touching others — or by a call by reference, and then an edit of the program reaches all the places where it is called (The program: graph and runs, section 18). There are no closed built nodes: any is opened and its graph seen. A built node has no version of its own. It is handed to another person as a program folder, like any program.
• The view (in all sections). Above the list of any section — «Tiles» and «Table»; a section remembers its view (views of the library, File formats, 7.3), tiles from the start. A tile is a preview and the main facts of a thing, a table columns, and a click on the name of a column sorts by it, a second one in reverse order. What is shown:
• a program — a preview: the outline of its graph, nodes and links; the description; how many nodes and modules; how much it weighs itself and, separately, its Python environment; when it changed; how many past runs it keeps; on which panels it stands (process.summary, Methods of the graph);
• a module — the name and identifier, the version, how much it weighs and how many files are in it, which networks it takes, how it lives: for a step, for a run or as a service; a module with a spoiled manifest is marked;
• a network — the name, the kind, how much it weighs, whether it lies as a file, a folder or a link, which modules take it, when it changed;
• a piece of interface — how many containers and elements are in it;
• what is found at a source — a picture, if the source gives one (Civitai — the first picture without the mark «for adults», a showcase — the field preview), the name, the author, the kind, how many downloaded and liked it, the licence, when it was updated, how much it weighs, if the source says. The picture is brought to the window by the function of sources (Protection, 3.14): the window itself does not go to the network.
• Picking and hardware:
• «Find here» picks the things of the section by name, description and facts, capital and small letters alike;
• «Order» — by which fact the tiles and rows stand, like a click on a column of the table; the arrow beside turns it over;
• «In groups» — programs by panels (a program on two panels stands under both, on none — last), modules by how they live, networks by kind with the modules that take them, what is found at a source — by task or type. A section remembers «In groups» and its view; networks are shown in groups until the person says otherwise;
• above the things — what the computer has: the video card, its memory and how much is free, memory, cores, room on the disk of the networks (module.hardware, Methods of modules);
• the fact «Video memory» on a thing: for a module — from its manifest, for a program — of the most demanding of its modules, for a network — its weight with a margin of a fifth for the work, for what is found at a source — the weight the source names, and in the panel — the weight of the chosen files of the model (weights, parts, adapters, without settings and descriptions; of several variants of weights — the heaviest, because one is loaded); for a program and a module of a showcase — what the showcase says;
• a thing that needs more video memory than the largest video card of the computer has is marked «will not fit the video card»; the switch «Only what will run» hides such things and says how many it hid. A thing of which it is not known how much it needs is not hidden; if no video card was found, the switch is not available.
• Sources — where programs, modules and networks are downloaded from at the person's command:
• Which. The O.G.A.S. showcase — by default ogas.space — and other showcases the person named; Hugging Face; Civitai. The address of each is a setting of the function of sources, so a mirror can be named instead of the site (Settings, section 8). In the column on the left under «Sources» stands each source.
• Search. Above what is found — a search line and «Find»; beside it is said that the search goes to the site of the source. An empty search shows the whole showcase, and for Hugging Face and Civitai the most downloaded. A row of what is found — the name, the author, how many downloaded it, the kind.
• Picking and order — as the source calls them (sources.facets): for Hugging Face — the task (text-generation, text-to-image…) and the library (transformers, diffusers, gguf…), for Civitai — the type (Checkpoint, LORA, VAE…) and the base model (SD 1.5, SDXL 1.0, Flux.1 D…), for a showcase — program, module or network; the order — most downloaded, most liked, newest. Choosing a filter or an order searches at once; typed words go only on «Find».
• The panel of the chosen — the description, the licence, the page on the site, how many parameters the thing has and how much video memory it needs, if the source names it, and the files with their sizes. Files that run code when read are marked and are not chosen by themselves (Protection, 3.14).
• Files by role — weights, parts of the model by its folders (unet, vae, text_encoder…), adapter, settings, tokenizer, description, pictures — with what one variant of the weights differs from another by: the GGUF quantization level (Q4_K_M, Q8_0…), precision (fp16, fp32), pruned or full. The own files of a program and a module stand under the word «Program» or «Module»; a thing whose files have one role is shown without headings. A showcase may name the role and the variant of a file itself, and for a program and a module — how much video memory they need (File formats, 17.1).
• Versions and relatives. At Civitai — the versions of a model, each with its own base model and files; another version chosen in the panel is read anew, and the one shown is downloaded. At Hugging Face — which model this one is made from (a click opens it) and the relatives: quantized, fine-tuned, adapters, merges — a click shows them among what is found, with the button «Search by words».
• Downloading. For a network the person chooses the kind — the folder in the folder of networks — and the name under which it will stand; the kind is offered beforehand from what the source calls the thing — the task of Hugging Face (text-to-image) or the type of Civitai (checkpoint, lora) — and can be changed; while «Download» cannot be pressed, what it lacks is said under the button; «Download» shows how much will go onto the disk. Downloads go above what is found with their share of readiness and «Stop». When done, a network stands in the folder of networks, a program and a module wait for «Take in the program» and «Take in the module», a piece of interface for «Take the piece in» (without the question of trust: there is no code in it). A network for which the source demands signing in is not downloaded, and the status line says why: the platform keeps no keys of sources.
• There is one checked showcase — ogas.space. Above what is found at another showcase it is said that other people keep it and nobody checked it. A program or module from there the platform takes in only after the question of trust — every time, with the address of the showcase, even if the person has already trusted modules in this session (Protection, 3.14).

5.7 The assistant

The assistant is a window where the person gives a task in words, and a connected network builds a program or a module with the tools of the platform, checks and tries them, and says what it did (Methods of the platform services, section 6).

• The column — «New task», «Network of the assistant» and the tasks: each has the sign of its state — going, answered, stopped, hit its limit, did not work out.
• The work area — the conversation of the task: the person's words on the right, the assistant's answers on the left, and between them what it did, as rows: ✓ — the action went through, ✗ — it was refused; the pointer held over a row shows what the action was called with and what it answered. Under the conversation — a field for words, «Send» (Ctrl+Enter), while the task goes — «Stop», for a task that hit its limit — «Go on», the switch of access, «Ask people» and the spending of the task: steps and tokens.
• Marks of the platform. If the network ended its turn having written nothing, the platform reminds it of that once, and the conversation holds a mark. If nothing was written after the reminder either, under the answer it is said that the assistant's words about what it did are not confirmed; if the last attempt to write a graph, a pulpit or a file of a module was refused, it is said that it was not written.
• Access. «Drafts only» — the assistant changes only its own drafts and modules and switches nothing on. Extended access is switched on with the switch; before that the window warns that the assistant will be able to change the person's programs and switch them on, and that the person is responsible for what it does.
• «Network of the assistant» opens a panel: the choice of a network from the ready networks of OGAS SDK — the chosen one is put into the folder of modules — its settings, the key field and, for a local network, the neural network from the folder of networks and the program in whose Python environment it runs. The key goes into .env of the module of the network and does not stay in the window; the field only says whether it is set.
• «Ask people» opens the window «Profile» on a new request with the task written into it: the request goes from the platform, signed by the profile (5.10). The window opens in the browser only pages of ogas.space — the documentation of «Help».

5.8 The door for programs

In the settings, in the section «Door for programs», besides the settings of the door themselves — whether it is open, the port, how many programs it lets in — stand its state, the key, hidden until «Show the key», «Copy» and «Make a new key» (Methods of the platform services, section 5). A new key turns out all programs that came in with the old one.

5.9 Room, Windows and files

• The room on the disk — in «Status» of the window of settings: how much the platform takes in all, the limit it is given (core.disk_budget_gib), what is free on the disk and how much more may be taken, and below — by parts: programs, runs, Python environments, the cache, modules, neural networks, downloads, the journal. The Python cache and the downloads not taken in can be cleared right there: the window asks again, and what is missing is downloaded again when needed. The rest is taken away where it lives: runs — at the program, networks — in the library, months of the journal — in the journal. A download, an install of an environment and a run that would not fit do not begin and say why; the platform removes nothing by itself.
• Resources for modules — in the settings of modules: how many modules do a step at the same time, how much memory and how many processor cores they take together. A module that goes past the memory is stopped, and the step says why.
• Memory and processors of WSL — also in «Status», below the room. This is the file .wslconfig of Windows, shared by every distribution of Linux on the computer; the window says so before writing, and the writing acts when WSL starts again.
• A file of Windows is given to a program in two ways: by a press of the field for a file — the dialog of Windows opens, at the folder of the setting «Folder to choose a file from», with the files of the kind asked for first — or by dragging a file from the Explorer onto that field. Linux copies the file whole, once; its contents do not go through the window. A file let go in the wrong place is not lost silently: the window says where to let it go. A folder in a setting that needs one (the folder of networks) is chosen in the same dialog — «Choose…».
• Sleep — while a run of any program goes on, Windows does not go to sleep (the setting «Stay awake while a run goes»): a sleep would stop WSL and the run with it.
• Shortcuts — «Make a shortcut» at a program in the library puts on the desktop a shortcut that starts the platform, switches the program on and opens its face; the setting «Start at the sign-in to Windows» puts the shortcut of the platform among the programs Windows starts and takes it away when turned off. A shortcut runs not wsl.exe but the starter ogas-start.exe — a program of Windows with no window that hands its words to wsl.exe with no console and ends: no window of the console stands on the screen while the platform works. The starter comes beside the window program, and it puts the starter into %LOCALAPPDATA%\OGAS on the disk of Windows; when it cannot — the shortcut runs wsl.exe with the console minimized.

5.10 The profile

Profile — a window in the bar «Platform»: the person's profile on ogas.space, their sendings and the board of requests (Methods of the platform services, section 7; what guards against what — Protection, section 8). Everything the person does on the site — a review, a request, «I'll do it», a bug report — goes from here and from the library, signed by the profile; the site has no accounts.

• The first window. A platform without a profile opens this window at start until the person says «Later» (the setting profile.ask_at_start). The platform works without a profile; a profile is needed only to send to the site.
• «Profile» in the column. Without a profile — the card (name, about, links to one's places on other networks, whether to show the page), «Make a profile», «I have a profile» and «Later». A profile made shows the recovery code once, large, with a warning to copy it onto paper, «Save as a file…» — into a folder chosen by the window of Windows, with a password if wished — and «I wrote the code down», after which the code is never shown again. «I have a profile» signs in with the code or the key file. With a profile — the number on the site, the start of the key of this computer, the card and «Save the card», «Revoke all computers but this one», «Delete the profile» — all three only with the main key: the code, or the key file with its password — and «Sign out on this computer». What is dangerous is pressed twice: the first press changes the label to «Press again».
• «Sendings» — «Check» and what became of each sending: waits for the look of the author of the site, on the site, accepted, rejected, answered; the unsent — with the reason and «Send again»; while a parcel goes — «counting the task…», «going…». Below — the letters: an answer to a bug report, a bug in one's own thing whole, a new review of one's own thing.
• «Report a bug» — a bug of the platform itself: what was done, expected, happened, the output of doctor, a piece of the journal; the version goes by itself. Only the author of the site reads the report, and the answer comes as a letter in «Sendings».
• «Requests» — the board of requests of the site, «Leave a request» (what the program does, what goes in and out, a neural network, the video card, an example, incognito) and «I'll do it» at each request.
• New letters and changed states found by a look at the site at start are said by the workshop in the status line.

6 The pulpit

6.1 The purpose of the pulpit

The pulpit is a full graphical interface of a working process. The person builds the pulpit themselves, without writing code: takes into the interface what the program gives (6.4), shows it by elements on the graph of the interface (6.8), lays the elements out over sections and sheets (6.3) and gives them a look (6.5). It is built on the step «View» of the graph window, and used over the whole window — on the face of the program (6.6).

The constant properties of the pulpit:

• an element of the pulpit is tied to a shared object of the graph by object_id: an event, a variable, the state of a run, a question or switching the program on; the meaning of the object is the graph's (The program: graph and runs, section 16);
• the pulpit computes nothing: the action of an element is an event or a command to the owner of the object, an input element writes a variable, a showing element shows a variable or a state;
• the document of the pulpit is workspace.json of the process, the owner is the function canvas;
• the layout of the windows of the workshop is not part of the document of the pulpit;
• the pulpit on the step «View» and on the face of the program is drawn by one and the same code, and this code does not depend on the frame of the workshop: what is built in the workshop looks the same on the face of the program.

There is no pulpit on another computer and there are not several pulpits of one process.

The structure of the pulpit is built with the graph of the interface (6.8).

6.2 The elements of the pulpit

The set of elements is closed and is extended by the platform. A module brings no elements of its own: an interface element of a module would mean outside code in the window, and hence a sandbox, versions and a foreign look.

The behaviour of an element is closed: what it shows, what it takes and what command it sends. The look of an element can be replaced (6.5): a look is pictures and numbers, not code, so the reason the set is closed does not concern the look.

An element is not a node. An element is attached to a shared object of a node, a process or a group and is combined with others: one module node may have fields for its parameters, a run button and a bar with the result.

Elements are of four families (table 2).

Table 2 — Families of pulpit elements

The family of an element and the kind of an object must fit each other: a showing element is not attached to a run, an action element not to a variable. The workshop shows an unfit combination before saving. An element whose object was removed from the graph or no longer fits it — say, the type of a variable was changed — does not disappear from the pulpit: it stays in its place and is marked.

An element is attached to one object or to several — as many as its description names:

• an event button carries with it the values of the variables the person named: they go as the data of the event, each under its own field name (The program: graph and runs, section 5). The value is taken at the moment of the press and goes with the packet, so runs that queued up get each their own;
• a variable taken by the parameters of several nodes lets one input element control them all. The pulpit has no way of branching of its own: the variable branches.

A program with settings is built of the same elements; for it the elements have two things:

• a hint. Each element except a decoration may have the person's hint: what it sets and which way to turn it — «More steps — a cleaner picture, but longer». The window shows it when the pointer is held over it and tells it to a screen reader; it is edited with the row «Hint» in the panel of the element, beside the label;
• «Return as it was». A button bound to a container of the pulpit (resets) returns to its initial value each variable written by the input elements in it at any depth: a group of settings, a tab, a window. The initial values are known to the graph, and the return is the same kind of writing by the person as typing in a field: the event of a change of the variable hears it (The program: graph and runs, section 5). No «Write» nodes for each setting are needed for this.

A second button with the same meaning is not allowed: a document where one section holds two elements of one kind with the same objects is refused by the function of the pulpit. One object in different sections or in elements of different kinds is allowed: a stop button on each section, a variable as a field in the settings and as a value on the main sheet. The rule does not concern decorations: a decoration has no object, and there are as many of them on the sheet as needed.

The set, with one default look, grows from a working minimum: an element is added when a built program lacks it. The list of elements belongs to the function canvas: the window shows it but adds no elements of its own. Each element is a finished part in its own folder (Rules of development, 2.10): a description, a dictionary and built-in looks. The make-up of the first set by kind, the names of bindings and parameters — File formats, section 7. Marking up a picture is given by a question with the answer «area», editing a shown text — by a question with an answer as a line whose field is filled with this text (The program: graph and runs, section 9); marking up sound and recording from a microphone are the work of modules. Choosing the neural network a node takes is the same «Choice», whose variants are the networks of one kind from the library, bound to the variable the node takes its network parameter from. There is no element of its own for a network: an element chooses a value the same way, wherever the variants come from.

6.3 Sections and the sheet

A pulpit consists of sections: «Main», «Settings» and any others the person made. Sections are the tabs of the pulpit. An element lies in one section.

A section has its own sheet — a field of a set width and height. The tabs of one window have one sheet: a size set on one tab is taken by all tabs of the window, and is no smaller than what stands on any of them needs. Elements are placed on the sheet freely: an element has a place and a size, the person puts it where they want; when dragging, it is drawn to the grid and to its neighbours. Elements may lie one over another — so a frame lies under buttons. The order of elements in the document is the order they are drawn in and the order of going round with the key Tab.

The sheet grows with the window. The size the sheet was drawn at is the least. A window smaller than that shows the sheet whole and smaller, with the same arrangement of elements; the sheet does not get smaller than a set limit — then the field scrolls. A window bigger than that is filled by the sheet whole, the underlay too, and there are no strips at the sides: elements do not change their size but hold on to an edge. Across, an element stands at the left, at the right, in the middle or stretches; down — at the top, at the bottom, in the middle or stretches: so it keeps its place against its edge, and a stretched one takes what the window adds. What the element does is set by the row «When the window is bigger» in its panel; without it — by its kind: a field, a table, a view and rows stretch across, a button keeps to its side of the sheet — the half it stands in —, and a table and a view with nothing under them on the page stretch down as well; the rest keeps to the top left corner. The frame of a group grows with what lies in it. The reason for the choice: screens are of different sizes, and a finished program is spread over the whole screen, and it matters to the person that an element stands where it was put — so the layout is not rebuilt but stretched by rules that are seen and set in the panel.

Checking sizes. On the step «View» the sheet is laid out at the size it was drawn. The signs in the bar over the sheet show it in a window of another size — «As drawn», «Narrow window», «Wide window», «Whole screen»: in such a window the sheet grows as on the face of the program, and nothing is laid out there; a window bigger than the work area is shown whole, smaller.

The pulpit works without laying out. An element put on the pulpit without a section goes into the section open on the step «View», and one put from the graph into the first section. The place and size are given by the function of the pulpit, not by the window. Laying out and dressing are done over a pulpit that already works and are not a condition of its work.

Laying out is always free. Each page — a tab of a window or a window without tabs — always has a sheet, and everything that lies on it at any depth stands on this sheet with its place and size; there is no button «give a sheet». The first place is where the page would put a thing itself (6.8): the function of the pulpit gives it when a thing is put without a place. What is put into a page where something already stands lies under what stands; on the step of the sheet.

Not placed. An element and a frame on the sheet have three states: on the sheet, not placed and deleted. An element that is not placed is in the graph of the interface with all its bindings and its look, but has no place on the sheet: it lies in the column of the step «View», in the part «Not placed», and from there it is laid on the sheet by a press — at its former place if that is still on the sheet, else where the page would lay it itself. «Take off the sheet» in the panel of the element and of the graphic node takes it off the sheet; a frame is taken off the same way — in the panel of its container on the graph of the interface, with all that lies in it. A new graphic node put on the graph of the interface is not placed at first: the function of the pulpit gives it no place by itself. On the face of the program what is not placed is not seen, but its bindings work: the variable is written, a container is shown and hidden by its own. An event button, an element of input and a question must be seen to be used: such an element that is not placed is marked in the column with a warning sign, which says a person cannot use it. «Delete the element» removes it from the program.

A group on the sheet is a frame around what lies in it: the frame is counted by the function of the pulpit — margins around and a head with the name on top, for a container of tabs the head is its switcher; the frame has no place and size of its own, except an empty group, which stands where it was put. So what lies in a group is always inside it: the frame grows after what is its own. What is put into a group lies under what stands in it, and what stands under the frame goes down by as much as the frame grew. The tabs of a container of tabs inside a page lie one above another in its frame; the open one is seen. The switcher in the head of a frame is one line: the names of the tabs are written in the letters of the sheet, like elements, and grow and shrink with the sheet; what does not fit is shortened with an ellipsis rather than lying over what the frame holds.

Elements are laid out on the step «View» (5.4): the sheet is always edited there, there is no switch «Arrange», and the pulpit is used on the face of the program (6.6):

• carrying — the chosen element is carried with the pointer; a press chooses an element at once, a press without moving changes nothing. While an element is in hand, it is drawn where it is held, over the others, and names its place and size; it goes into the document of the pulpit when let go, as one step of the history;
• size — a chosen element has eight handles: at the corners and at the middles of the sides. A side or a corner is pulled; the opposite side stays in place. An element does not get smaller than the smallest size of its kind;
• drawing to lines — a corner of an element stands on the step of the sheet; an edge that came nearer than half a step to an edge of another element, to the edge of the sheet or to the margin from the edge stands on that line, and the line is shown across the sheet. So two elements stand close or level even if the neighbour stands off the step. With the key Alt nothing helps: the element follows the pointer by a unit of the sheet. The device is the same as for windows on the host (section 5);
• keys — the arrows shift the chosen element to the next line of the step, with Alt by a unit of the sheet;
• numbers — the place and size of an element stand as rows in its panel, the width and height of the sheet in the panel of the section: what the hand does roughly is set exactly there. A number with which the element does not fit on the sheet or is smaller than its smallest size does not go into the pulpit: the row stays as typed, the window names the reason. The sheet is not made smaller than what stands on it;
• several elements are chosen by pressing with Ctrl or Shift — it marks one more or lets a marked one go — and with a frame: dragging with the same key over an empty place of the sheet stretches it, and the frame let go adds to the chosen the elements of the page that lie in it whole. A press on one of the chosen carries them all: each goes by as much, and none beyond the edge of the sheet; the arrows shift them the same way, Delete removes all. The panel shows the element chosen first, and above its rows — the part «Chosen» with the number chosen and six actions of alignment: left, right, top or bottom edges — by the outermost of the chosen, middles across or down — by the middle of all together. Each of these actions is one step of the history; several chosen elements have no handles: they are carried, not pulled;
• an element is not carried beyond the edge of the sheet, neither by hand nor by a key;
• a frame — the frame of a group is carried by pressing on it: everything that lies in it at any depth travels with it, in sight while the hand holds it, and what is let go stands as one step of the history. A frame is drawn to lines like an element: to the step and to the edges of what it does not hold. A frame has no size of its own: what is in it stretches it.

The step helps the hand and is not a must: a place set by a number or with the key Alt is not moved to the step by the function of the pulpit. The order of elements does not change by hand on the sheet — it is changed in the panel, «Earlier» and «Later»: an element put later lies over.

The numbers of the sheet are settings of the function of the pulpit (Settings, section 8): the size of a new sheet, the step, the margin from the edge and the gap with which the function gives a place itself, and the limit of making the sheet smaller on the screen. The window gets the step, the margin and the limit from the function of the pulpit together with the surface and keeps no numbers of its own. The smallest size and the default size are named by the description of each element. A process may have numbers of its own — at the level of the settings of the process; they travel with it.

The format of the document — File formats, section 7.

6.4 Into the interface: reflections

What the program gives its interface is chosen by the person: a node as a whole — its event with its stop, repeat and state, a question, «Show», the course of a step, — an input, an output, a parameter, a variable, an assembled node — by its face. Only what is chosen goes: of a module with a heap of inputs and outputs the one thing needed goes into the interface. A thing taken whole — a node, the face of an assembled node — takes in the reflections of its rows taken one by one, and those the function of the pulpit made (6.8): a thing has one reflection, and so has a row.

The action stands in the panel of the chosen, on the tab «Edit», in the part «Into the interface»: at a node — a row for each thing that can be taken, at a variable — itself, at an assembled node — its face. «Into the interface» puts on the graph of the interface a reflection (6.8) — a node whose rows are these objects. A row names what is taken «In the interface» and says how many graphic nodes show it; it offers the kinds of elements to show or set it with — the one pressed puts such an element, bound to the reflection and not placed on the sheet (6.3), — and «Show in the interface». One can take from the side of the interface too: the column of the graph of the interface offers «What the program has», and there too — switching the program on, which no node has (6.8).

A reflection is not a node of the working graph. It is not part of the document of the graph, has no links, and a run knows nothing of it: it is a part of the document of the pulpit that names objects of the graph. The reasons:

• a link of the graph carries packets; a tie of the interface drawn on the working graph with the same line would mean something else and confuse both;
• inserting a process, calling a process by a node and turning a group into a process work with the graph and know nothing of the interface (The program: graph and runs, sections 16–18);
• the pulpit finds an object by its object_id, follows its renaming and marks a missing object (6.2) — a reference is enough for that.

«Into the interface» does with the graph what the person would do by hand (The program: graph and runs, section 16):

• an event, a question, «Show», an input, an output, a variable — the object is already there: the reflection names it;
• a parameter of a node — a variable with the type and value of the parameter is made, the parameter takes it ({ "variable": … }), the reflection names the variable;
• an input an input element is bound to — a variable with the type of the input and its node are made, whose cold link gives the input; the row of the reflection becomes this variable. An input element is not put on an input links already come to.

The variable and node made are an ordinary edit of the graph: it is seen on the canvas, taken back together with other edits and not available in a program that is on. A parameter already taken from a variable keeps its variable: a second one is not made.

On the working graph a node something of which is in the interface wears a sign on its head, before the sign of its kind, with a hint of how many reflections it has; a variable in the column is marked. «Show on the graph» in the panel of a reflection leads to the original, «Show in the interface» in the panel of a node — to the reflection. A removed reflection removes the bindings of graphic nodes to its rows; the node and the variables made for it stay in the graph until the person removes them.

The pulpit on the screen is checked against the graph on the screen, not against the written one: a variable made a minute ago is already an object for the pulpit. Both documents — the graph and the pulpit — are written each by its own window.

6.5 The look of an element and the theme of the pulpit

Graphics are one of the foundations of the pulpit: the pulpit must look like the interface of this program, not like a form of identical buttons. The behaviour of an element is set by the closed set (6.2), the look can be replaced. There are three layers of graphics:

1) the theme of the pulpit — the palette, the font and the roundings of one pulpit; kept in the document of the pulpit; 2) underlay and decorations — a colour or a picture under the sheet of a section, and decoration elements: labels, frames, pictures; 3) the look of an element — how the element itself is drawn. Each element of the set has built-in looks. The person puts a look of their own together from pictures for the states of the element — «not pressed», «pressed», «not available», positions of a pointer, divisions of a bar — and numbers for them.

A look is data, not code: a description file and pictures beside it. The pictures are made in any graphics editor; the platform holds no editor of its own for them. The pictures of the pulpit and its own looks lie in the process folder and travel with it (The program: graph and runs, section 1; File formats, 7.2).

The look of the set is one by default: a pulpit without a theme and own looks is drawn with the built-in looks. The look of the pulpit does not mix with the tokens ui.* of the workshop (section 7): nothing on the sheet is drawn in the colours of the workshop, and the pulpit looks the same in a light and in a dark workshop and on the face of the program. Only the tools of laying out — selection, handles, the line of drawing to — are drawn in the colours of the workshop.

The theme is nine keys: the background of the pulpit, the colour of elements, the colour of letters, the colour of action, the colour of done, the colour of stopping, the font, the height of letters and the rounding of corners. The colour of action — an event button, the fill of a bar, a switch that is on; the colour of done — the indicator of a run that went through and the retry button; the colour of stopping — the stop button, a failure and the mark of an element that does not work. The colour of letters over a fill the window chooses itself — the letters or the background, whichever reads better; outlines and fields come from the colour of letters and the colour of elements. The font is chosen of four: the font of the platform, a Windows font, serif, monospaced. The height of letters and the rounding are counted in units of the sheet and change with it.

A key of the theme the pulpit did not set is taken from the settings: the section «Default look of the pulpit» (Settings, section 8). So the person has one look for all their pulpits and one of its own for a pulpit they gave it to. The list of keys and what each takes is the same settings schema of the function of the pulpit: there is no second description.

The look is set on the step «View»: the sign «Look» in the bar over the sheet opens the panel of the pulpit itself — the theme and the pictures. A colour is chosen in the colour picker of the system, as in the part «Own look»; a key the pulpit did not set shows in its row, in grey, what the settings give, and the sign «Return» lets the key go back to the settings.

The underlay of a section — the colour of the sheet, a picture under the sheet, or both, the picture over the colour; it is set in the panel of the section, the colour in the colour picker of the system, like a colour of the theme. The underlay picture is stretched over the whole sheet, and over a sheet grown with the window too.

Decorations are put from the column of the step «View», from the list «Decorations»:

• a label — words on the sheet; it has its text, the height of letters and where the words stand: left, middle, right;
• a frame — outlines what belongs to one matter; a new frame lies under everything that lies in its section;
• a picture — a picture from the folder of the pulpit; fitted whole, over the whole area with cropping, or stretched.

A decoration is carried, pulled and removed like any element; it has no label and no other look.

The pictures of the pulpit lie in the process folder and go with it when it is handed over (File formats, 7.2 and 10.1). A picture is added in the panel «Look»: a button opens the Windows file picker, and the page gives the function of the pulpit the file itself, not the path to it. PNG, JPEG, GIF, WebP and SVG no larger than set in the settings are taken; the file is checked by its name and its content, and is shown only as an image — nothing of it is run. A picture named by an underlay or an element is not removed from the folder until it is taken off the sheet. An element and a section whose picture is not in the folder stay in place and are marked.

The visual editor of a look: the look of an element is made in its panel, in the part «Own look». «Draw an own look» begins a look from the theme of the pulpit, «Change the look» — from the own look the element is already drawn with. In the rows — the state of the element being made, and its colours (ground, edge, words: chosen in the colour picker of the system; a state other than the first takes what it lacks from the first), the rounding and the width of the edge, a pattern — stripes, checks or dots — with a colour and a step, the font and the height of letters, for a bar the fill colour, and the name of the look. What is made is seen on the sheet at once, while not saved; «Save the look» gives the look to the function of the pulpit as an own look of the process (ogas.look/1 with paint, File formats, 7.2), and the element is drawn with it, «Cancel» drops it. Other elements of the same kind get a saved look in the row «Look»; it goes with the program, like any own look. The editor writes the files of a look; it does not change the format of the pulpit.

A look of an element made of pictures. A look is a folder: the description look.json and the pictures it names (File formats, 7.2). The description says:

• which picture to show in each state of the element. Each kind of element has its own states: a button — at rest, under the pointer, pressed, not available; a switch — off and on; an indicator — five states of a run; fields — at rest and with the cursor in the field. A state without a picture is shown with the picture of the first;
• how a picture stretches to the size of the element: whole, or cut into nine parts — the corners keep their size, the edges and the middle stretch;
• where the words of the element stand on the picture and of what colour they are — or that there are no words, and the look says everything with pictures;
• how a quantity is drawn at an element that shows one: by a fill, by a strip of frames or by a pointer;
• for what size the look is drawn: an element given the look takes this size.

A look changes only how an element is drawn: what it shows, takes and sends stays the business of the set. The pictures of a look lie under the element and take no presses.

A look is chosen for an element in its panel, in the row «Look»: «The look of the set» or one of the looks made for this kind of element. There are six built-in looks: «Key» for a button, «Lever» for a switch, «Lamp» for an indicator, «Tube» and «Dial» for a bar, «Plate» for a frame; the theme of the pulpit does not act on them — a look has its own colours. An own look is added in the panel «Look», in the part «Own looks»: a button opens a Windows window to choose the folder of the look, and the function of the pulpit takes the folder whole or refuses and says what is wrong in it. An own look lies in the process folder and goes with it; under the name of a built-in look it takes its place. A look an element is drawn with is not removed until the element is given another.

An element that names a look that is not there, a look of another element or a look made with an error works as usual: it is drawn with the look of the set, and while laying out it is marked with a sign with the cause.

A look of pictures is described by the file look.json in the folder of the look, a look of colours and numbers is made in the panel of the element, in the part «Own look» (above).

6.6 The face of a program

The face of a program is the pulpit of a working process over the whole window of the platform, without the frame of the workshop: the sections of the pulpit as tabs, the sheet of the open section and a button to go to the workshop. The window on the face of a program is the size of the built interface: the sheet at scale 1 and what is around it — the strip on top, the tabs, the margins; a sheet larger than the screen shrinks as a whole, and the window with it, so there are no empty strips at the sides. A window that was stretched or spread over the whole screen is filled by the sheet whole (6.3). The window asks for this size when the face of the program is shown or its sheet has changed; a size the person then gave the window by hand stays. On going to the workshop the window takes its former place and size. So a ready program is used without opening the workshop. The window and the instance are the same: the face of a program is the second thing the window of the platform shows, not a separate program.

• Entry. The shortcut of a program starts the platform, switches this program on and opens its face. A start by shortcut is an action of the person, so the program is switched on by it (The program: graph and runs, section 2). An ordinary start opens the workshop. From the workshop the face of a program is opened by a click on its icon on a panel of programs (section 4) or by «Open» in the library (5.6); with unsaved edits it first asks, like leaving a process (section 5).
• Make-up. On top one strip: the name of the program, its words — the state and refusals — the button «To the workshop» and the buttons of the Windows window; under the strip the pulpit. The window has no Windows frame, so the face draws its buttons itself, with the same signs as the frame.
• Start. The shortcut calls the verb program with the name of the process (Getting started, 2.2). The face appears at once, before the process is read, and holds nothing until it is read: the workshop does not flash on the screen, and a foreign pulpit is not shown under the name of the program. If the instance already works, its window comes forward and shows the face of this program; the program whose face was on the screen before stays on. A process that did not open leaves on the screen what was there — the workshop or the face of the former program — and the refusal in words.
• Going to the workshop. The button on the face of a program shows the workshop with this process. The program stays on: runs go, questions wait for an answer, modules stay loaded. The reasons: in the workshop one looks at where a running run stopped and builds another process while this one works (Getting started, 7); the workshop does not change a program that is on, even without stopping it (The program: graph and runs, section 2).
• A refusal to switch on. If the program did not switch on, the face names the cause in the words of the refusal and keeps the way to the workshop.
• Closing. Closing the window on the face of a program acts as closing the workshop: confirmation, then stopping the platform (section 1). The question names the program, not the workshop: there is no workshop on the screen.
• Use, not editing. On the face of a program the elements act; their place, size and look are set on the step «View». A press and input on the face choose nothing, the keys of the workshop — Esc, Delete, Ctrl+Z — do not act on the face.

How the kernel passes the name of the program to a starting and to a working instance — The make-up of the platform, 3.6.3 and 5.3; the methods of the function ui — Methods of the workshop and the pulpit, section 2.

6.7 The set of the pulpit

What the pulpit has:

• the document of the pulpit — containers and elements (File formats, section 7);
• the first set of elements: button, switch, field, number, choice, question, value, bar, indicator — each in its own folder at the function canvas, the drawing of each at the window page; make ci compares the one with the other;
• sections — the tabs of the pulpit; a section has a sheet: in a window smaller than drawn it shrinks as a whole, in a bigger one it grows, and elements hold on to edges or stretch; the place and size of a new element are given by the function of the pulpit;
• laying out on the sheet (6.3): an element is carried and pulled by its handles with the pointer, shifted with the arrows, the place, size and size of the sheet are set by numbers in the panel; drawing to the step of the sheet, to neighbours and to the margin; the numbers of the sheet are settings of the function of the pulpit;
• the look (6.5): the theme of the pulpit and the default look in the settings, the underlay of a section — colour and picture, decorations — label, frame, picture, pictures in the process folder that go with the process when it is handed over;
• looks of elements (6.5): six built-in looks and the process's own looks — pictures by state, stretching by nine parts, a quantity by a fill, a strip of frames or a pointer; the look is chosen in the panel of the element;
• the step «View» of the graph window: the column on the left — what lies on the open tab: the tab itself, then each of its containers that is seen now — of a container of tabs only the open tab, at any depth, as on the sheet — and in each what lies directly in it; a tab opened on the sheet opens its section of the column too. A click chooses the element on the sheet and opens its panel. Things are put on the pulpit in the graph of the interface (6.8) and by the kinds of elements in the part «Into the interface» of the panel of a working node (6.4); an empty tab says so; a press on the sheet chooses an element and opens its panel, pressing nothing (5.1); over the sheet stands a bar, as over the canvas of the graph, with the sign «Look»; for an element with nothing to work with the panel offers «Bind on the graph» — the window goes to the graph of the interface with its graphic node chosen; for a bound one — «Show on the graph»: the window goes to the graph of the interface to the reflection it is bound to, with its graphic node chosen and its link lit; for an event button the panel sets which variables it carries and under which field names;
• an element whose object was removed from the graph or no longer fits stays in its place, says the cause and does nothing;
• the action «Into the interface» at a node, at a variable and at an assembled node, and the sign of what is reflected on the working graph (6.4).

6.8 The graph of the interface

The interface of a program is built in two steps after the working graph: first the graph of the interface — what the program gives its interface and what shows it: reflections of what is needed, graphic nodes and the structure of them — windows, tabs, groups, subgroups — then place and look.

The graph of the interface is a separate graph on a canvas of its own. It is not part of the working graph but refers to it: a run knows nothing of it, inserting and calling a process do not work with it. The working graph is tied to it by reflections only: what the person took into the interface (6.4) stands on the graph of the interface as a node of its own.

The nodes of the graph of the interface are of three families:

• reflections — what the working graph gives the interface: a node as a whole, an input, an output, a parameter, a variable, the face of an assembled node. A reflection is drawn as a node, its rows are shared objects of the graph, the point of each row is on the right; a row is coloured by the type of its data, and in a program that is on shows what it holds now. A thing has one reflection; when the original is removed, its row is marked «not in the graph»;
• elements — the set of elements of the pulpit (6.2): button, field, switch, indicator, bar and others, each as a node;
• container nodes — window, tab, group, subgroup: what elements are put into. It is one group at different levels, as in the working graph: the level, «Wrap», «Fold», «Unfold», «Take apart» are the same (The program: graph and runs, section 17). A window, a tab and a group differ only in how the container shows what lies in it: all at once or one at a time, with a switcher. A window is a container of the top level, windows are shown one at a time, and the program begins with the first; a tab is a container in one that shows its content one at a time; a group and a subgroup — in one that shows all at once. A container has a name — of a window, of the label of a tab, of the title of a group — how it shows its content, and bindings to variables (below). On the layer «Wrap» puts an element or a container into a new group in its place, and «Take apart» leaves what the container held where it lay, and a button that opened it opens the container above; a window is neither wrapped nor taken apart — it has nothing to lie in, and its content would be left without a window.

A window here is a screen inside one window of the program, not a separate Windows window: the platform has one window. The first window is the window of the program itself: it has no frame on the graph, and what lies in it stands on the canvas by itself. A window is drawn as a frame only when the person has made a second one.

The links of the graph of the interface are of four sorts:

• nesting: a subgroup lies in a group, a group in a tab, a tab in a window;
• binding: a line from a row of a graphic node to a row of a reflection — a button to an event, a field to a variable, a view to an output or a display node (The program: graph and runs, section 24). A graphic node and a reflection are tied by a shared object: the element names the object, the reflection holds it as a row;
• from the process to the interface: a container is bound to a variable of the program — to a yes-no variable by which it is shown or hidden, and to a text one that names the tab open in it. The process opens a tab or hides a group with a «Write» node into this variable — so the program steers its interface itself, and a run knows nothing of the interface. Switching a tab by hand, the person writes the same variable;
• going within the interface: a button opens a tab or a window without going into the process — by a binding to a container of the same graph; the same way, by the binding resets, a button returns the fields of a container to their initial values (6.2).

A binding is written in the element and in the container, as in the pulpit: the name of the binding and the object_id of the shared object (The program: graph and runs, section 16); reflections are written in the document of the pulpit beside the elements (File formats, section 7). An object an element is bound to and no reflection holds is reflected by the function of the pulpit itself — so a pulpit built earlier or by the assistant is seen at once with its links. An element has as many bindings as objects it names.

An empty element is a graphic node without a kind: first it is bound, then it is chosen what element it is to be. It stands first in the column of the graph of the interface, and it is also pulled out by a link from a row of a reflection into an empty place of the canvas: there it stands already bound. Bound, it offers «What to be» in its panel: only the kinds possible for that object and kind of data, the fitting one first — at an output of text «Value» and «View», at an event «Button», at an input without links also the elements of input of its type: such an element gets a variable with its node, whose cold link gives the input, and the row of the reflection becomes this variable. While no kind is chosen it is written with the mark «kind not chosen», does not lie on the sheet and is not seen on the face. The same list for a finished element is «Change the kind»: bindings, place and size stay where the new kind takes them. If the link of an element was let go on a row its kind does not take, the panel offers «What to be here»; an element of input is not put on an input other links come to — it would fight the graph, and the workshop says so. Containers are not concerned: a window, a tab and a group are chosen by structure.

Elements are the set of the pulpit. Each element of the set with its bindings is a graphic node: button, switch, field, number, choice, question, value, bar, indicator; a view that shows the same as the node «Show» — text, picture, gallery, player; choosing a file into a variable; a table — a list of records, for example a list of chats or a feed of letters, as rows and columns: a click on a row writes its key into a variable and may press an event, the table shows only the records whose field equals the value of a variable — the feed of the open chat — and orders the rows by a field; rows — a list the person edits by rows. A field may have several lines and write as it is typed; a question is answered in the form the question node sets — with a picture and with an area on a picture too (File formats, section 7; The program: graph and runs, section 9). A label and a picture are decorations. There is no frame in the set: gathering elements together is the business of a group.

A link of the graph of the interface is not a link of the working graph: it carries no packets of a run and is drawn in its own way.

The fork stays in the working graph. When one press starts several parts of one matter, several links leave the event, and the branches go at the same time (The program: graph and runs, 10.2 and 12.2): so it works from a button, a timer, a message and a call. The interface has no branching of its own (6.2). A common switch is another matter: one button that presses several events, each with its own run, its own stop and its own state. There is no logic in it — it is several presses at once — so such a binding is allowed in the graph of the interface.

Where it is built. The graph of the interface is a true node canvas, of its own: the working graph is not on it, and the lines of the interface do not go across working links. It has no window of its own:

• it is opened by the sign «Graph of the interface» in the top right corner of the graph window, and the sign «Graph» beside it goes back to the working graph (5.4); it has no item of its own in the bar «Workshop» and no sign in the tool bar;
• a graphic node is drawn the same way as a working one (5.3), by the same hand: the label — for an element only when chosen — with the actions «Remove», «Build into a node», «Open on the pulpit»; the head with the name, the kind and the sign of the family, in a colour of its own — the setting ui.color.head_interface; under the head a row for each binding of its kind — «What it presses», «What it shows», «What it carries with it» — with what it is attached to, and with a point on the left edge. A link is drawn from the point of a row and let go on a row of a reflection: a button takes an event, a bar the course of a step of a module node, a view, a value and a table what an output gave or came to an input, a field a variable. If the row does not give what the binding takes, it is said so, and nothing changes. A row is attached and let go in the panel of the node too;
• a reflection is drawn as a node with a head in the colour of data: what is reflected — «Generation · steps», «Chat · message». Its label has «Remove the reflection», «Build into a node», «Show on the graph»; the panel names what is reflected, and at each row — the kinds of elements to show or set it with: the one pressed puts such an element, tied to the row, not placed. A removed reflection removes the bindings of graphic nodes to its rows;
• a node of the graph of the interface has its own place: the hand puts and moves it, like a working node. At first the reflections of the window of the program stand in a column on the left, graphic nodes in a column further right. A container — a tab, a group, another window — is a node built of nodes and is drawn like a group of the working graph: unfolded — an area around what lies in it, with the nesting mark on its label and the actions «Remove», «Fold», «To the library», «Take apart», «Build into a node»; folded — one node of the same level, on which it is named what lies in it and to which the links of what lies inside come. A container is moved with all its content. Reflections are built into a node too; a node in which only reflections lie is order on the graph, it is not on the sheet;
• the nodes of the graph of the interface keep the same rule as working ones (5.1): nothing lies over another's. Of two that came to lie on each other, the one the hand is not touching now gives way; they give way to the right or down, a container with everything in it;
• a link goes the same way as a link of the working graph: at right angles from the point of a row of a reflection — first straight to the right, then where it must — to the point of a row of a graphic node, around nodes; links of the interface are lighter than the heads, their arrows of the colour of the line. The arrow shows which way the data go: at the reflection — for a button, an element of input, a question and the row picked in a table, which give them to the graph; at the graphic node — for what shows, for the variables a button carries and for the variables of a container. Links do not lie on each other: those that go along one corridor go side by side, each in its own lane a node margin apart, and part without crossing. While a link is pulled from a graphic node, the rows of reflections that will take it are lit. A link of the interface is chosen by a press, like a working one (5.3): the panel says whose it is, of which row and where it leads, and «Remove the link» and Delete take off this binding — the graphic node and the reflection stay, a row that holds several objects loses only this one;
• the column of the graph window on this step offers first the graphic nodes of each kind, not yet attached — a new graphic node is not placed on the sheet (6.3), it is laid on the sheet on the step «View»; then «What the program has» — node by node what can be reflected, and apart from them switching the program on and its variables: the one pressed is reflected and stands in the middle of the visible part of the canvas, what is reflected is marked, and a press chooses its reflection; then pieces and decorations, and after them everything it offers the working graph. A new node stands in the middle of the visible part of the canvas, in the container chosen on the canvas;
• a node not attached to the working graph is written and marked «not linked with the graph»: it is put before a link is drawn. On the pulpit it does nothing until it is linked;
• nodes of one container marked with Ctrl or Shift — graphic ones and reflections — are built into one node by the action on the label or by the tool «Build into a node» of the control bar, the same as for working nodes; whether a container shows as tabs or all at once is set in its panel; Delete removes the chosen node;
• a chosen graphic node highlights its links and the reflections it is attached to; a chosen reflection — its links;
• the graph of the interface is written with the same button «Save», with the program on too: the pulpit is always written.

A piece of interface is a container with everything in it, kept in the library to be put into another program:

• it is saved with the action «To the library» on the label of a chosen container and in its panel; an unsaved edit of the pulpit is written first — a piece is made from the pulpit as it is seen, and a pulpit the owner did not write gives no piece. A piece is named by the name of the container;
• a piece holds the nested containers, the elements, their labels, parameters, built-in looks and places on the canvas. The links to the working graph and the bindings of containers to variables do not go in: they lead to nodes of their own program, and in another they are drawn anew. A button that opens a container of the piece itself opens it after too; a piece takes no own look of the process — its pictures lie in the folder of that program;
• the column of the graph, while graphic nodes are shown, offers «Pieces from the library»: a piece stands in the container chosen on the canvas, in the middle of the visible part, and the graphic nodes in it keep their places relative to each other. The containers and elements get new names of this pulpit; a piece once put is a part of the program of its own, and neither deleting the piece nor a new version of it changes what was put;
• in the library pieces are the section «Pieces of the interface»: the name, how many containers and graphic nodes it holds, «Delete the piece» after a question (5.6).

Three steps and the border between them:

1) the working graph — the process is built, works and is checked right in the graph (5.5); 2) the graph of the interface — what there is in the interface, what it lies in and what it is bound to; 3) the interface itself — where it stands and how it looks: place, size, theme, looks of elements (6.3, 6.5) — on the step «View».

A program has a look already after the graph of the interface: a thing put without a place gets one where the page would put it itself, and laying out moves this place (there is no page without a sheet — 6.3). The page puts first its elements, then groups and containers with tabs, one under another; an element at the default height of its kind, and what is read and typed in — field, view, table, rows, question, choice, number, bar — stretched over the width of the page; a question and rows grow by what they hold; buttons standing one after another — in a row, wrapping to the next line, as actions over one thing; a group — as a frame with a name; a container with tabs — as a switcher over the open one. A question of the program that waits for the person is outlined, and a tab not open in which it lies at any depth is marked: a question that opened out of sight is not missed; the page itself does not jump to it — a jump under the hand is worse. Places are given on the step of the sheet, and a group is a frame around what is its own (6.3). A place lives with the element and is not lost when the rest of the structure changes; an element moved into another container gets a place in it anew — under what stands there.

Where the graph of the interface lives: where the rules of the platform put it — in the document of the pulpit workspace.json of the process, ogas.workspace/3; the owner is the function canvas. The interface of a program has one owner and one document, and no second file is made for the same thing (Rules of development, 2.4); a new thing takes a ready place — the document and the function that already hold the interface of the program (2.5 there); everything that belongs to a process lies in its folder (The program: graph and runs, section 1). The working graph (process.json, the owner is the function of the graph) the graph of the interface only names — by shared objects, like the pulpit. The make-up of the document — File formats, section 7.

7 The look of the shell

The colours, the font, the sizes of letters, the roundings, the margins, the outlines and the sizes of the areas of the workshop itself (the bars and capsule tabs, the host, the column on the left, the work area and the panel of the chosen of windows, the graph and the pulpit) are set by the settings of the group ui.* (Settings, section 8). A value from a closed set (language, scheme, font source) is chosen from a list on the tab «Edit» of the panel of the chosen: the set grows without changing the look of the row.

• Palettes. Both palettes (dark, light) belong to the function of settings. A colour not set is taken from the scheme ui.scheme. Choosing a scheme does not write colours into the file, a reset removes a set value.
• Text over a fill takes from ink and ink_on_accent the one more contrasting with the background.
• Only tokens. A window on the host does not write a colour, a size or a font as a number right in its code.

One look of the shell. The look is set by the tokens ui.* (lib/look.js → CSS variables), the common classes of style.css, the faces of capsules faces.js and the signs lib/glyphs.js. The frame (shell.js, windows.js) and the windows on the host (host/*) draw from the same tokens, classes, faces and signs (rule 2.9 of Rules of development).

• The label of a button stands in the middle of the button across and down.
• The text of a list row, of a value field and of help begins at the start of the row.
• An icon is a sign from lib/glyphs.js in the middle of its tile, not a letter and not a picture of one window.
• The capsule tab of a window on the host (the name, the buttons, the folding chevron) is one for all windows and belongs to the frame. A window draws only the content of its body and names its buttons.
• A bar is one capsule in three states; a bar of the right side is the same face, mirrored. The set of subsections of a bar is a list, not a new layout.
• A new look of an element of the shell appears first as a common primitive or token, and only then takes its place in a window. A drawing for one window only is not allowed.
• The sign ? at a row is help, not the icon of a kind of node.

This is the look of the workshop itself, not of the person's pulpit. The look of the pulpit does not mix with the tokens ui.*.

7.1 The language of the interface

The workshop uses everyday language (rule 3.4 of Rules of development). Below is how the rule applies to the words of the workshop.

• Labels, hints and messages in ordinary words. In the Russian interface — «данные», not «пакет»; «запуск», not «прогон»; «круг цикла», not «итерация»; «панель», «окно», «значок», not «бар», «хост», «слот», «шеврон»; in the English one, likewise, «data» and «run» rather than words of development. Words of development are used in the documentation, not in the window.
• A term only in the details, and beside its explanation: «the step may already have been done, and a retry will do it once more (a non-idempotent step)».
• A hint says what will happen, not how it is made inside.
• An error says what happened and what to do. Each error code the person may see has a text error.<code> in the dictionaries in both languages; the code and the message of the function are in the journal and in the details.
• The journal tells an event in the words of its owner. Each event has a text event.<type> in the dictionary of whoever sends it out; a row of the journal is the time, these words and which part or run it is about, and the name of the event, its level and fields are in the panel of the row. make ci checks that each declared event has a text.
• A part of the platform is called by its name, not its id. Each function names itself in words in its dictionary — the text <id>.name in both languages; by this name the part is called by the head of the workshop, the section «State» and a row of the journal, and the id stays in the details. A part without a name is called by its id. make ci checks that each function has a name.
• Names of values that come from data (the field text, the operation equals) stay as they are: the person sees them in their data. An explanation is given beside them.

8 The division of drawing the interface

The functions do not describe to the workshop how to draw the interface. The workshop draws its windows itself, and the functions give it data with their requests: process.open and process.snapshot — the graph and a run, canvas.get and canvas.snapshot — the pulpit, settings.schema — the settings, module.list — modules, observe.* — the journal and problems.

The grounds:

• the workshop is the only consumer of the data of the functions for showing, and comes in the same delivery; a separate description of the interface would mean two descriptions of one and the same thing;
• there is no interface by outside authors, and descriptions are needed precisely for such an interface;
• the look of the shell belongs to the workshop in any case: the tokens ui.*, the common classes and the faces of capsules (section 7).

Kept at the same time:

• The snapshot of the pulpit. canvas.snapshot gives the window the sections, the elements with their places and marks and what each object of the process is put on the pulpit as, with the revision of the document; after each edit the window asks the owner the same about the pulpit on the screen (canvas.preview). These are data for drawing, not a description of the interface: the window keeps no rules of its own about the pulpit.
• The names of surfaces at introduction. A function declares surfaces (graph.editor, canvas.editor) — these are only names for diagnostics, the kernel does not parse them.
• Unavailability. A window names in its description the parts of the platform it shows (needs). If such a part is not in the platform or does not work, the window writes over the work area which part is missing or why it does not work — in the words of the kernel code and naming the missing dependency — and shows the last data it got (Getting started, 8). The strip on top lists the parts that stopped. Without dictionaries the window opens and says in its own words that the labels are shown as keys: the function ui names i18n as optional.
• A broken link. Introduction is not repeated after a break — the launch token is for one use; the workshop shows «No connection to the platform» (ui.status.disconnected).