How to speed up compilation of a beamer document? - TeX

TopAnswers TeX

Top Answer

samcarter

There are many different methods one can try. Some ideas in no particular order

### 1. Compile only the frames I'm working on

This can be done using the `\includeonlyframes` command (or `\includeonlylecture` for longer elements)

```
\documentclass{beamer}

\includeonlyframes{foo}

\begin{document}
	
\begin{frame}[label=bar]
  abc
\end{frame}  
  
\begin{frame}[label=foo]
	def
\end{frame}	
	
\end{document}
```

### 2. Avoid time consuming elements

Things like complicate tikz pictures can take quite long to compile. Instead of recompiling them every time one changes something somewhere else in the presentation, one could make a standalone pdf out of them and then include this with `\includegraphics{...}`.

If there are only a few of such images, a simple standalone document can be used:

```
\documentclass{standalone}
\usepackage{tikzducks}

\begin{document}
	
\begin{tikzpicture}
	\duck[]
\end{tikzpicture}	
	
\end{document}
```

If you have many complicate tikz images, using the `external` library might be more comfortable (this needs to be compiled with shell-escape enabled)

```
% !TeX program = txs:///arara
% arara: pdflatex: {synctex: on, interaction: nonstopmode, shell: yes}

\documentclass{beamer}

\usepackage{tikz}
\usetikzlibrary{external}
\tikzexternalize

\usepackage{tikzducks}

\begin{document}
	
\begin{frame}
	\begin{tikzpicture}
    \duck
  \end{tikzpicture}
\end{frame}	
	
\end{document}
```

### 3. Temporarily disabling overlays

Animations with a lot of individual slides can also slow down things. Will work is still in progress, it can make sense to disable them. For individual frames one can temporally restrict which overlays will be show 

```
\begin{frame}<1>
a \pause b
\end{frame}
```

or one can disable them for the whole presentation using the `handout` option

```
\documentclass[handout]{beamer}
```

### 4. Dedicated compilation tools

There are a couple of dedicated compilation tools, which try to recompile only slides that have been modified, e.g. 

- https://github.com/misc0110/beamer-preview

- https://github.com/theHamsta/faster-beamer

(remember to compile the final version normally to get page numbers, cross-refs etc. right)

----

With all these approaches, keep an eye on how long it would take you to implement vs. how much time it safes 

https://xkcd.com/1205/

Answer #2

Skillmon

**Note:** The following is applicable for any document which is compiled multiple times without changes to the preamble and not restricted to `beamer`. However dumping a format doesn't work (easily) when you're using LuaTeX, as the Lua state isn't included in the format at all.

-----
 # Build your own format

If your preamble contains many big packages (Ti*k*Z & `pgf` for example) you can speed up the compilation by building your own format from your preamble and using that one instead (actually this speeds up the compilation in almost every case, but it is more noticeable the bigger your preamble is, obviously).

Most things should work this way (I use this way of compiling for all my bigger projects and so far only had problems with two things, one of which was freezing the date by explicitly setting the values of `\day`, `\month`, and `\year`, the other was setting the display skips, both of which were easily fixed with `\AtBeginDocument`). But your mileage my vary.

This uses the handy [`mylatexformat`](https://ctan.org/pkg/mylatexformat), with it you can compile your preamble into a format by using:

```sh
<engine> -ini -jobname="<file>" "&<engine>" mylatexformat.ltx """<file>.tex"""
```

With `<engine>` being one of `pdflatex`, `lualatex`, or `xelatex`, and with `<file>` being the name of your main file without the `.tex` ending. This will produce a file called `<file>.fmt`, afterwards you can compile your document with

```sh
<engine> -fmt="<file>" <file>.tex
```

(with the same substitutions for `<engine>` and `<file>` as above).

Keep in mind that you have to recreate the format every time you make changes to your preamble if you want to use this approach (else your changes wouldn't have any effect).

This approach compiles everything until `\begin{document}` into a format, you can however end this earlier by putting `\csname endofdump\endcsname` into your preamble. Note that if you use the `minitoc` package, it has to be loaded after `\csname endofdump\endcsname` according to `mylatexformat`'s documentation.

If you're using PNGs it is worth batch-converting them to PDF and using those instead. PNG takes *really* long to be included by LaTeX, as it isn't supported by the PDF standard and has to be reencoded, whereas many other picture formats can be more or less directly dumped into the PDF.

@@@ xkcd 1205 3e44cec838dc479df95d67fe4d41ec1515573c05a6dfc0c698d0e2b9b840841c "Is It Worth the Time?" "Don't forget the time you spend finding the chart to look up what you save. And the time spent reading this reminder about the time spent. And the time trying to figure out if either of those actually make sense. Remember, every second counts toward your life total, including these right now."

Yes, I had heard the "shifting things around" argument quite a few times. And it is a valid argument, if you have not enough experience with LaTeX this can drive you crazy. (This is, BTW, one of the reason why I do not like `expl3`. It makes LaTeX even more inaccessible for those who use it occasionally, and eventually we will pay a very high price for it.)

For those: absolutely. Even these rotating polyhedra freak me out. (But `externalize` won't help because I keep changing the TeX code till I am happy, but it absolutely will help if I had more than one such animation in a presentation.)

This was not meant to be a criticism. Just a comment that I had tried some of these before, and had unexpected problems. However, I agree that one cannot list all unexpected problems. Yet one could perhaps say that some of these tricks can lead to obstacles, and that the user needs to gauge how much time they can save by somewhat speeding up the compilation time (as opposed to debugging additional issues).

> compilation time you save with these tricks is typically of the order of seconds Admittedly not the typical use case, but for some of the scenes of the X-mas extravaganza the saved time is in the order of half an hour :)

Coming from the experimental site I don't often see the "too many formula" problem, but nevertheless one can often recognise ppt vs. beamer immediately: ppt slides are often crammed with as many things as possible while beamer slides keep to some structure like images not going into the margin etc. because it is simply not that easy to shift things around :)

I agree that there are many situations in which some of the techniques won't be applicable. But isn't this the case for basically everything one does in tex? I think giving a long list of possible problems will make the answer rather confusing. How about a separate Q&A about possible drawbacks and workarounds of externalise?

Each of the suggestions are interesting and good. However, I also feel that some of them should come with a bit more fine print. To give an example, `externalize` is great. However, you need to know that it does not work with everything "out of the box". For instance, it does not work with `tikzmark` unless you have taken precautions. My own experience is that the compilation time you save with these tricks is typically of the order of seconds, or below, unless you have a really huge presentation. Finding out why something does not work can take tens of minutes, or more. So one should first verify that the time one could save is really critical. Another side remark is that people often say that Powerpoint or Keynote presentations are better. This is not because the slides are more pretty (they aren't), but because it is much harder to add equations, so these presentations carry less and shorter equations. And such presentations are typically better. So in a way it is a good thing if the user gets penalized when adding too much stuff because this prevents them from overdoing it.

2 Answers