LaTeX Export for Org Mode < 8.0

The tags used for the single export case are held in two variables: org-export-select-tags is a list of tags, initially set to export, that select a tree or sub-tree for export; org-export-exclude-tags is a list of tags, initially set to noexport, that exclude a tree or subtree for export. The effect they have on export is logical, but the logic isn't necessarily what one might expect. In particular, if both select tags and exclude tags are to be used in the same buffer, then their use must follow certain rules. Also, the handling of unmarked trees and subtrees changes depending on which tags are used and how they are used.

If neither select tags nor exclude tags are used, then all of the trees and their subtrees are sent to the LaTeX exporter. If, however, a select tag is added to a tree as in the example below, then unmarked trees will not be sent to the exporter. Thus, the effect of a select tag is not restricted to its tree; its effect extends to the entire buffer.

* Tree 1                                                             :export:
,   This is exported
** Subtree 1
,   This is also exported
* Tree 2
,  This is not exported
** Subtree 2
,  This is not exported, either

Once the scope of the tag's effect is grasped, the primary rule of using select and exclude tags is obvious: only one type of tag may be used for the trees of a buffer. If both types of tags are used for trees, how can Org-mode decide what to do with the unmarked trees?

A corollary of this rule is that the other type of tag can only be used in a subtree of the tagged tree in order to reverse the effect of the tree-level tag, as in the following example.

* Tree 1                                                             :export:
,   This is exported
** Subtree 1                                                       :noexport:
,   This is not exported
* Tree 2
,  This is not exported
** Subtree 2
,  This is not exported, either

In the multiple export case, tags used to select a tree or subtree for export are defined in .emacs as part of the configuration needed to specify the many properties of a publication project. A tutorial illustrates the flexibility of the publishing mechanism using an HTML example. The intricacies of the publishing mechanism are beyond the scope of of this LaTeX export tutorial. Here, a working example³ is described.

In the example, the file index.org holds material for two export targets, one related to work items and the other related to home. The variable org-publish-project-alist has two entries, one for a project named work and the other for a project named home. Both projects are based on the file index.org located in ~/notes/org.

Both projects will create output files named index.tex, based on the name of the Org-mode file used for import. The two index.tex files are kept separate by writing them to different directories, as indicated by the keyword argument :publishing-directory.

(setq org-publish-project-alist
      '(
        ("work"
         :base-directory "~/notes/org/"
         :base-extension "org"
         :publishing-directory "~/notes/export/work/"
         :publishing-function org-publish-org-to-latex
         :select-tags     ("@WORK")
         :title "Work Notes"
         :include ("index.org")
         :exclude "\\.org$"
         )
        ("home"
         :base-directory "~/notes/org/"
         :base-extension "org"
         :publishing-directory "~/notes/export/home/"
         :publishing-function org-publish-org-to-latex
         :select-tags     ("@HOME")
         :title "Home Phone"
         :include ("index.org")
         :exclude "\\.org$"
         )
        ))

The parts of index.org tagged @WORK can now be exported to ~/notes/export/work/index.tex with C-c C-e X and selecting the work project.

Similarly, the parts of index.org tagged @HOME can now be exported to ~/notes/export/home/index.tex with C-c C-e X and selecting the home project.

The variable org-entities-user holds the information needed to define special characters. In response to a question posed by Rasmus Pank Roulund, Lawrence Mitchell described how to use this variable to define an escaped space, which is used in LaTeX to insert a single space, instead of a double space, after a period that doesn't end a sentence.

With this definition:

(setq org-entities-user '(("space" "\\ " nil " " " " " " " ")))

then

this is some text, e.g.\space foo bar

is exported as

this is some text, e.g.\  foo bar

For simple block-level arbitrary markup, you can use the contributed package org-special-blocks, which turns #+begin_foo into \begin{foo} upon LaTeX export. You can use ordinary Org markup inside the block. For example, you can wrap an abstract in

#+BEGIN_ABSTRACT
This is an *abstract* with ordinary =Org-mode= /markup/.
#+END_ABSTRACT

For more complex cases, where you need to pass parameters or process block contents, but don't want to use literal LaTeX, you may want to explore the possibilities of the contributed org-exp-blocks package.

An example of block-level markup for a results block that will be typeset with a shaded background:

#+LaTeX_HEADER: \usepackage{framed}
#+LaTeX_HEADER: \usepackage{xcolor}
#+LaTeX_HEADER: \definecolor{shadecolor}{gray}{.95}
#+LaTeX_HEADER: \newenvironment{results}{\begin{shaded}}{\end{shaded}}

Inline arbitrary semantic markup can be implemented by defining a new link type in .emacs.⁴ The following code block defines a new link type, latex, whose path argument can hold the name of any LaTeX command. This one defines export markup for HTML and LaTeX. A link such as [latex:proglang][Org-mode] will export \proglang{Org-mode} to the LaTeX file. In this way, it is possible to make the Org-mode LaTeX exporter conform to the semantic markup defined in arbitrary style files. Org-mode will even complete your new link type!

(org-add-link-type
 "latex" nil
 (lambda (path desc format)
   (cond
    ((eq format 'html)
     (format "<span class=\"%s\">%s</span>" path desc))
    ((eq format 'latex)
     (format "\\%s{%s}" path desc)))))

Two examples of LaTeX commands for inline semantic markup:

#+LaTeX_HEADER: \let\progstruct=\texttt
#+LaTeX_HEADER: \newcommand{\progexample}[1]{{\ttfamily\small #1}}

The LaTeX caption command is typically passed two arguments: the required argument, which is typeset with the figure or table; and the optional argument, which appears in the List of Figures or List of Tables. It is common nowadays, especially in the sciences, to have long captions (actually captions plus legends) with figures and much abbreviated versions, typically less than a line long, in the List of Figures. In addition, many styles require that figure captions end with a period; the caption passed to the List of Figures should not end in a period.

The Org-mode #+CAPTION: macro handles an optional argument.

This construct:

#+CAPTION[Short caption]: Long caption.

exports:

\caption[Short caption]{Long caption.}

In the default configuration, the Org-mode LaTeX exporter includes a function that sandwiches the LaTeX \tableofcontents command between a command that sets the depth of the headings that appear in the table of contents (based on the number of headline levels that will be exported as headings, rather than lists) and a command to add some vertical space. Neither of these additions to the \tableofcontents command is especially desireable. It is often the case that one wants the table of contents depth to differ from the depth to which sections are numbered. Also, in the LaTeX world, the space between the end of one element and the start of another is something that is specified within a class or style file, rather than within the document itself. Formatting with the class or style file exclusively can give the finished document a pleasing stylistic uniformity that is difficult to achieve in an ad hoc way. Also, hardwiring the table of contents in this way always puts it directly following the output of the LaTeX maketitle command. In practice, however, it is often useful to print an abstract or executive summary between the title and the table of contents. Fortunately, the LaTeX exporter is coded in such a way that it is possible for the user to alter this behavior relatively easily.

(defun org-export-latex-no-toc (depth)
    (when depth
      (format "%% Org-mode is exporting headings to %s levels.\n"
              depth)))
  (setq org-export-latex-format-toc-function 'org-export-latex-no-toc)

With this setup, place the abstract and #+LATEX: commands for frontmatter before the first exported headline, e.g.,

#+BEGIN_abstract
  [Abstract here]
#+END_abstract
#+LATEX: \tableofcontents
#+LATEX: \listoftables
#+LATEX: \listoffigures
* First Exported Headline

The default title created by the LaTeX exporter is often just fine, but in cases where you would like to include specific information in the title, or create a custom title page, then perhaps the best way to do this was posted to the Org-mode list by Nick Dokos:

#+LATEX_HEADER: \input{mytitle}

* Foo
 foo

* Bar
 bar

where the file mytitle.tex looks like this:

\renewcommand\maketitle{\begin{titlepage}%
FOO
\end{titlepage}%
}

The LaTeX exporter will fontify exported code blocks written in any language that has an associated Emacs mode for editing. If you want to export pseudo-code, for which there is no corresponding Emacs mode, then one approach is to use #+begin_latex ... #+end_latex and write the pseudo-code directly in LaTeX. This depends on the LaTeX listings package, which is one of the default packages used by Org-mode.

Dan Davison provided this example on the Org-mode list:

#+begin_latex
\begin{algorithm}
 \caption{An algorithm}
 \label{alg:myalg}
 \begin{lstlisting}[mathescape,escapeinside='']
   '\foreach individual $i$'
       '\foreach group $k$'
           $\gamma_{ik} \getsp Q_{k}\prod_{l}\prod_{a=1}^{2}P_{lkX_{ila}}$
 \end{lstlisting}
\end{algorithm}
#+end_latex

Org-mode supports two LaTeX packages for typesetting and fontifying source code; listings and minted. The listings package is a pure LaTeX implementation that works reasonably well, but the package appears to be orphaned and the latest documentation was written in 2007. In contrast, the minted package is not a pure LaTeX solution and relies on an external Python script, pygmentize, to typeset and fontify source code. This package appears to be actively maintained. Both packages are included in the TeXLive and MacTeX LaTeX distributions. If your distribution lacks one or the other, then you'll need to check the documentation for instructions how to install them.

The two packages are structured somewhat differently, but it is possible to configure Org-mode so that these differences are mostly smoothed over, making it possible to generate LaTeX code that will work with either package. The two main differences have to do with the minted package's generation of language names by appending code to the language name; this convention is not followed by the listings package. In addition, the minted package defines styles, by which it means colorizing semantic elements of the programming language. This facility is not implemented in the listings package.

The following sections show the basics of listings and minted setups which, when exported to LaTeX, illustrate the ability of each package to typeset and fontify source code on a per-language basis.

In this example, the minted package is specified in the #+LaTeX_HEADER:. This is followed by a command to use the minted style emacs, which colors source code in a way familiar to emacs users. The final #+LaTeX_HEADER: line uses the newminted macro to set the font size for code blocks of common-lisp.

The source code block setup-minted includes emacs-lisp code that might typically appear in .emacs, but can be useful in a source code block where it can be used to configure LaTeX export for an individual document. In the source code block, the variables that control LaTeX export using the minted package are configured. First, org-latex-listings is set to use the minted package. Then, the variable org-latex-custom-lang-environments is used to associate the emacs-lisp code of an Org-mode source code block with the common-lisp language that the minted package knows how to parse. Note that this is given as common-lispcode here, but as common-lisp in the call to the newminted macro. The minted package appends code to language names by default. The variable org-latex-minted-options sets typesetting options that will apply to all programming languages. See the minted package documentation for the very many options that can be set with key/val pairs. The three entries in the association list call for source code blocks to be framed with lines, set in a very small font, and identified with line numbers. In relation to these settings, the emacs-lisp code will be set at a slightly larger font size. Finally, the variable org-latex-to-pdf-process is set using the -shell-escape option so the external pygmentize program can be called and its results incorporated into the pdf document. Note that using the -shell-escape option creates security holes.

A Python source code block at the end illustrates how the default emacs-style code differs from the specially formatted emacs-lisp source code.

#+LATEX_CLASS: article
#+LaTeX_HEADER: \usepackage{minted}
#+LaTeX_HEADER: \usemintedstyle{emacs}
#+LaTeX_HEADER: \newminted{common-lisp}{fontsize=\footnotesize}

#+name: setup-minted
#+begin_src emacs-lisp :exports both :results silent
     (setq org-latex-listings 'minted)
     (setq org-latex-custom-lang-environments
           '(
            (emacs-lisp "common-lispcode")
             ))
     (setq org-latex-minted-options
           '(("frame" "lines")
             ("fontsize" "\\scriptsize")
             ("linenos" "")))
     (setq org-latex-to-pdf-process
           '("pdflatex -shell-escape -interaction nonstopmode -output-directory %o %f"
             "pdflatex -shell-escape -interaction nonstopmode -output-directory %o %f"
             "pdflatex -shell-escape -interaction nonstopmode -output-directory %o %f"))
#+end_src

#+name: another-listing
#+begin_src python :exports code
   x = str(y)
#+end_src

When this example is exported (C-c C-e d) the resulting pdf file contains two source code blocks nicely typeset and colored in a way common to many emacs setups.

In this example, the listings package is specified in the #+LaTeX_HEADER:. It is followed by three #+LaTeX_HEADER: lines that construct a call to the lstnewenvironment command that associates the language identifier common-lispcode with the Lisp language that the listings package knows how to parse, and configures typesetting options that will apply to code identified as common-lispcode. Note that common-lispcode is used here simply to conform with the setup used by the minted package for typesetting emacs-lisp code. The final #+LaTeX_HEADER: line defines a new LaTeX command that configures typesetting Python code inline.

The source code block setup-listings instructs Org-mode to use the listings package. It sets the variable org-latex-custom-lang-environments to associate emacs-lisp source code in Org-mode with common-lispcode, as defined by lstnewenvironment. Then it configures default options in the variable org-latex-listings-options that place a frame around source code blocks, set code in a fairly small font, and number lines at the left with tiny numbers. The variable org-latex-to-pdf-process doesn't need to use the -shell-escape option in the call to pdflatex because the listings package is pure LaTeX and doesn't rely on the output of external programs. A new link type, latex, is defined. This can be used to markup inline code snippets. This is followed by a short Python source code block that illustrates the difference between the default typesetting options and the options specified for emacs-lisp source code blocks. Finally, the latex link type is used to call the new python command to typeset an inline code snippet.

#+LATEX_CLASS: article
#+LaTeX_HEADER: \usepackage{listings}
#+LaTeX_HEADER: \lstnewenvironment{common-lispcode}
#+LaTeX_HEADER: {\lstset{language={Lisp},basicstyle={\ttfamily\footnotesize},frame=single,breaklines=true}}
#+LaTeX_HEADER: {}
#+LaTeX_HEADER: \newcommand{\python}[1]{\lstset{language={Python},basicstyle={\ttfamily\small}}\lstinline{#1}}

#+name: setup-listings
#+begin_src emacs-lisp :exports both :results silent
  (setq org-latex-listings 'listings)
  (setq org-latex-custom-lang-environments
        '((emacs-lisp "common-lispcode")))
  (setq org-latex-listings-options
        '(("frame" "lines")
          ("basicstyle" "\\footnotesize")
          ("numbers" "left")
          ("numberstyle" "\\tiny")))
  (setq org-latex-to-pdf-process
        '("pdflatex -interaction nonstopmode -output-directory %o %f"
        "pdflatex -interaction nonstopmode -output-directory %o %f"
        "pdflatex -interaction nonstopmode -output-directory %o %f"))
  (org-add-link-type
   "latex" nil
   (lambda (path desc format)
     (cond
      ((eq format 'html)
       (format "<span class=\"%s\">%s</span>" path desc))
      ((eq format 'latex)
       (format "\\%s{%s}" path desc)))))
#+end_src

#+name: another-listing
#+begin_src python :exports code
  x = str(y)
#+end_src

This is an inline snippet of Python: [[latex:python][x = str(y)]].

When this example is exported, both source code blocks are typeset without any semantic markup, which would be specified by element, rather than with a style as with the minted package.

LaTeX divides table handling into two parts: typesetting the actual table, and placing the table on the page along with a caption and cross-reference information.

LaTeX provides several environments for typesetting tables. The LaTeX exporter currently supports a well-rounded subset of these:

tabular

table doesn't break across pages, user responsible for determining column widths

tabularx

table doesn't break across pages, width of table specified by user, automatic calculation of column widths

tabulary

like tabularx, but tries harder to calculate optimal column widths

longtable

table breaks across pages, can't be used in a multicolumn page layout

Because the various tabular envionments don't break across pages, they are typically "floated" by wrapping them in a table environment, or for a table that spans columns in a multi-column page layout, a table* environment. LaTeX will "float" the typeset table to an appropriate place in the output, ensuring that the table doesn't run off the end of the page (unless it is taller than the text height). Note that the LaTeX environments responsible for handling the information specified by #+CAPTION: and #+LABEL: are table, table*, and longtable. If tabular, tabularx, and tabulary are used by themselves, then they won't support captions and cross-references.

The tables in many high-quality publications use rules of different widths for the different "lines" in a table. The horizontal rules at the top and bottom of a table are heavier than the rule separating the column heads from the table body. In general, good table design discourages the use of vertical rules; they are superfluous in an otherwise well-designed table.

The LaTeX exporter currently uses rules of the same width everywhere in a table. It is possible to get book quality tables.

The following steps assume that the org-babel-load-languages variable has an entry (latex . t) and that functions in the Library of Babel are available. I have this in .emacs so that Org-mode knows where to find the Library of Babel (but don't know if it is strictly necessary):

(org-babel-lob-ingest "/path/to/library-of-babel.org")

First, load the booktabs package:

#+LATEX_HEADER: \usepackage{booktabs}

Then, give your table a name, e.g., #+tblname: test-table and put it somewhere the LaTeX exporter won't see, perhaps in a sub-tree tagged with :noexport:.

Finally, create a LaTeX source block something like this:

#+name: tabularx-export
#+begin_src latex :exports results :results latex :noweb yes
  \begin{table}[htb!]
  \centering
  \footnotesize
  \caption{A table to test booktabs}
  \label{tab:test-table}
  <<booktabs(table=test-table,align="lrX",env="tabularx",width="\\textwidth")>>
  \end{table}
 #+end_src

When you export the file to LaTeX, this code block is expanded in a #+results: block and wrapped in #+BEGIN_LaTeX … #+END_LaTeX. If the table has column heads, then the rule beneath them should be finer than the rules at the top and bottom of the table.

In a better world, the LaTeX footnote command would work inside a tabular environment, setting the notes at the end of the table. The current situation is described in the TeX FAQ. A manual solution is possible, and can be implemented in Org-mode as follows.

First, define a counter that uses table note marks (asterisk, dagger, pilcrow, etc.) and a command to use it. Here is an example:

#+LaTeX_HEADER: \newcounter{my@fn}
#+LaTeX_HEADER: \newcommand{\fn}[1]{\setcounter{my@fn}{#1}\textsuperscript{\fnsymbol{my@fn}}}

Then use a LaTeX source block that calls booktabs-notes from the Library of Babel.

#+begin_src latex :exports results :results latex
  \begin{table}[htb!]
    \centering
    \footnotesize
    \caption{The table caption without Org-mode markup}
    \label{tab:dates}
    <<booktabs-notes(table=dates,notes=dates-fn,lspace=t,align="rcr",env="tabular")>>
  \end{table}
#+end_src

This works like booktabs (see Table Rules), except it accepts a second Org-mode table that contains the table notes. Remember that both of these Org-mode tables are sent to orgtbl-to-generic so Org-mode markup within them won't give the results you might expect. Instead, the table entries use LaTeX markup.

#+tblname: dates
| One\fn{1} | Two\fn{2} | Three\fn{3} |
|-----------+------------+-------------|
| A         | B          | C           |
| D         | E          | F           |

#+tblname: dates-fn
| \multicolumn{3}{l}{\fn{1} A table note.}               |
| \multicolumn{3}{l}{\fn{2} Another table note.}         |
| \multicolumn{3}{l}{\fn{3} The \emph{last} table note.} |

There is also a switch, lspace, which if set non-nil calls the addlinespace command from the booktabs package after the bottomrule that separates the table body from the notes.

Tables often benefit from a smaller font size than the body text of a document. However, Org-mode doesn't offer a way to change the font size in a table. A discussion on the Org-mode list yielded two solutions, one of which makes a setting for all the tables in the Org-mode document and another that is used on individual tables.

The first solution, offered by Nick Dokos, uses a LaTeX style file, illustrated here with scripttab.sty. This style file sets all the tables in the document with the same size font. The command \scriptsize yields a very small font; the particular size is determined in LaTeX by the font size of \normalsize. Note that \scriptsize can be replaced by another legal LaTeX font size, such as \footnotesize or \small.

\makeatletter
\def \@floatboxreset {%
        \reset@font
        \scriptsize %\footnotesize %\small
        \@setminipage
}
\makeatother

Put scriptab.sty where LaTeX can find it and then add this line to the Org-mode file:

#+LaTeX_HEADER: \usepackage{scripttab}

A second approach, which sets the font size for an individual table with the #+ATTR_LaTeX line, was proposed by Suvayu Ali. This solution is documented on Org ad hoc code, quick hacks and workarounds. Any LaTeX command that works inside the table environment can be passed in this way.

In standard LaTeX, lists are set with a lot of vertical white space and it is sometimes nicer to set them more compactly. This can be accomplished with the paralist package.

#+LaTeX_HEADER: \usepackage{paralist}

You can redefine the standard LaTeX list environments with their compact paralist equivalents:

#+LaTeX_HEADER: \let\itemize\compactitem
#+LaTeX_HEADER: \let\description\compactdesc
#+LaTeX_HEADER: \let\enumerate\compactenum

With these settings, all the lists in the Org-mode document will be exported in compact form.

The paralist package has a facility for setting lists in paragraphs, rather than displayed separately. Typically the lists in a paragraph are enumerated and it is possible to set Org-mode's enumerated lists in paragraph, while displaying itemized and description lists.

#+LaTeX_HEADER: \let\itemize\compactitem
#+LaTeX_HEADER: \let\description\compactdesc
#+LaTeX_HEADER: \let\enumerate\inparaenum

With the paralist package you can also specify how to enumerate the list. These two examples use lowercase Roman numerals in parentheses and lowercase letters in parentheses, either of which might be used when an enumerated list is set in a paragraph.

#+LaTeX_HEADER: \renewenvironment{enumerate}{\begin{inparaenum}[(i)]}{\end{inparaenum}}
#+LaTeX_HEADER: \renewenvironment{enumerate}{\begin{inparaenum}[(a)]}{\end{inparaenum}}

Checkboxes aren't supported natively in LaTeX, so Org-mode rolls its own. The variable org-export-latex-list-parameters controls how this is done. Skip Collins and Nick Dokos discussed how to modify these parameters. Their discussion resulted in a proposal for better looking checkboxes.

#LATEX_HEADER: \setbox0=\hbox{\large$\square$}

#+BIND: org-export-latex-list-parameters (:cbon "[{\\parbox[][][c]{\\wd0}{\\large$\\boxtimes$}}]" :cboff "[{\\parbox[][][c]{\\wd0}{\\large$\\square$}}]")

Bera is the LaTeX version of the Bitstream's Vera family of fonts. The family includes serif, sans-serif, and monospace fonts designed to work well with one another.

#+LaTeX_HEADER: \usepackage[T1]{fontenc}
#+LaTeX_HEADER: \usepackage[scaled]{beraserif}
#+LaTeX_HEADER: \usepackage[scaled]{berasans}
#+LaTeX_HEADER: \usepackage[scaled]{beramono}

Charter was designed to reproduce well on low-resolution 300 dpi printers. It is paired here with Helvetica and Courier, like Times, for which it is an alternative. Helvetica is set a bit smaller to match the shape of the Charter font. These fonts conflict with the amssymb= package.

#+LaTeX_HEADER: \usepackage[T1]{fontenc}
#+LaTeX_HEADER: \usepackage[bitstream-charter]{mathdesign}
#+LaTeX_HEADER: \usepackage[scaled=.9]{helvet}
#+LaTeX_HEADER: \usepackage{courier} % tt

Garamond refers to a group of old-style serif typefaces and is named after the sixteenth-century type designer, Claude Garamond. It is an elegant typeface. Garamond requires a bit more leading than normal. The sans-serif font is Latin Modern and the typewriter font is Courier. Both were chosen to match the shape and stroke weight of Garamond.

#+LaTeX_HEADER: \usepackage[T1]{fontenc}
#+LaTeX_HEADER: \usepackage[urw-garamond]{mathdesign}
#+LaTeX_HEADER: \usepackage{lmodern}
#+LaTeX_HEADER: \usepackage{courier}
#+LaTeX_HEADER: \linespread{1.0609}

The KP font family is produced by Christophe Caignaert for the Johannes Kepler project. The family supports math.

#+LaTeX_HEADER: \usepackage[T1]{fontenc}
#+LaTeX_HEADER: \usepackage{kpfonts}

The Linux Libertine Project produces OpenSource fonts. Libertine is a replacement for Times New Roman and includes a companion sans-serif font. It was used to typeset the Wikipedia logo. The monospace typewriter font is Latin Modern.

#+LaTeX_HEADER: \usepackage[T1]{fontenc}
#+LaTeX_HEADER: \usepackage{libertine}
#+LaTeX_HEADER: \renewcommand*\oldstylenums[1]{{\fontfamily{fxlj}\selectfont #1}}
#+LaTeX_HEADER: \usepackage{lmodern}

The Nimbus font set uses fonts from the Tex-Gyre distribution, which provides a rich collection of diacritical characters in the attempt to cover as many Latin-based scripts as possible. The serif font is Termes, which is a replacement for Times Roman. The sans-serif font is Heros, which is a replacement for Helvetica. The monospace font is Cursor, which is a Courier replacement.

#+LaTeX_HEADER: \usepackage[T1]{fontenc}
#+LaTeX_HEADER: \usepackage{tgtermes}
#+LaTeX_HEADER: \usepackage[scale=.85]{tgheros}
#+LaTeX_HEADER: \usepackage{tgcursor}

The beautiful, old-style serif font, Palatino, was designed by Herman Zapf. It is somewhat heavier and easier to read than Garamond. Palatino gets a bit more leading than normal. It is paired here with Helvetica and Courier, as is Times, for which it is an alternative.

#+LaTeX_HEADER: \usepackage[T1]{fontenc}
#+LaTeX_HEADER: \usepackage{mathpazo}
#+LaTeX_HEADER: \linespread{1.05}
#+LaTeX_HEADER: \usepackage[scaled]{helvet}
#+LaTeX_HEADER: \usepackage{courier}

The times option uses URW Nimbus Roman, a Times clone, for the serif font, URW Nimbus Sans, a Helvetica clone, for the sans-serif font, and URW Nimbus Mono, a Courier clone, for the typewriter font. This is a standard set of common typefaces typically used in scientific publications. All of the fonts should be included in a typical LaTeX distribution.

Times New Roman was designed by Stanley Morison for The Times of London during a redesign of the newspaper prompted, in part, by Morison's criticism of its typography in 1929. Helvetica was developed in 1957 by Max Miedinger. Helvetica looks better with Times if it is set slightly smaller than the serif font. Courier was designed by Howard Kettler in 1955 for use in IBM typewriters.

#+LaTeX_HEADER: \usepackage[T1]{fontenc}
#+LaTeX_HEADER: \usepackage{mathptmx}
#+LaTeX_HEADER: \usepackage[scaled=.90]{helvet}
#+LaTeX_HEADER: \usepackage{courier}

Utopia is a transitional serif font designed by Robert Slimbach for Adobe in 1989. It became free software in 2006. It is paired here with the Bera sans serif and monospaced fonts. Note that the Utopia font clashes with the amssymb package.

#+LaTeX_HEADER: \usepackage[T1]{fontenc}
#+LaTeX_HEADER: \usepackage[adobe-utopia]{mathdesign}
#+LaTeX_HEADER: \usepackage[scaled]{berasans}
#+LaTeX_HEADER: \usepackage[scaled]{beramono}

The biblatex package, which recently emerged from beta status, offers support for the full range of citation styles, including the numeric styles favored by scientists, the author-date styles used by social scientists, and the footnote styles popular in the humanities.

You'll need two additions to the LaTeX preamble, one to load biblatex and the other to specify the *.bib files that hold the BibTeX database. Loading biblatex without options defaults to a numeric citation style typical in the sciences.

#+LaTeX_HEADER: \usepackage{biblatex}
#+LaTeX_HEADER: \bibliography{my-bib,my-other-bib}

There are a number of citation and bibliography styles that ship with biblatex and there is a growing body of contributed styles. These can be selected by passing options to biblatex. The author/date style used in the social sciences can be selected:

#+LaTeX_HEADER: \usepackage[style=authordate]{biblatex}

Or a footnote style used in the humanities:

#+LaTeX_HEADER: \usepackage[style=verbose]{biblatex}

Biblatex supports the various citation commands implemented by natbib.

#+LaTeX_HEADER: \usepackage[natbib]{biblatex}

The list of cited works can be placed in the document by adding this line to the appropriate place in the Org-mode file:

\printbibliography

Thanks to work by Ali Tofigh and Joost Kremers, it is possible to manage citations using the ebib program for managing BibTeX databases. Using ebib with Org-mode was the idea of Ali Tofigh, who sent this message to the Org-mode list:

A while ago I asked on this list about connecting org-mode with ebib, which is a bibtex database manager for emacs. Thanks to Joost Kremers, there is now a solution.

I asked the developer of ebib, Joost Kremers, if he could write a function that would start ebib on a given bibtex entry. He kindly added this functionality to the 'ebib' function (which starts ebib in emacs) and it is now available in the ebib git repository (see http://ebib.sourceforge.net). If you are using ebib and would like to get org-mode to open bibtex entries do the following:

1. Install the latest development version of ebib.
2. make sure ebib-preload-bib-files is set properly so that your .bib file is loaded by ebib when ebib starts
3. add the following line to your .emacs:

(org-add-link-type "ebib" 'ebib)

Now you can insert ebib links in your documents like this: [ebib:Jones1998][some paper title]. Opening this link should now result in ebib starting, loading your default bibtex database, and highlighting the bibtex entry Jones1998. Alternatively, if you have already started ebib, then opening the link will get you to the bibtex entry in your opened ebib database.