Install TeX Live, TinyTeX or MiKTeX, and Typst

A full TeX Live installation needs 9,402 MB of disk space in the example screen of its own installation guide, while TinyTeX starts at 50 to 70 MB and Typst is one small program. All three end with the same check: a version line that says what you really installed.

Below you will compare the ways of getting a TeX system and pick one for your computer, install Typst and list the fonts it carries, check every version from the command line and from inside a document, fix a build that stops on a missing class, and set up an editor or an online alternative.

A TeX distribution brings the engines, the format and the packages

You never install LaTeX on its own: you install a distribution, which brings the engines, the LaTeX format, packages and fonts in one TeX treeTeX tree: The folders where a TeX distribution keeps its classes, packages, fonts and settings, such as texmf-dist. Engines find each file in it by name, and kpsewhich prints where a file is. and keeps them updated. Four ways are common:

• TeX Live, from the TeX Users Group, for Unix, macOS and Windows. You download its installer and run perl install-tl on Unix or install-tl-windows on Windows; on macOS the TeX Live guide recommends the native MacTeX installer, which is TeX Live with a few Mac-specific additions. The full installation needs several gigabytes, and you need no administrator rights, only write access to the folder it goes into. Many Linux distributions also offer TeX Live through their package managers, which may carry an older year, so check its version line.
• MiKTeX, for Windows, macOS and Linux. Its package manager installs missing components from the internet when a document first needs them, so the first installation stays small.
• TinyTeX, a small, portable distribution built from TeX Live. Its FAQ gives 50 to 70 MB or more, zipped, and it grows as you install packages with the usual TeX Live tools. Its installers are one-line scripts on Linux and macOS and a batch file on Windows, all on its website.
• An online editor such as Overleaf, which compiles on its servers, so nothing is installed on your computer.

Tectonic is a further option, a self-contained engine built on XeTeX and TeX Live that fetches support files as it needs them; whatever you install, read the LaTeX2e line of a log to see which LaTeX release you really got. Answer three questions about your computer, and the table says which distributions fit:

In short: TeX Live when disk space is no problem and you want everything ready, MiKTeX or TinyTeX when space or bandwidth is short, and an online editor when you may not install anything. Every LaTeX example in this track was recorded with TinyTeX 2026.10, which is TeX Live 2026.

Typst is one program, with its fonts inside

Installing Typst means putting one program on your computer. Its README lists brew install typst for macOS, winget install --id Typst.Typst for Windows, cargo install --locked typst-cli for anyone with Rust, and ready-made binaries on its releases page; Linux distributions package it too. Typst’s guide for LaTeX users calls the compiler a single, small binary that any user can run without root privileges.

The program carries its own fonts, so a document builds the same on any computer that has nothing else installed. typst fonts lists every font family Typst can use; this session ignores the computer’s own fonts, as every Typst example in this track does, so the list shows only the families built into the program:

from session import run

# The font families built into the Typst program: with system fonts ignored, these are all it can use.
run("""
typst fonts
""")

$ typst fonts
DejaVu Sans Mono
Libertinus Serif
New Computer Modern
New Computer Modern Math

Libertinus Serif is the default text font and New Computer Modern Math the maths font of the note in the first lesson, which is why its PDF embedded Libertinus. Without that setting, Typst also finds the fonts installed on your computer, so typst fonts on your machine lists more. Packages are different: they stay on Typst Universe until a document asks for one, and then Typst fetches it once and reuses its saved copy, so build once while online before you work on a train.

Check every version, from the command line and from inside the document

Each tool answers --version. This session asks the three engines for their first line, then latexmk, the TeX Live Manager tlmgrtlmgr: The TeX Live Manager: the command that installs, updates and lists the packages of a TeX Live or TinyTeX installation, as in tlmgr install exam or tlmgr update --all. and Typst, and finally asks the shell where it finds pdflatex and typst:

from session import run

# The version of every tool, asked from the command line: the three engines (first line only), latexmk, tlmgr and
# Typst, then where the shell finds pdflatex and typst.
run("""
pdflatex --version | head -1
lualatex --version | head -1
xelatex --version | head -1
latexmk --version
tlmgr --version
typst --version
which -a pdflatex typst
""")

$ pdflatex --version | head -1
pdfTeX 3.141592653-2.6-1.40.29 (TeX Live 2026)
$ lualatex --version | head -1
This is LuaHBTeX, Version 1.24.0 (TeX Live 2026)
$ xelatex --version | head -1
XeTeX 3.141592653-2.6-0.999998 (TeX Live 2026)
$ latexmk --version
Latexmk, John Collins. Version 4.88
$ tlmgr --version
tlmgr revision 79639
tlmgr using installation: …
TeX Live (https://tug.org/texlive) version 2026
$ typst --version
typst 0.15.1 (9dfd3a08)
$ which -a pdflatex typst
…/bin/universal-darwin/pdflatex
…/typst

Read them as the first lesson read the log: pdfTeX 1.40.29, LuaHBTeX 1.24.0 (LuaTeX built with the HarfBuzz library, the engine lualatex uses) and XeTeX 0.999998, each followed by (TeX Live 2026); latexmk 4.88; tlmgr reporting TeX Live version 2026; and typst 0.15.1 (9dfd3a08), the version followed by a short code that identifies the exact build. which -a lists every copy of a command on your PATH, in the order the shell tries them, and here it found one of each.

A document can report the same facts about the build that made it. \fmtversion is the LaTeX release, each engine defines its own banner, and Typst’s sys.version is the compiler’s version. The second session builds these two files and reads each PDF back:

\documentclass{article}
\begin{document}
\section*{Versions}
% \fmtversion is the release of the LaTeX format; each engine defines its own banner or version.
LaTeX format: \fmtversion\par
\ifdefined\pdftexbanner Engine: \pdftexbanner\par\fi
\ifdefined\luatexbanner Engine: \luatexbanner\par\fi
\ifdefined\XeTeXrevision Engine: XeTeX \the\XeTeXversion\XeTeXrevision\par\fi
\end{document}

= Versions
// sys.version is the version of the Typst compiler that built this file.
Typst #sys.version

from session import files, run

# The versions as the documents themselves see them, printed into the PDF, and the program that wrote each PDF.
files("versions/versions.tex", "versions/versions.typ")
run("""
pdflatex -interaction=nonstopmode -halt-on-error versions.tex
pdftotext versions.pdf -
lualatex -interaction=nonstopmode -halt-on-error -jobname=versions-lua versions.tex
pdftotext versions-lua.pdf -
typst compile versions.typ versions-typst.pdf
pdftotext versions-typst.pdf -
pdfinfo versions.pdf | grep Producer
pdfinfo versions-lua.pdf | grep Producer
pdfinfo versions-typst.pdf | grep Creator
""")

$ pdflatex -interaction=nonstopmode -halt-on-error versions.tex
This is pdfTeX, Version 3.141592653-2.6-1.40.29 (TeX Live 2026) (preloaded format=pdflatex)
 restricted \write18 enabled.
entering extended mode
(./versions.tex
LaTeX2e <2026-06-01>
L3 programming layer <2026-09-09>
(…/texmf-dist/tex/latex/base/article.cls
Document Class: article 2025/01/22 v1.4n Standard LaTeX document class
(…/texmf-dist/tex/latex/base/size10.clo)) (…/texmf-dist/tex/latex/l3kernel/l3backend-pdftex.def)
No file versions.aux.
[1{…/texmf-var/fonts/map/pdftex/updmap/pdftex.map}] (./versions.aux) )<…/texmf-dist/fonts/type1/public/amsfonts/cm/cmbx12.pfb><…/texmf-dist/fonts/type1/public/amsfonts/cm/cmr10.pfb>
Output written on versions.pdf (1 page, 27096 bytes).
Transcript written on versions.log.
$ pdftotext versions.pdf -
Versions
LaTeX format: 2026-06-01
Engine: This is pdfTeX, Version 3.141592653-2.6-1.40.29 (TeX Live 2026)
kpathsea version 6.4.2

1

$ lualatex -interaction=nonstopmode -halt-on-error -jobname=versions-lua versions.tex
This is LuaHBTeX, Version 1.24.0 (TeX Live 2026) 
 restricted system commands enabled.
(./versions.tex
LaTeX2e <2026-06-01>
L3 programming layer <2026-09-09>
 (…/texmf-dist/tex/latex/base/article.cls
Document Class: article 2025/01/22 v1.4n Standard LaTeX document class
(…/texmf-dist/tex/latex/base/size10.clo)) (…/texmf-dist/tex/latex/l3kernel/l3backend-luatex.def)
No file versions-lua.aux.
[1{…/texmf-var/fonts/map/pdftex/updmap/pdftex.map}] (./versions-lua.aux))
 411 words of node memory still in use:
   3 hlist, 1 vlist, 1 rule, 2 glue, 3 kern, 1 glyph, 4 attribute, 49 glue_spec, 4 attribute_list, 1 write nodes
   avail lists: 2:36,3:10,4:2,5:28,6:6,7:246,9:24,11:18
<…/texmf-dist/fonts/opentype/public/lm/lmroman10-regular.otf><…/texmf-dist/fonts/opentype/public/lm/lmroman12-bold.otf>
Output written on versions-lua.pdf (1 page, 7790 bytes).
Transcript written on versions-lua.log.
$ pdftotext versions-lua.pdf -
Versions
LaTeX format: 2026-06-01
Engine: This is LuaHBTeX, Version 1.24.0 (TeX Live 2026)

1

$ typst compile versions.typ versions-typst.pdf
$ pdftotext versions-typst.pdf -
Versions
Typst 0.15.1

$ pdfinfo versions.pdf | grep Producer
Producer:        pdfTeX-1.40.29
$ pdfinfo versions-lua.pdf | grep Producer
Producer:        LuaTeX-1.24.0
$ pdfinfo versions-typst.pdf | grep Creator
Creator:         Typst 0.15.1

The same versions.tex reported pdfTeX when pdflatex built it and LuaHBTeX when lualatex did, because the engine is chosen by the command, not by the file. The last three commands read the PDFs’ own records: a PDF names the program that wrote it, pdfTeX-1.40.29, LuaTeX-1.24.0 or Typst 0.15.1, so you can tell how any PDF was made without its source.

A missing class or package is one install away

Sooner or later a document asks for something your distribution does not have. This file uses the exam class, which teachers use for question papers and which this TinyTeX does not include. The session shows the error, then asks the tree what is installed, without touching the network:

\documentclass{exam}
\begin{document}
\begin{questions}
\question What does the command pdflatex start?
\end{questions}
\end{document}

from session import files, run

# A document whose class is not installed: the error, then how to find out what is installed, without the network.
files("quiz/quiz.tex")
run("""
!pdflatex -interaction=nonstopmode -halt-on-error -file-line-error quiz.tex
kpsewhich article.cls
!kpsewhich exam.cls
tlmgr info --only-installed --data name,installed,cat-version csquotes
tlmgr info --only-installed exam
""")

$ pdflatex -interaction=nonstopmode -halt-on-error -file-line-error quiz.tex
This is pdfTeX, Version 3.141592653-2.6-1.40.29 (TeX Live 2026) (preloaded format=pdflatex)
 restricted \write18 enabled.
entering extended mode
(./quiz.tex
LaTeX2e <2026-06-01>
L3 programming layer <2026-09-09>

! LaTeX Error: File `exam.cls' not found.

Type X to quit or <RETURN> to proceed,
or enter new name. (Default extension: cls)

Enter file name: 
./quiz.tex:2: Emergency stop.
<read *> 
         
l.2 \begin
          {document}^^M
./quiz.tex:2:  ==> Fatal error occurred, no output PDF file produced!
Transcript written on quiz.log.
[exit status 1]
$ kpsewhich article.cls
…/texmf-dist/tex/latex/base/article.cls
$ kpsewhich exam.cls
[exit status 1]
$ tlmgr info --only-installed --data name,installed,cat-version csquotes
csquotes,1,5.2p
$ tlmgr info --only-installed exam
package:     exam
installed:   No

The error names a file, exam.cls, not a package. kpsewhich looks a file up in the installed tree: it printed the path of article.cls, printed nothing for exam.cls and ended with exit status 1. tlmgr info --only-installed reads only the local package list, so it works offline: it gave 1 (installed) for csquotes and installed: No for exam. To fix the build in TeX Live or TinyTeX, find the package that holds the file with tlmgr search --global --file exam.cls and install it with tlmgr install exam; tlmgr also installs what that package depends on and updates the file database. Step through the fix, and where MiKTeX differs:

A file and its package often share a name, as exam.cls and exam do, but not always, which is why the search step exists. On Overleaf you choose a project’s TeX Live year in its settings instead, and new projects use the newest one.

An editor that builds on save, or one in the browser

Any plain-text editor can write LaTeX and Typst, and the TeX Live guide notes that something TeX-specific is not required. An editor that builds and shows the PDF as you type saves a lot of switching, though:

Online editors need no installation at all, but they decide the version for you. Overleaf’s documentation says new projects compile with the latest TeX Live on its servers while existing projects keep the year they were created with, so an old project can fail on a package a new project has. Check the year in the project’s settings before you blame the document.

Practise: check an installation from its output

A lab or a coaching class often checks many computers at once by asking students to paste their version lines. Build that check in two steps: read the versions out of the pasted text, then flag anything older than this track’s versions. The sample tests paste real version lines:

import re


def read_versions(text):
    """Return {"texlive": year or None, "latex": release or None, "typst": version or None} found in text."""
    found = {"texlive": None, "latex": None, "typst": None}
    # Replace this comment with one search per value.
    return found

from versions import read_versions

PDFLATEX = "pdfTeX 3.141592653-2.6-1.40.29 (TeX Live 2026)\nkpathsea version 6.4.2"
LOG = "This is LuaHBTeX, Version 1.24.0 (TeX Live 2026)\n(./versions.tex\nLaTeX2e <2026-06-01>\nL3 programming layer <2026-09-09>"
TYPST = "typst 0.15.1 (9dfd3a08)"


def test_all_three():
    """finds the year, the LaTeX release and the Typst version in one paste"""
    assert read_versions("\n".join([PDFLATEX, LOG, TYPST])) == {"texlive": 2026, "latex": "2026-06-01", "typst": "0.15.1"}


def test_only_a_log():
    """leaves Typst as None when the text has no Typst line"""
    assert read_versions(LOG) == {"texlive": 2026, "latex": "2026-06-01", "typst": None}


def test_nothing_found():
    """returns None for every value when the text names no tool"""
    assert read_versions("command not found: pdflatex") == {"texlive": None, "latex": None, "typst": None}


def test_older_installation():
    """reads older versions the same way"""
    text = "This is pdfTeX, Version 3.141592653-2.6-1.40.26 (TeX Live 2024)\nLaTeX2e <2024-11-01>\ntypst 0.13.1"
    assert read_versions(text) == {"texlive": 2024, "latex": "2024-11-01", "typst": "0.13.1"}


def test_typst_word_in_a_sentence():
    """does not take a sentence that only mentions typst as a version line"""
    assert read_versions("I will install typst later.")["typst"] is None

def version_problems(found, pins):
    """Return a message for each value of found that is missing or older than its pin: TeX Live, LaTeX, then Typst."""
    problems = []
    # Replace this comment with one check per value.
    return problems

from problems import version_problems

PINS = {"texlive": 2026, "latex": "2026-06-01", "typst": "0.15.1"}


def test_up_to_date():
    """reports nothing when every value equals its pin"""
    assert version_problems({"texlive": 2026, "latex": "2026-06-01", "typst": "0.15.1"}, PINS) == []


def test_older_tex_live_and_latex():
    """reports an older TeX Live and an older LaTeX, in that order"""
    found = {"texlive": 2025, "latex": "2025-11-01", "typst": "0.15.1"}
    assert version_problems(found, PINS) == ["TeX Live 2025 is older than 2026", "LaTeX 2025-11-01 is older than 2026-06-01"]


def test_missing_typst():
    """reports a value that was not found"""
    found = {"texlive": 2026, "latex": "2026-06-01", "typst": None}
    assert version_problems(found, PINS) == ["Typst: not found"]


def test_typst_versions_compare_by_number():
    """treats 0.9.0 as older than 0.15.1, and 0.16.0 as newer"""
    assert version_problems({"texlive": 2026, "latex": "2026-06-01", "typst": "0.9.0"}, PINS) == ["Typst 0.9.0 is older than 0.15.1"]
    assert version_problems({"texlive": 2026, "latex": "2026-06-01", "typst": "0.16.0"}, PINS) == []


def test_nothing_found():
    """reports all three when the paste named no tool"""
    found = {"texlive": None, "latex": None, "typst": None}
    assert version_problems(found, PINS) == ["TeX Live: not found", "LaTeX: not found", "Typst: not found"]

Then answer questions about distributions, versions and packages; the ones you get wrong come round again:

Interview questions

Warm-up (fresher to 2–5 years): how do TeX Live, MiKTeX and TinyTeX differ?

All three are TeX distributions: they install the engines, the LaTeX format, packages and fonts. TeX Live, from the TeX Users Group, is the comprehensive one, with a yearly release for Unix, macOS (as MacTeX) and Windows; a full installation takes several gigabytes, and tlmgr adds or updates packages. MiKTeX starts small and fetches a package over the internet at the moment a document asks for it. TinyTeX is a small distribution built from TeX Live, tens of megabytes at first, that grows as you install packages with tlmgr. Choose by disk space, by whether you work offline, and by what your template or team uses; check the result with pdflatex --version and the first line of a log.

Two harder questions follow, about a build that works on one computer and fails on another, and about an old installation that will not go away. Decide your first step before you open each one:

Key takeaways

• A distribution brings the engines, the LaTeX format, packages and fonts: TeX Live is complete and large, MiKTeX installs missing parts on demand, TinyTeX starts small and grows, and online editors install nothing.
• Typst is one program with its own fonts; it downloads packages on first use, so build once online before working offline.
• --version, the first lines of a log, \fmtversion, sys.version and a PDF’s producer all say which engine, release and TeX Live year really ran, and which -a shows which copy of a command runs first.
• A missing class or package stops the build with the name of a file: confirm it with kpsewhich, find its package and install it with tlmgr, or let MiKTeX fetch it.
• An editor that builds on save speeds up writing, and an online editor sets the TeX Live year per project.