The words in which the literature writes scheduling instances, schedules and online information, for the operations family, the batching family and the two standalone problems. All numbers are written in binary, as entries of the word.

Blocks. A finite set of tuples of numbers is written canonically: the number of tuples, then every tuple, preceded by its length, in increasing lexicographic order and without repetition.

Instances of the operations family. A field is written by its view, the meaning its constraints use, and not by its internal representation, so that two representations of the same constraints have the same word. The word consists of

• a flag, $0$ for the standard encoding and $1$ for high multiplicity, the number of jobs and the number of machines;
• for every job a record, preceded by its length: its number of operations, the processing time of every operation on every machine, its deadline ($0$ for none, or $1$ followed by the deadline), and three blocks: the sets of machines each operation may occupy, the setup time of each operation at the server, and the transport delays between its operations; and its batch for batch setups;
• a block of the facts on pairs of jobs: $(0, i, j)$ when $i$ precedes $j$, $(1, i, j, s, l)$ for the lag $±l$ of such a pair ($s = 1$ for a negative lag), and $(2, i, j, c)$ when the pair has communication delay $c$;
• a block of the global facts: $(0, t)$ for every forbidden time, $(1, a, b, s)$ for the setup time $s$ from batch $a$ to batch $b$, for the batches of jobs, and, when the problem has a transport robot, $(2, i, i', t)$ for the empty moving time $t$ of the robot from machine $i$ to machine $i'$, for all machines (all $0$ when the robot has no empty moves);
• for every job its release date, weight and due date ($1$ and $0$ when the objective has none), three numbers each, in the order of the jobs.

The release dates, weights and due dates come last so that changing the objective — which the threshold steps between objectives do — rewrites only the end of the word. With high multiplicity the jobs are written as a block of their distinct records, each followed by the job's release date, weight and due date and preceded by the number of jobs that have both, and there are no facts on pairs.

Instances of batching: the number of jobs, the setup time and the capacity, then for every job its processing time, release date, weight, due date, deadline and size, then the block of precedence pairs, each with its lag. Rejection: the number of jobs and the budget, then the processing time and rejection cost of every job. Machine covering: the numbers of jobs and machines and the processing times.

Schedules. A schedule of the operations family is the list of its pieces, each written as its job, operation, start and length (a rational as numerator and reduced denominator) and the sorted machines it occupies. With high multiplicity a schedule is written compactly, by machine patterns: a list of groups, each a number $c$ of machines followed by the pieces every one of them runs, a piece written as the type of its job (the position of the job's tuple in the block of distinct records), its operation, start and length. The groups use consecutive machines, $c$ for a group, and the $k$-th piece of a type and an operation goes to the $k$-th job of that type, in the order of the jobs; every operation is one piece. A batch schedule writes for every job its batch and the start and processing time of that batch; a rejection schedule for every job whether it is accepted and its start; a covering the machine of every job.

Online. For problems whose jobs arrive online, the scheduler sees at time $t$ the records of the jobs released by $t$ (with their numbers), the facts on pairs of them, and the global facts; two schedules made the same decisions up to $t$ if they have the same pieces starting before $t$. Other problems are revealed at once.