1ROFF(7) Miscellaneous Information Manual ROFF(7)
2
6 roff - concepts and history of roff typesetting
7
9 roff is the general name for a set of text formatting programs, known
10 under names like troff, nroff, ditroff, groff, etc. A roff system con‐
11 sists of an extensible text formatting language and a set of programs
12 for printing and converting to other text formats. Unix-like operating
13 systems distribute a roff system as a core package.
14 The most common roff system today is the free software implementation
16 GNU roff, groff(1). groff implements the look-and-feel and functional‐
17 ity of its ancestors, with many extensions.
18 The ancestry of roff is described in section HISTORY. In this docu‐
20 ment, the term roff always refers to the general class of roff pro‐
21 grams, not to the roff command provided in early UNIX systems.
22 In spite of its age, roff is in wide use today, for example, the manual
24 pages on UNIX systems (man pages), many software books, system documen‐
25 tation, standards, and corporate documents are written in roff. The
26 roff output for text devices is still unmatched, and its graphical out‐
27 put has the same quality as other free type-setting programs and is
28 better than some of the commercial systems.
29 roff is used to format UNIX manual pages, (or man pages), the standard
31 documentation system on many UNIX-derived operating systems.
32 This document describes the history of the development of the roff sys‐
34 tem; some usage aspects common to all roff versions, details on the
35 roff pipeline, which is usually hidden behind front-ends like groff(1);
36 a general overview of the formatting language; some tips for editing
37 roff files; and many pointers to further readings.
38
40 Document formatting by computer dates back to the 1960s. The roff sys‐
41 tem itself is intimately connected to the Unix operating system, but
42 its roots go back to the earlier operating systems CTSS and Multics.
43 The Predecessor RUNOFF
45 roff's ancestor RUNOFF was written in the MAD language by Jerry Saltzer
46 for the Compatible Time Sharing System (CTSS), a project of the Massa‐
47 chusetts Institute of Technology (MIT), in 1963 and 1964 – note that
48 CTSS commands were all uppercase.
49 In 1965, MIT's Project MAC teamed with Bell Telephone Laboratories
51 (BTL) and General Electric to begin the Multics system ⟨http://
52 www.multicians.org⟩. A command called runoff was written for Multics
53 in the late 60s in the BCPL language, by Bob Morris, Doug McIlroy, and
54 other members of the Multics team.
55 Like its CTSS ancestor, Multics runoff formatted an input file consist‐
57 ing of text and command lines; commands began with a period and were
58 two letters. Output from these commands was to terminal devices such
59 as IBM Selectric terminals. Multics runoff had additional features
60 added, such as the ability to do two-pass formatting; it became the
61 main format for Multics documentation and text processing.
62 BCPL and runoff were ported to the GCOS system at Bell Labs when BTL
64 left the development of Multics.
65 There is a free archive about historical RUNOFF documents. You can get
67 it anonymously by the shell command
68 $git clone https://github.com/bwarken/RUNOFF_historical.git
69 As well, there is a new project for writing a program that can read
71 RUNOFF files , but it does not yet work so far. You can get an early
72 version anonymously by the shell command
73 $git clone https://github.com/bwarken/runoff.git
74 The Classical nroff/troff System
76 At BTL, there was a need to drive the Graphic Systems CAT typesetter, a
77 graphical output device from a PDP-11 computer running Unix. As runoff
78 was too limited for this task it was further developed into a more pow‐
79 erful text formatting system by Joseph F. Ossanna, who already pro‐
80 grammed several runoff ports.
81 The name runoff was shortened to roff. The greatly enlarged language
83 of Ossanna's version already included all elements of a full roff sys‐
84 tem. All modern roff systems try to implement compatibility to this
85 system. So Joe Ossanna can be called the father of all roff systems.
86 This first roff system had three formatter programs.
88 troff (typesetter roff) generated a graphical output for the CAT type‐
90 setter as its only device.
91 nroff produced text output suitable for terminals and line printers.
93 roff was the reimplementation of the former runoff program with its
95 limited features; this program was abandoned in later versions.
96 Today, the name roff is used to refer to a troff/nroff system as
97 a whole.
98 Ossanna's first version was written in the PDP-11 assembly language and
100 released in 1973. Brian Kernighan joined the roff development by
101 rewriting it in the C programming language. The C version was released
102 in 1975.
103 The syntax of the formatting language of the nroff/troff programs was
105 documented in the famous Troff User's Manual [CSTR #54], first pub‐
106 lished in 1976, with further revisions up to 1992 by Brian Kernighan.
107 This document is the specification of the classical troff. All later
108 roff systems tried to establish compatibility with this specification.
109 After Ossanna's death in 1977, Kernighan went on with developing troff.
111 In the late 1970s, Kernighan equipped troff with a general interface to
112 support more devices, the intermediate output format, and the postpro‐
113 cessor system. This completed the structure of a roff system as it is
114 still in use today; see section USING ROFF. In 1979, these novelties
115 were described in the paper [CSTR #97]. This new troff version is the
116 basis for all existing newer troff systems, including groff. On some
117 systems, this device independent troff got a binary of its own, called
118 ditroff(7). All modern troff programs already provide the full ditroff
119 capabilities automatically.
120 Availability
122 The source code of both the ancient Unix and classical troff weren't
123 available for two decades. Meanwhile, it is accessible again (on-line)
124 for non-commercial use, cf. section SEE ALSO.
125 groff — free GNU roff
127 The most important free roff project was the GNU implementation of
128 troff, written from scratch by James Clark and put under the GNU Public
129 License ⟨http://www.gnu.org/copyleft⟩. It was called groff (GNU roff).
130 See groff(1) for an overview.
131 The groff system is still actively developed. It is compatible to the
133 classical troff, but many extensions were added. It is the first roff
134 system that is available on almost all operating systems — and it is
135 free. This makes groff the de-facto roff standard today.
136 Free Heirloom roff
138 An alternative is Gunnar Ritter's Heirloom roff project ⟨https://
139 github.com/n-t-roff/heirloom-doctools⟩ project, started in 2005, which
140 provides enhanced versions of the various roff tools found in the Open‐
141 Solaris and Plan 9 operating systems, now available under free
142 licenses. You can get this package with the shell command:
143 $ git clone https://github.com/n-t-roff/heirloom-doctools
144 Moreover, one finds there the Original Documenter's Workbench Release
146 3.3 ⟨https://github.com/n-t-roff/DWB3.3⟩.
147
149 Most people won't even notice that they are actually using roff. When
150 you read a system manual page (man page) roff is working in the back‐
151 ground. roff documents can be viewed with a native viewer called
152 xditview(1x), a standard program of the X window distribution, see
153 X(7x). But using roff explicitly isn't difficult either.
154 Some roff implementations provide wrapper programs that make it easy to
156 use the roff system on the shell command line. For example, the GNU
157 roff implementation groff(1) provides command line options to avoid the
158 long command pipes of classical troff; a program grog(1) tries to guess
159 from the document which arguments should be used for a run of groff;
160 people who do not like specifying command line options should try the
161 groffer(1) program for graphically displaying groff files and man
162 pages.
163 The roff Pipe
165 Each roff system consists of preprocessors, roff formatter programs,
166 and a set of device postprocessors. This concept makes heavy use of
167 the piping mechanism, that is, a series of programs is called one after
168 the other, where the output of each program in the queue is taken as
169 the input for the next program.
170 cat file | ... | preproc | ... | troff options | postproc
172 The preprocessors generate roff code that is fed into a roff formatter
174 (e.g. troff), which in turn generates intermediate output that is fed
175 into a device postprocessor program for printing or final output.
176 All of these parts use programming languages of their own; each lan‐
178 guage is totally unrelated to the other parts. Moreover, roff macro
179 packages that were tailored for special purposes can be included.
180 Most roff documents use the macros of some package, intermixed with
182 code for one or more preprocessors, spiced with some elements from the
183 plain roff language. The full power of the roff formatting language is
184 seldom needed by users; only programmers of macro packages need to know
185 about the gory details.
186 Preprocessors
188 A roff preprocessor is any program that generates output that syntacti‐
189 cally obeys the rules of the roff formatting language. Each preproces‐
190 sor defines a language of its own that is translated into roff code
191 when run through the preprocessor program. Parts written in these lan‐
192 guages may be included within a roff document; they are identified by
193 special roff requests or macros. Each document that is enhanced by
194 preprocessor code must be run through all corresponding preprocessors
195 before it is fed into the actual roff formatter program, for the for‐
196 matter just ignores all alien code. The preprocessor programs extract
197 and transform only the document parts that are determined for them.
198 There are a lot of free and commercial roff preprocessors. Some of
200 them aren't available on each system, but there is a small set of pre‐
201 processors that are considered as an integral part of each roff system.
202 The classical preprocessors are
203 tbl for tables.
205 eqn for mathematical formulae.
206 pic for drawing diagrams.
207 refer for bibliographic references.
208 soelim for including macro files from standard locations.
209 chem for drawing chemical formulæ.
210 Other known preprocessors that are not available on all systems include
212 grap for constructing graphical elements.
214 grn for including gremlin(1) pictures.
215 Formatter Programs
217 A roff formatter is a program that parses documents written in the roff
218 formatting language or uses some of the roff macro packages. It gener‐
219 ates intermediate output, which is intended to be fed into a single
220 device postprocessor that must be specified by a command-line option to
221 the formatter program. The documents must have been run through all
222 necessary preprocessors before.
223 The output produced by a roff formatter is represented in yet another
225 language, the intermediate output format or troff output. This lan‐
226 guage was first specified in [CSTR #97]; its GNU extension is docu‐
227 mented in groff_out(5). The intermediate output language is a kind of
228 assembly language compared to the high-level roff language. The gener‐
229 ated intermediate output is optimized for a special device, but the
230 language is the same for every device.
231 The roff formatter is the heart of the roff system. The traditional
233 roff had two formatters, nroff for text devices and troff for graphical
234 devices.
235 Often, the name troff is used as a general term to refer to both for‐
237 matters.
238 Devices and Postprocessors
240 Devices are hardware interfaces like printers, text or graphical termi‐
241 nals, etc., or software interfaces such as a conversion into a differ‐
242 ent text or graphical format.
243 A roff postprocessor is a program that transforms troff output into a
245 form suitable for a special device. The roff postprocessors are like
246 device drivers for the output target.
247 For each device there is a postprocessor program that fits the device
249 optimally. The postprocessor parses the generated intermediate output
250 and generates device-specific code that is sent directly to the device.
251 The names of the devices and the postprocessor programs are not fixed
253 because they greatly depend on the software and hardware abilities of
254 the actual computer. For example, the classical devices mentioned in
255 [CSTR #54] have greatly changed since the classical times. The old
256 hardware doesn't exist any longer and the old graphical conversions
257 were quite imprecise when compared to their modern counterparts.
258 For example, the Postscript device post in classical troff had a reso‐
260 lution of 720 units per inch, while groff's ps device has 72000, a
261 refinement of factor 100.
262 Today the operating systems provide device drivers for most printer-
264 like hardware, so it isn't necessary to write a special hardware post‐
265 processor for each printer.
266
268 Documents using roff are normal text files decorated by roff formatting
269 elements. The roff formatting language is quite powerful; it is almost
270 a full programming language and provides elements to enlarge the lan‐
271 guage. With these, it became possible to develop macro packages that
272 are tailored for special applications. Such macro packages are much
273 handier than plain roff. So most people will choose a macro package
274 without worrying about the internals of the roff language.
275 Macro Packages
277 Macro packages are collections of macros that are suitable to format a
278 special kind of documents in a convenient way. This greatly eases the
279 usage of roff. The macro definitions of a package are kept in a file
280 called name.tmac (classically tmac.name). All tmac files are stored in
281 one or more directories at standardized positions. Details on the nam‐
282 ing of macro packages and their placement is found in groff_tmac(5).
283 A macro package that is to be used in a document can be announced to
285 the formatter by the command line option -m, see troff(1), or it can be
286 specified within a document using the file inclusion requests of the
287 roff language, see groff(7).
288 Famous classical macro packages are man for traditional man pages, mdoc
290 for BSD-style manual pages; the macro sets for books, articles, and
291 letters are me (probably from the first name of its creator Eric All‐
292 man), ms (from Manuscript Macros), and mm (from Memorandum Macros).
293 The roff Formatting Language
295 The classical roff formatting language is documented in the Troff
296 User's Manual [CSTR #54]. The roff language is a full programming lan‐
297 guage providing requests, definition of macros, escape sequences,
298 string variables, number or size registers, and flow controls.
299 Requests are the predefined basic formatting commands similar to the
301 commands at the shell prompt. The user can define request-like ele‐
302 ments using predefined roff elements. These are then called macros. A
303 document writer will not note any difference in usage for requests or
304 macros; both are written on a line on their own starting with a dot.
305 Escape sequences are roff elements starting with a backslash ‘\’. They
307 can be inserted anywhere, also in the midst of text in a line. They
308 are used to implement various features, including the insertion of non-
309 ASCII characters with \(, font changes with \f, in-line comments with
310 \", the escaping of special control characters like \\, and many other
311 features.
312 Strings are variables that can store a string. A string is stored by
314 the .ds request. The stored string can be retrieved later by the \*
315 escape sequence.
316 Registers store numbers and sizes. A register can be set with the
318 request .nr and its value can be retrieved by the escape sequence \n.
319
321 Manual pages (man pages) take the section number as a file name exten‐
322 sion, e.g., the filename for this document is roff.7, i.e., it is kept
323 in section 7 of the man pages.
324 The classical macro packages take the package name as an extension,
326 e.g. file.me for a document using the me macro package, file.mm for mm,
327 file.ms for ms, file.pic for pic files, etc.
328 But there is no general naming scheme for roff documents, though
330 file.tr for troff file is seen now and then. Maybe there should be a
331 standardization for the filename extensions of roff files.
332 File name extensions can be very handy in conjunction with the less(1)
334 pager. It provides the possibility to feed all input into a command-
335 line pipe that is specified in the shell environment variable LESSOPEN.
336 This process is not well documented, so here an example:
337 LESSOPEN='|lesspipe %s'
339 where lesspipe is either a system supplied command or a shell script of
341 your own.
342 More details for file name extensions can be found at groff_file‐
344 names(7).
345
347 The best program for editing a roff document is Emacs (or Xemacs), see
348 emacs(1). It provides an nroff mode that is suitable for all kinds of
349 roff dialects. This mode can be activated by the following methods.
350 When editing a file within Emacs the mode can be changed by typing ‘M-x
352 nroff-mode’, where M-x means to hold down the Meta key (or Alt) and
353 hitting the x key at the same time.
354 But it is also possible to have the mode automatically selected when
356 the file is loaded into the editor.
357 · The most general method is to include the following 3 comment
359 lines at the end of the file.
360 .\" Local Variables:
362 .\" mode: nroff
363 .\" End:
364 · There is a set of file name extensions, e.g. the man pages that
366 trigger the automatic activation of the nroff mode.
367 · Theoretically, it is possible to write the sequence
369 .\" -*- nroff -*-
371 as the first line of a file to have it started in nroff mode
373 when loaded. Unfortunately, some applications such as the man
374 program are confused by this; so this is deprecated.
375 All roff formatters provide automated line breaks and horizontal and
377 vertical spacing. In order to not disturb this, the following tips can
378 be helpful.
379 · Never include empty or blank lines in a roff document. Instead,
381 use the empty request (a line consisting of a dot only) or a
382 line comment .\" if a structuring element is needed.
383 · Never start a line with whitespace because this can lead to
385 unexpected behavior. Indented paragraphs can be constructed in
386 a controlled way by roff requests.
387 · Start each sentence on a line of its own, for the spacing after
389 a dot is handled differently depending on whether it terminates
390 an abbreviation or a sentence. To distinguish both cases, do a
391 line break after each sentence.
392 · To additionally use the auto-fill mode in Emacs, it is best to
394 insert an empty roff request (a line consisting of a dot only)
395 after each sentence.
396 The following example shows how optimal roff editing could look.
398 This is an example for a .I roff document. .
400 This is the next sentence in the same paragraph. .
401 This is a longer sentence stretching over several lines; abbreviations
402 like ‘cf.’ are easily identified because the dot is not
403 followed by a line break. . In the output, this will still go to
404 the same paragraph.
405 Besides Emacs, some other editors provide nroff style files too, e.g.
407 vim(1), an extension of the vi(1) program.
408
410 There is a lot of documentation on roff. The original papers on clas‐
411 sical troff are still available, and all aspects of groff are docu‐
412 mented in great detail.
413 Internet sites
415 troff.org
416 The historical troff site ⟨http://www.troff.org⟩ provides an
417 overview and pointers to all historical aspects of roff.
418 Multics
420 The Multics site ⟨http://www.multicians.org⟩ contains a lot of
421 information on the MIT projects, CTSS, Multics, early Unix,
422 including runoff; especially useful are a glossary and the many
423 links to ancient documents.
424 Unix Archive
426 The Ancient Unixes Archive ⟨http://www.tuhs.org/Archive/⟩ pro‐
427 vides the source code and some binaries of the ancient Unixes
428 (including the source code of troff and its documentation) that
429 were made public by Caldera since 2001, e.g. of the famous Unix
430 version 7 for PDP-11 at the Unix V7 site ⟨http://www.tuhs.org/
431 Archive/PDP-11/Trees/V7⟩.
432 Developers at AT&T Bell Labs
434 Bell Labs Computing and Mathematical Sciences Research ⟨http://
435 www.bell-labs.com/⟩ provides a search facility for tracking
436 information on the early developers.
437 Plan 9 The Plan 9 operating system ⟨http://plan9.bell-labs.com⟩ by AT&T
439 Bell Labs.
440 runoff Jerry Saltzer's home page ⟨http://web.mit.edu/Saltzer/www/
442 publications/pubs.html⟩ stores some documents using the ancient
443 RUNOFF formatting language.
444 CSTR Papers
446 The Bell Labs CSTR site ⟨http://cm.bell-labs.com/cm/cs/
447 cstr.html⟩ stores the original troff manuals (CSTR #54, #97,
448 #114, #116, #122) and famous historical documents on program‐
449 ming.
450 GNU roff
452 The groff web site ⟨http://www.gnu.org/software/groff⟩ provides
453 the free roff implementation groff, the actual standard roff.
454 Historical roff Documentation
456 Many classical troff documents are still available on-line. The two
457 main manuals of the troff language are
458 [CSTR #54]
460 J. F. Ossanna, Nroff/Troff User's Manual ⟨http://cm.bell-
461 labs.com/cm/cs/cstr/54.ps.gz⟩; Bell Labs, 1976; revised by Brian
462 Kernighan, 1992.
463 [CSTR #97]
465 Brian Kernighan, A Typesetter-independent TROFF ⟨http://cm.bell-
466 labs.com/cm/cs/cstr/97.ps.gz⟩, Bell Labs, 1981, revised March
467 1982.
468 The “little language” roff papers are
470 [CSTR #114]
472 Jon L. Bentley and Brian W. Kernighan, GRAP – A Language for
473 Typesetting Graphs ⟨http://cm.bell-labs.com/cm/cs/cstr/
474 114.ps.gz⟩; Bell Labs, August 1984.
475 [CSTR #116]
477 Brian W. Kernighan, PIC – A Graphics Language for Typesetting
478 ⟨http://cm.bell-labs.com/cm/cs/cstr/116.ps.gz⟩; Bell Labs,
479 December 1984.
480 [CSTR #122]
482 J. L. Bentley, L. W. Jelinski, and B. W. Kernighan, CHEM – A
483 Program for Typesetting Chemical Structure Diagrams, Computers
484 and Chemistry ⟨http://cm.bell-labs.com/cm/cs/cstr/122.ps.gz⟩;
485 Bell Labs, April 1986.
486 You can get an archive with most classical roff documentation as rea‐
488 sonable PDF files at github using the shell command
489 $ git clone https://github.com/bwarken/roff_classical.git
490 Manual Pages
492 Due to its complex structure, a full roff system has many man pages,
493 each describing a single aspect of roff. Unfortunately, there is no
494 general naming scheme for the documentation among the different roff
495 implementations.
496 In groff, the man page groff(1) contains a survey of all documentation
498 available in groff.
499 On other systems, you are on your own, but troff(1) might be a good
501 starting point.
502
504 Copyright © 2000-2014 Free Software Foundation,
505 Inc.
506 Permission is granted to copy, distribute and/or modify this document
508 under the terms of the FDL (GNU Free Documentation License) Version 1.3
509 or any later version published by the Free Software Foundation. with
510 the Invariant Sections being the .au and .co macro definitions, with no
511 Front-Cover Texts, and with no Back-Cover Texts.
512 A copy of the Free Documentation License is included as a file called
514 FDL in the main directory of the groff source package.
515 The license text is also available on-line at the GNU copyleft site
517 ⟨http://www.gnu.org/copyleft/fdl.html⟩.
518
520 This man-page was written by Bernd Warken ⟨groff-
521 bernd.warken-72@web.de⟩ and is maintained by Werner Lemberg
522 ⟨wl@gnu.org⟩.
523Groff Version 1.22.3 4 November 2014 ROFF(7)