enumitem (formatting, counters, inline)

LaTeX lists are too spaced out: that is usually why people reach for the enumitem package, yet few have looked at the actual numbers. In the article class the baseline-to-baseline distance between two items is 20pt, against 12pt for an ordinary line — eight extra points of air between every pair of items. Those eight points are two lengths, \itemsep (4pt) and \parsep (4pt), and the enumitem package exists to rewrite them directly through key=value options such as itemsep=0pt. This page follows what the defaults actually are, what nosep and leftmargin=* really change, and how \setlist sets a policy for a whole document — with measured numbers throughout.

What LaTeX's list defaults actually are

Measured in article at 10pt, level 1: \itemsep is 4pt, \parsep is 4pt, \topsep is 8pt, \leftmargin is 25pt, \labelwidth is 20pt and \labelsep is 5pt. With those numbers in hand the “too spaced out” complaint becomes concrete. The vertical gap inserted between two items is \itemsep plus \parsep, 8pt in total — add the 12pt leading and you get 20pt, so inside a body text set on a 12pt grid the list alone runs at 1.67 lines per item. Typographically that is deliberate: the entries are meant to separate visually. But ten short entries in a row leave the page looking gappy. The horizontal side is the same story: against a \leftmargin of 25pt, the bullet itself is under 5pt wide, so 20pt of that indent is simply air.

The values shrink with depth. At itemize level 2, \itemsep and \parsep drop to 2pt, \topsep to 4pt and \leftmargin to 22pt; at levels 3 and 4, \parsep reaches 0pt and \topsep 2pt, while \leftmargin thins to 18.7pt and then 17pt. LaTeX therefore starts out with a deliberate policy of opening up the shallow levels most, and deep nests are already tight. That is why the level you usually want to compress is level 1.

The key=value interface: the keys are LaTeX's own lengths

Load it in the preamble with \usepackage{enumitem} and the three environments itemize, enumerate and description gain an optional argument: write comma-separated key=value pairs in the brackets and that list is configured. The point of the design is that the key names are exactly the length names in the table above. itemsep=1ex rewrites \itemsep; leftmargin=1cm rewrites \leftmargin. Learning enumitem is therefore the same act as learning LaTeX's list internals — which is its real advantage over the older habit of overriding internal commands with \renewcommand. TeX Live 2024 ships Javier Bezos's v3.9 (2019/06/20); kpsewhich enumitem.sty tells you which copy your own installation uses.

\usepackage{enumitem}
% ...
\begin{itemize}[itemsep=1ex, leftmargin=1cm]
  \item the key names are the LaTeX length names
  \item second entry
\end{itemize}

The same key can be overridden at three levels — the whole document, one environment type, or a single list (through \setlist, below). The most specific value wins, so the tidy approach is to set a global policy first and opt out only where you must. Note that if a value is wholly wrapped in braces, one outer pair is stripped (the default keyval behaviour), so double them when you need the braces themselves to survive.

Compacting a list: nosep versus noitemsep

nosep zeroes four vertical lengths; noitemsep zeroes two. In the package source, nosep sets \partopsep, \topsep, \itemsep and \parsep all to 0pt, while noitemsep sets only \itemsep and \parsep. The one people forget is partopsep, the 2pt that is added only when the list begins after a blank line, as a new paragraph. Measured, an itemize with nosep puts its item baselines exactly 12pt apart — the same spacing as ordinary lines of text. The space above and below the list goes too, so it merges completely into the surrounding prose.

% nosep  -> partopsep = topsep = itemsep = parsep = 0pt
% noitemsep -> itemsep = parsep = 0pt, list keeps its 8pt topsep
\begin{itemize}[nosep]
  \item item baselines land exactly 12pt apart
  \item as tight as ordinary body text
\end{itemize}

Which to choose depends on whether the list is meant to read as part of the prose. When the entries are the main event — a procedure, a slide — nosep is fine. For a short list embedded in the body of a paper, noitemsep is the safer choice: the 8pt above and below survives, so the boundary between paragraph and list stays visible. Close up the top and bottom as well and the list glues itself to the neighbouring paragraphs, making it hard to see where the enumeration starts and ends. There is also an older key, nolistsep, which differs from nosep only in setting topsep to 0pt plus .1pt rather than a flat zero; for new documents, use nosep.

label= and ref=: styling the label and the cross-reference separately

A list's label is set with label=. Inside the value, the starred forms \arabic*, \alph*, \Alph*, \roman* and \Roman* stand for the current counter at that level. label=(\arabic*) gives (1) (2) (3), label=\alph*) gives a) b) c), and label=\Roman*. gives I. II. III. The starred forms take no argument; treat them as special spellings that mean something only inside a label. There is also label*=, which appends to the parent's label, so nesting accumulates numbers as 1., 1.1., 1.2. and so on.

\begin{enumerate}[label=(\arabic*), ref=\arabic*]
  \item \label{step:one} prepare the ingredients
  \item heat the pan
\end{enumerate}
Go back to step~\ref{step:one}.   % prints "step 1", not "step (1)"

By default, label= also governs how the cross-reference looks. Put a \label on an item of a list declared merely as [label=(\arabic*)], and \ref prints the parenthesised (1) — which is where the everyday annoyance of “go back to step (1)” with doubled brackets comes from. Add ref=\arabic* and the printed label stays (1) while \ref returns a bare 1. Compiling the code above confirms exactly that. Note that the label and ref values are treated as moving arguments, so a fragile command inside them may need \protect; the starred counter forms themselves are fine.

To write labels in the terse spelling of the old enumerate package, load it as \usepackage[shortlabels]{enumitem}. Writing A, a, I, i or 1 as the first element in the brackets then means \Alph*, \alph*, \Roman*, \roman* or \arabic* respectively, so \begin{enumerate}[(1)] works. This is handy when porting an old manuscript off the enumerate package, but in new work an explicit label= states the intent more clearly when you come back to it.

leftmargin=* and wide: letting the margin compute itself

The horizontal keys are not independent: they are bound by the single equation \leftmargin + \itemindent = \labelindent + \labelwidth + \labelsep. Hand * to some of them instead of a value and enumitem solves the equation for the rest. Measured, the effect is dramatic. A default itemize has \leftmargin at 25pt; add [leftmargin=*] and it shrinks to 9.99pt — just enough to hold the bullet. The reverse case matters more: with a wide label such as label=(\roman*), “(viii)” does not fit the default 20pt box and overhangs to the left, whereas adding leftmargin=* grows the box to match the label. Whenever you use a wide label, write leftmargin=* alongside it and you will avoid most of the accidents.

The other convenience key is wide. It zeroes the left margin and the label box so the label reads as part of the text and the entry sets like an ordinary paragraph. In the source it sets \leftmargin and \labelwidth to zero, puts its argument (default \parindent) into \labelindent, matches \listparindent to it, and computes \itemindent from the equation. Measured, \leftmargin comes out 0pt, \itemindent 20pt and \listparindent 15pt, which is \parindent. Pass a value, as in wide=0pt, to change the indentation. It is the key to reach for when the page design wants lists that do not jut leftward and a text block with one flush left edge. Worth pairing with it is align=, which decides whether the label sits flush left (left), flush right (right, the default) or in a left-aligned parbox (parleft) inside its box.

Starting at 5, or continuing the previous list (start, resume, series)

start= sets the number of the first item, and resume continues the numbering of the immediately preceding enumerate. Breaking a procedure with an explanatory paragraph and picking up again at “7.” is an extremely common need, and doing it by hand with \setcounter breaks the moment you insert one more step. Compiled for real, [start=5] produced 5 and 6; after an intervening paragraph, [resume] continued at 7. Use resume* and you inherit not only the number but the previous list's option settings as well (this starred form only means anything inside the environment's brackets).

\begin{enumerate}[start=5]
  \item numbered 5
  \item numbered 6
\end{enumerate}
An explanatory paragraph goes here.
\begin{enumerate}[resume]
  \item numbered 7 -- the count carries over
\end{enumerate}

resume looks only at the immediately preceding list, so it is not enough when several widely separated lists — across sections, say — should carry one running count. For that, use a series: tag the first list with series=name, then write resume=name or resume*=name on the later ones, and the numbering connects no matter what lies between. For a long procedure split across sections, this is the only approach that really holds up.

Document-wide defaults with \setlist, and your own list with \newlist

Writing the same options every time is not realistic. \setlist applies settings in bulk to a chosen list type and level: \setlist{...} with no brackets reaches every level of every list, \setlist[itemize]{...} all levels of itemize, and \setlist[enumerate,1]{...} only level 1 of enumerate. The starred \setlist* adds to the settings so far instead of replacing them. If you want to fix the gappiness described at the top of this page across a whole document, one line of \setlist{noitemsep} in the preamble is the highest-value change you can make.

\usepackage{enumitem}
\setlist{noitemsep}                    % tighten every list in the document
\setlist[itemize]{leftmargin=*}        % let itemize size its own margin
\setlist[enumerate,1]{label=(\arabic*), ref=\arabic*}

% a list type of your own
\newlist{steps}{enumerate}{1}
\setlist[steps]{label=\textbf{Step \arabic*.}, leftmargin=*}

Going further, you can define a list type of your own. \newlist{name}{type}{max depth} clones one of the three basic lists (enumerate, itemize or description) into a new environment, and a following \setlist[name]{...} gives it its look (you must at least set the label). Compiling the code above, \begin{steps} produced “Step 1.” and “Step 2.” The gain is less in the output than in the readability of the source: seeing \begin{steps} tells a reader that this is a procedure, without looking at the page. The meaning of the list is carried by its name rather than by its formatting.

Run-in lists inside a paragraph (enumerate*)

Load the package as \usepackage[inline]{enumitem} and you gain the starred environments enumerate*, itemize* and description*, whose entries run horizontally through a paragraph instead of breaking onto separate lines. Compiled, it reads as a single line: “We need (1) flour (2) sugar (3) salt for this.” When you are merely counting off three or four short phrases, this is often easier to read than spending four lines of the page on a displayed list — and in academic prose, enumerating conditions this way is the more standard style.

\usepackage[inline]{enumitem}
% ...
We need
\begin{enumerate*}[label=(\arabic*)]
  \item flour \item sugar \item salt
\end{enumerate*}
for this.

The separators are tuned with itemjoin (between items; a space by default), itemjoin* (for a different separator just before the last item — this is how you produce the English “a, b, and c”), and afterlabel (right after the label; ~ by default). Note that items of an inline list are boxed by default, so floats, nested lists and displayed equations cannot go inside; specify mode=unboxed if you need them. In practice the sensible line to draw is that inline lists are for short phrases only.