Contents
The manual has two parts. The guide is a series of short steps, each one you can finish in a sitting. The reference is everything, complete and exact.
Guide
- Make a reader, step 1: show an article: the article format's first rules, and a test to check yourself.
- Make a reader, step 2: fetch an article: get an article from a relay and check that it is genuine.
- Make a reader, step 3: links and feeds: follow links, subscribe to a feed, check its signatures.
- Write a program: a first Terse32 program, built and run in three commands.
- Draw a line and read a key: the 2D vector display and keyboard events.
- Make a host, step 1: run a program to its end: the program file, memory and the processor, until
exit. - Make a host, step 2: frames and the budget: 125,000 units a frame,
wait_frameand the carry rule. - Make a host, step 3: a driver shows hello: the reference terminal over the device bus.
- Make a host, step 4: prove it exact: the state hash, snapshots and the conformance program.
- Make a device: a device as a separate program on the device bus.
- Swap in your own part: your reader, core or device with the reference for everything else.
- Make a shell: the program that starts other machines and lays out their screens.
- Using Tersenet: install, read, follow, write and publish; no programming needed.
Reference
Tersenet as a whole:
- How Tersenet works: sharing articles and programs, the network, the machine, the devices, determinism and the shell.
- Using the shell: the launcher and tiles, layouts, sessions, halted machines, open requests and consent prompts.
- Using the reader: the timeline, feeds, search and reading an article, with every key.
- Fonts: the fonts the host draws with, which characters they show, and adding one.
- Performance reports: what a report of your host's record holds, publishing one, and reading many.
Articles and the network:
- Writing an article: the article format, every construct shown as source and as shown.
- Writing a reader without the machine: what a native reader must do to be a complete Tersenet client.
- The network: blobs and relays, feeds and entries, profiles, names and search, programs, mirroring relays.
Programs:
- Building a program:
terse buildandterse new, every option, what they run and why, the devices an image lists. - The C library: the start code, the linker script, terse.h, and the hello program in assembly and C.
- Rust programs: the Rust runtime, what things cost, a larger program with cargo.
- Building by hand, and other languages: the build without
terse build, and what any compiler must do. - Running and publishing a program: headless runs, scripted input, the state hash, the window, costs, publishing.
The Terse32 machine:
- The Terse32 machine: the CPU, the memory map, frames and the budget, faults, the image format, the call table.
- Events and input: every event, the queue, keys, text, the pointer, the wheel and controllers.
- Charges and limits: every charge and every numeric limit on one page.
- State, replay and conformance: the machine's state, its hash, snapshots and the conformance image.
The devices:
- The system device (device 1): frames, events, time, random bytes, controllers, exit, opening things.
- The terminal (device 2): an 80 by 30 grid of character cells.
- The 2D vector display (device 3): lines and filled shapes from a display list, clean or phosphor.
- Content: blobs, requests and statuses (device 4): fetching and publishing blobs by hash.
- Content: feeds, names, search and publishing: the feeds the host follows, names and search.
- Content: named records: small named records a program keeps on the host.
- The sound device (device 6): a 16-voice wavetable synthesizer, optional and bit-exact.
- The page (device 7): typeset proportional text and tables in a rectangle of the screen.
- Figures on the page: drawings within the page's text.
- The Machines device (device 8): the shell's device, which starts other machines.
- Screens, panels and input (device 8): where machines' screens go, flat or as panels in 3D.
- The 3D vector display (device 9): lines, points and circles in a box, seen from the host's eye.
- Surfaces: a program's own screen placed in its 3D scene.