Verbatim

Sometimes you need text to appear on the page exactly as you typed it — every command, comment, and special character switched off, set in a monospaced (typewriter) font. That mechanism is called verbatim. This page walks through inline \verb, the block-level verbatim environment, whole-file \verbatiminput, the important limitation that none of these may sit inside another command’s argument (and how to work around it), the alltt variant that still honors a few commands, and finally fancyvrb for line numbers and frames.

The verbatim environment and \verb

The foundation of literal output is the verbatim environment, built into LaTeX from the start. Whatever you place between \begin{verbatim} and \end{verbatim} is printed as typed: a backslash no longer starts a command but prints as \, % does not begin a comment, spaces and line breaks are kept literally, and the whole block is set in the typewriter font (\tt). It is ideal for program source, or for showing strings full of $ and &.

\begin{verbatim}
for i in range(3):
    print("100% & $5")   # nothing here is interpreted
\end{verbatim}

There is just one rule to respect: the string \end{verbatim} must not appear inside the environment, because LaTeX treats the moment it sees that string as the end of the environment. If you genuinely need to display the text \end{verbatim} itself, change the terminator with fancyvrb (below) or escape that piece with \verb.

To drop a little verbatim into the middle of a line, use the inline form \verb. The recipe: put one delimiter character right after \verb, then the text you want literal, then the same delimiter again. The delimiter may be any non-letter character that does not appear in the text. The common choice is \verb|...|, but if | occurs inside, pick another, such as \verb!...! or \verb+...+. Do not put a space between \verb and its delimiter.

The macro \verb|\textbf{...}| sets bold text, and
the pipe itself is shown with \verb!a|b! instead.

The starred form \verb* prints the spaces inside as a visible space character (␣) — handy in code examples where the exact number of spaces matters. Likewise the verbatim* environment shows the spaces in a block as ␣.

That said, if your only goal is a string that tends to contain ~, #, %, or _ — a URL, say — then \url{...} from the url or hyperref package can be easier, since it also breaks the line at sensible points.

Typesetting a whole file (\verbatiminput)

To paste the contents of an external file as-is, the verbatim package (part of the LaTeX required tools) provides \verbatiminput{filename}. Load \usepackage{verbatim} in the preamble, then write \verbatiminput{program.py} in the body, and every line of that file is set verbatim. Unlike copying into the manuscript by hand, editing the source file updates the output automatically — no keeping the code and the document in sync by hand.

\usepackage{verbatim}
% ...
\verbatiminput{hello.py}

The same verbatim package also adds a comment environment that skips everything between \begin{comment} and \end{comment} — not for literal output but for *not* printing at all, useful for temporarily setting aside a draft passage.

It cannot go inside a command argument

This is the single most common stumbling block with verbatim. \verb and the verbatim environment cannot appear inside another command’s argument — for example inside \section{\verb|code|}, a \footnote{...}, a table cell, or a \caption{...}. The reason is category codes (catcodes — the role assigned to each character). \verb switches the catcode regime just before it reads its argument, but a command’s argument has already been converted to a token list under the normal catcodes at the moment the command was called — so interpretation is over before \verb can change anything. Writing it this way usually errors out.

There are two workarounds. One is the cprotect package: just prefix the offending command with \cprotect, and verbatim inside its argument goes through. For instance, write \cprotect\section{\verb"foo"}. There is also \cprotEnv for protecting the \begin of an environment.

The other is \SaveVerb / \UseVerb from fancyvrb (below): a two-step approach where you save the verbatim text under a name first, then merely call that name inside the argument. Save with \SaveVerb{label}|verbatim text|, and typeset it with \UseVerb{label}.

% Workaround 1: cprotect
\usepackage{cprotect}
\cprotect\section{The \verb|\foo| command}

% Workaround 2: fancyvrb SaveVerb / UseVerb
\usepackage{fancyvrb}
\SaveVerb{cmd}|\foo|
\section{The \UseVerb{cmd} command}

Keeping commands alive with alltt

In ordinary verbatim, you cannot highlight or color just part of a code example, because commands are switched off. The alltt package (also part of the standard LaTeX distribution) and its alltt environment solve this. alltt sets text monospaced and as-typed much like verbatim, except that the backslash \ and the braces { and } keep their usual meaning. So you get a verbatim-like look while still being able to run LaTeX commands inside.

\usepackage{alltt}
% ...
\begin{alltt}
def \textbf{greet}(name):
    return "Hi, " + name   \textit{# a comment}
\end{alltt}

Here the function name greet becomes bold and the comment becomes italic, while everything else stays exactly as typed. The trade-off is that to print the three characters \, {, } literally you must spell them out as \textbackslash, \{, \} (whereas verbatim prints them directly). Reach for alltt when you want to add light formatting by hand, and verbatim when you want everything truly as-is.

Line numbers and frames with fancyvrb

The built-in verbatim offers neither line numbers nor frames. The more capable choice is the fancyvrb package, centered on the capital-V Verbatim environment (a different beast from lowercase verbatim). You set options per environment as \begin{Verbatim}[key=value, ...], or globally from the preamble with \fvset{key=value, ...}.

The options you reach for most: numbers=left (or right) adds line numbers, frame=single draws a box around the whole block, and fontsize=\small sets the font size. And commandchars lets you keep a few commands working inside the otherwise-verbatim text.

The following example is a Verbatim block with line numbers on the left, a single frame, and a slightly smaller font.

\usepackage{fancyvrb}
% ...
\begin{Verbatim}[numbers=left, frame=single, fontsize=\small]
def greet(name):
    return "Hello, " + name
\end{Verbatim}

With commandchars=\\\{\}, the characters \, {, } act as the escape and group delimiters inside the verbatim text, letting you embed commands much like alltt. There is also \VerbatimInput[options]{filename} to pull in a whole file — unlike \verbatiminput, it accepts the options above. And via \SaveVerb / \UseVerb (shown earlier), verbatim works even inside command arguments.

One closing caveat: everything here is about printing text as-is, not syntax highlighting such as coloring keywords. To present program source with colors and formatting, the right tools are the dedicated listings package or minted, which uses Python’s Pygments (covered on the “Code listings” page).