I have spent a couple of hours rethinking the literate style tools we have for LaTeX, which are essentially doc, docstrip and ltxdoc. Although the traditional workflow with a good editor can be less of a pain, imprisoning the code in guards and percentage marks can be disruptive to the flow of writing code, especially to newcomers. With this in mind and also to try and improve the typography and the functionality of the code, I came up with an alternative.

The central idea is to be able to use any class as the base class (in the MWE I have used the tufte-book) and to be able to have pretty printing using a package such as listings. The approach is to use only one .tex file which when compiled produces the documentation as well as the class, package or files.

Essentially it saves code verbatim when is defined. The MWE example only outputs to one .sty file, but it is possible to save to as many files as one needs (simulating the docstrip guards). A small installation script can be incorporated and self generated with LuaLaTeX if one wants to also simulate docstrips ability to install files in different directories.

What precautions should one take in developing such a code and are there any essential features of the doc/docstrip approach that cannot be incorporated in my approach?

 \def\rmdefault{bch} % not scaled
\usepackage[listings, theorems]{tcolorbox}
\definecolor{theblue} {rgb}{0.02,0.04,0.48}
\definecolor{thered}  {rgb}{0.65,0.04,0.07}
\definecolor{thegrey} {gray}{0.5}

\lstloadlanguages{[LaTeX]TeX, [primitive]TeX}

% Emphasis

       numbers=left, gobble=2,
     % keywordstyle=\ttfamily\textcolor{thegreen},
     showspaces=false,  % shows spacing symbol
      aboveskip=3pt plus1pt minus1pt, % compact the code looks ugly in type
      belowskip=7pt plus1pt minus1pt,  % user responsible to insert any skips


\newcommand\lorem{Fusce adipiscing justo nec ante. Nullam in enim.
 Pellentesque felis orci, sagittis ac, malesuada et, facilisis in,
 ligula. Nunc non magna sit amet mi aliquam dictum. In mi. Curabitur
 sollicitudin justo sed quam et quadd. \par}

\author{Y Lazarides}\publisher{Camel Press}
\title{\parindent0pt A New Approach in\\ Documenting Macros}




\chapter{The Approach}
\section{User Documentation}
The user documentation can be styled a bit better. The user should be able to 
write the package or class in a more natural style.\todo{Write a few more notes here.}

\begin{tcblisting}{colframe=thegreen,boxrule=1pt,colback=thered!5,listing options={style=tcblatex}}
The macro  \verb+\LaTeXe+, typesets the \LaTeXe logo.



  \ProvidesPackage{textsamples}[2012/02/13 v1.0 sample texts]


    Fusce adipiscing justo nec ante. Nullam in enim.
    Pellentesque felis orci, sagittis ac, malesuada et, facilisis in,
    ligula. Nunc non magna sit amet mi aliquam dictum. 
    In mi. Curabitur sollicitudin justo sed quam et quadd.


      \TeX\xspace (*@\sidenote{You can even place sidenotes.% 
      These notes have no impact on the %
      code being written to the file.} @*)
 % closes the open file

\section{Full listing of {textsamples.sty}}

Note, I have used listings for the verbatim writes and tcolorbox for the example self-running box. It also omits doc's many useful macros which would still need to be adapted.

  • Note that you have to save your sample code as textsamples.tex to make it work.
    – cjorssen
    Mar 8, 2012 at 12:19
  • Very nice approach. I always thought that a listings (pretty printing) support was missing to the doc/docstrip mechanism.
    – cjorssen
    Mar 8, 2012 at 12:19
  • @cjorssen Thanks for picking up the \jobname. I've removed a lot of code to make a MWE. Hardcoded it in the example.
    – yannisl
    Mar 8, 2012 at 12:24
  • Gorgeous! You may want to reset the line numbering before writing the full listing.
    – ienissei
    Mar 8, 2012 at 15:13
  • @ienissei Oops! Also at the full listing one should switch style, as I emphasize the macros as they were defined. Thanks for picking it up.
    – yannisl
    Mar 8, 2012 at 15:42

3 Answers 3


As discussed in earlier in the comments, it is quite possible to solve the problem of defining classes with this method. Granted, as you said, it takes two runs, but it is possible to make a document that will deal with the writing (and some minimal printing) on the first run, and that will process class-defined commands on the second run only (if correctly marked up, obviously).

In order to perform this check, I rely on the existence (or lack thereof) of an .aux file, because it is both easy – most IDEs can delete it in one click, it allows for overwrites, etc. – and user friendly in case of problem – as I expect most users to try to delete this file first if something goes wrong.

The only requirement is that we store the code in a class file instead of a package. The following MWE implements this solution, and also a macro-based solution to the problem of multiple files (you should write one file after the other, not mix them up haphazardly). Due to the fact that I am using comma-separated lists for the macros, it might make things easier to index, e.g. adding an optional argument for the type of thing created (macro, environment, counter, etc.).

The .cls file:





    \section{Listings for \jobname.\usefiletype}%
    The file contains the following code:


\newcommand{\numbercolor}{\color[HTML]{655643}}% Ash
\newcommand{\macrocolor}{\color[HTML]{78948D}}% Teal
\newcommand{\commentcolor}{\color[HTML]{BF4D28}}% Saffron
\newcommand{\mathcolor}{\textcolor[HTML]{CF872E}}% Ochre




    literate=   {\{}{{\bracketcolor\{}{\identifiercolor$\langle$}}{2}

    literate=   {\{}{{\bracketcolor\{}}{1}



% Create commands for globally adding indexation patterns. By default, it is assumed to be a control sequence


% Set default index
    {\entryname @\string\texttt{{\string\textbackslash}\entryname}\space(\entrytype)}

% Create a command for setting the macro type based on the optional argument to code
    % Create helper macros for text
    % Create helper macros for indexes
    % Default definitions
    % Specific type definitions
            \entryname @\string\texttt{{\string\textbackslash}\entryname}}}{}
          \def\macro@format{\textbackslash#2\par\textbackslash end#2}}{}
          \def\macro@format{\textbackslash#2\par\textbackslash end#2}}{}
            \entryname @\string\texttt{\entryname}\entrytype}}{}
            \entryname @\string\texttt{\entryname}\entrytype}}{}
            \entryname @\string\texttt{\string\textit{\entryname}}\space(\entrytype)}}{}
    % Append user created macros

            {\ClassError{literate}{Wrong item to index}{Control sequences must be indexed directly (no optional argument)\MessageBreak For parameters, write their type as an optional argument}}
            {\index{\csname index@#2\endcsname}}}
            {\ClassError{literate}{Wrong item to index}{Control sequences must be indexed directly (no optional argument)\MessageBreak For parameters, write their type as an optional argument}}
            {\index{\csname index@#1@#2\endcsname}}}}


          \@ifundefined{usefiletype}{\ClassError{literate}{Missing filetype definition}{You must specify which file to write to with the command \string\filetype}}{}%
      \csname\@lst @SetFirstNumber\endcsname%
      \csname\@lst @SaveFirstNumber\endcsname%


      \csname\@lst @SetFirstNumber\endcsname}
    {\csname\@lst @SaveFirstNumber\endcsname




And the .tex example of a self-documented class + package:


\addcs{ProvidesClass, definecolor, textcolor}

\addtoindex{col}{colour}{\macroname}{\entrytype!\entryname @\string\texttt{\entryname}}


% This is a sample copyright notice that will be printed verbatim at the beginning of all files.

\section{The first section}


The class (|.cls|) begins thus:

    [2011/03/20 v1 Some sample class]

Then we create a new macro:

% Some comment

It can be used this way:


And outputs this:

\mymacro[\emph]{some text}

Then we create a counter:

% Some comment

\section{The second section}


We also create an |.sty| file:

    [2011/03/20 v1 Some sample package]

\pagebreak A new environment:


A new color:


\textcolor{ochre}{Some ochre text!}

But perhaps should we return to talking about |\mymacro|\docindex{mymacro}, and later we'll switch back to colours\docindex[col]{ochre}.




Requires 2 runs of LaTeX to print the documentation + one run of MakeIndex and one final run of LaTeX.

Edit (April 3): Added an AfterEndEnvironment hook so the new macro names are set globally after the first code environment (fixes a bug in syntax highlighting).

Edit (April 10): Added several new things:

  • A macro for adding some control sequences to listings' colouring, without indexing them: \addcs{}, which takes a CSV list as its argument.

  • An environment that writes a copyright file and prints it at the beginning of every new file: \begin{copywrite}.

  • A command that inputs the listings of all created files, with a "heading" that can be customised via \renewcommand{\listingshead} – by default, I have set it to print a section title and a short sentence. (Could be made more customisable I suppose…)

  • Semi-automatic indexing (see below).

  • Some error messages, because wrong indexing commands are easy to produce and the LaTeX error message was really, really unhelpful.

Several macros that automatically index the marked content of every code environment based on its type. It also works with @ characters in macro names. By default, it is assumed that the string is a macro but you can change it using the optional argument (e.g. \begin{code}[e]{myenv} for an environment).

I have defined macros (m, default), environments (e), floats (f), lengths (l), dimensions (d), counters (c), packages (p) and options (o). New types can be defined implicitly:


in which case they will be treated as macros. They can also be defined explicitly in the preamble with:

\addtoindex{<short name>}{<name to index>}{<format>}{<indexing code>}
% The starred version is for control sequences, the normal version for everything else
% Helper macros are `\macroname`, `\entryname` and `\entrytype`

In the main file, you then need to write \docindex{mymacro} for control sequences, or \docindex[c]{mycounter} for everything else. This is made necessary by the fact that, while you can have only one control sequence with a given name, you can have several strings of other types with the same name (say the \chapter command vs the chapter counter and perhaps a chapter colour).

I will try to set up a repository with the complete file (which includes options at class selection), and try to work on some documentation as things are getting a bit complex now.

And I would indeed be very happy to get any feedback regarding bugs and possible features or improvements – in the hope that it can become a package once tested and cleaned up.

  • Thanks for the solution of the class issue. Will study it a bit more carefully tomorrow.
    – yannisl
    Apr 1, 2012 at 17:10
  • @YiannisLazarides Thanks. Let me know if you find any problem with it. I am working on a solution regarding indexes (preferably defining the type of macro we are indexing once, and then having one macro to index everything). I will edit my answer when it is working.
    – ienissei
    Apr 3, 2012 at 20:52
  • So far looks very promising and I added a forthcoming bonus for you:)
    – yannisl
    Apr 3, 2012 at 20:59
  • @YiannisLazarides Wow, very nice :) I will try to get the indexing to work in the next few days. I can parse things correctly at the moment, but I still need to do some string replacement, formatting and to load the indexing engines.
    – ienissei
    Apr 3, 2012 at 21:07
  • Thanks! Indexing is not the easiest things to get right and is about the only thing still missing so far.
    – yannisl
    Apr 3, 2012 at 21:11

Once a technology gets entrenched it is difficult to displace and doc/docstrip has been working well and served the community for many years.

The approach as listed above has certain limitations:

Use of the defined class/package. If used to define a class, the class itself cannot be used to typeset the code and the manual. This might be possible on two runs. Another possibility is to first typeset the code and its comments only, following it with the "user manual". Note that there is no "driver" in the approach used. So commands are available in a sequential order as they are entered and saved in the file.

Multiple files. One of the advantages of the doc/docstrip is that code can be saved in multiple files. The example above can be extended to cater for this.


Instead of hardcoding the filename in this case textsamples.sty, this can be passed onto Macro. It is also possible to extend the code to accept a list of files and or possibly to have special predicates similar to doc/docstrip.

Automating indexing. This will be hard to program as the contents of the Macro are not parsed fully. However, indexing commands can easily be added, so that when a macro is added it is indexed. This will also eliminate the problem of overindexing and having to exclude commands from the index. Rather it leaves it to the user to add commands as necessary.

I have used a slightly modified approach to the above to document JavaScript code and so far it has proved very useful.


There is other literate programming tools that can be used to prepare TeX macros. I have experience with using noweb (Norman Ramsey's web) but have heard about another option muweb. Both noweb and muweb provide a language agnostic implementation of cweb and ctangle.

Since noweb is language agnostic it provides an extension mechansim, so that external tools can be used to produce the list of macros used in some code snippet. (I think there is some available, but I am not sure I used it).

If you use noweb to produce LaTeX macros it supports:

  • Using the defined class to prepare the documentation.
  • Multiple file (look up for roots in the documentation).
  • Automated indexing (with an appropriate filter).
  • Generation of HTML documentation, instead of LaTeX, which is very nice for online documentation.
  • Use of code snippets, so that you can avoid \input statments if you want to provide easy to use files (for instance, if you send your files to a journal or on the arXiv).

If you are interested to see how the output look like, I have written a complete TeX format using this, it is called Bhrìd TeX and is free software. Example output is found in the download section, the file is called bhridman.pdf (in French).

I also have useful Makefile macros to ease the use of NOWEB, they are called BSD Make Pallàs Scripts and the file you are looking for is noweb/noweb.latex.mk.

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .