📖 项目介绍

>

>

>

>

>

Typst is a new markup-based typesetting system that is designed to be as powerful
as LaTeX while being much easier to learn and use. Typst has:

- Built-in markup for the most common formatting tasks
- Flexible functions for everything else
- A tightly integrated scripting system
- Math typesetting, bibliography management, and more
- Fast compile times thanks to incremental compilation
- Friendly error messages in case something goes wrong

This repository contains the Typst compiler and its CLI, which is everything you
need to compile Typst documents locally. For the best writing experience,
consider signing up to our [collaborative online editor][app] for free.

Example

Let's dissect what's going on:

- We use _set rules_ to configure element properties like the size of pages or
the numbering of headings. By setting the page height to auto, it scales to
fit the content. Set rules accommodate the most common configurations. If you
need full control, you can also use [show rules][show] to completely redefine
the appearance of an element.

- We insert a heading with the = Heading syntax. One equals sign creates a top
level heading, two create a subheading and so on. Typst has more lightweight
markup like this; see the [syntax] reference for a full list.

- [Mathematical equations][math] are enclosed in dollar signs. By adding extra
spaces around the contents of an equation, we can put it into a separate block.
Multi-letter identifiers are interpreted as Typst definitions and functions
unless put into quotes. This way, we don't need backslashes for things like
floor and sqrt. And phi.alt applies the alt modifier to the phi to
select a particular symbol variant.

- Now, we get to some [scripting]. To input code into a Typst document, we can
write a hash followed by an expression. We define two variables and a
recursive function to compute the n-th fibonacci number. Then, we display the
results in a center-aligned table. The table function takes its cells
row-by-row. Therefore, we first pass the formulas $F_1$ to $F_8$ and then
the computed fibonacci numbers. We apply the spreading operator (..) to both
because they are arrays and we want to pass the arrays' items as individual
arguments.

typst
  #set page(width: 10cm, height: auto)
  #set heading(numbering: "1.")
  = Fibonacci sequence
  The Fibonacci sequence is defined through the
  recurrence relation $F_n = F_(n-1) + F_(n-2)$.
  It can also be expressed in _closed form:_
  $ F_n = round(1 / sqrt(5) phi.alt^n), quad
    phi.alt = (1 + sqrt(5)) / 2 $
  #let count = 8
  #let nums = range(1, count + 1)
  #let fib(n) = (
    if n <= 2 { 1 }
    else { fib(n - 1) + fib(n - 2) }
  )
  The first #count numbers of the sequence are:
  #align(center, table(
    columns: count,
    ..nums.map(n => $F_#n$),
    ..nums.map(n => str(fib(n))),
  ))
  

Installation

- You can get sources and pre-built binaries for the latest release of Typst
from the [releases page][releases]. Download the archive for your platform and
place it in a directory that is in your PATH. To stay up to date with future
releases, you can simply run typst update.

- You can install Typst through different package managers. Note that the
versions in the package managers might lag behind the latest release.
- Linux:
- View [Typst on Repology][repology]
- View [Typst's Snap][snap]
- macOS: brew install typst
- Windows: winget install --id Typst.Typst

- If you have a [Rust][rust] toolchain installed, you can install
- the latest released Typst version with
cargo install --locked typst-cli
- a development version with
cargo install --git https://github.com/typst/typst --locked typst-cli

- Nix users can
- use the typst package with nix-shell -p typst
- build and run the Typst flake with
nix run github:typst/typst-flake -- --version.

- Docker users can run a prebuilt image with
docker run ghcr.io/typst/typst:latest --help.

Usage

sh
Creates file.pdf in working directory.

typst compile file.typ
Creates a PDF file at the desired path.

typst compile path/to/source.typ path/to/output.pdf

You can also watch source files and automatically recompile on changes. This is
faster than compiling from scratch each time because Typst has incremental
compilation.

sh
Watches source files and recompiles on changes.

typst watch file.typ

Typst further allows you to add custom font paths for your project and list all
of the fonts it discovered:

sh
Adds additional directories to search for fonts.

typst compile --font-path path/to/fonts file.typ
Lists all of the discovered fonts in the system and the given directory.

typst fonts --font-path path/to/fonts
Or via environment variable (Linux syntax).

TYPST_FONT_PATHS=path/to/fonts typst fonts

For other CLI subcommands and options, see below:

sh
Prints available subcommands and options.

typst help
Prints detailed usage of a subcommand.

typst help watch

If you prefer an integrated IDE-like experience with autocompletion and instant
preview, you can also check out our [free web app][app]. Alternatively, there is
a community-created language server called
Tinymist which is integrated into
various editor extensions.

Community

[Typst Universe][universe] is where the community shares templates and packages.
If you want to share your own creations, you can submit them to our
[package repository][packages].

If you had a bad experience in our community, please [reach out to us][contact].

Contributing

To build Typst yourself, first ensure that you have the
[latest stable Rust][rust] installed. Then, clone this repository and build the
CLI with the following commands:

sh
git clone https://github.com/typst/typst
cd typst
cargo build --release

The optimized binary will be stored in target/release/.

Another good way to contribute is by [sharing packages][packages] with the
community.

Pronunciation and Spelling

Design Principles

- Simplicity through Consistency:
If you know how to do one thing in Typst, you should be able to transfer that
knowledge to other things. If there are multiple ways to do the same thing,
one of them should be at a different level of abstraction than the other. E.g.
it's okay that = Introduction and #heading[Introduction] do the same thing
because the former is just syntax sugar for the latter.

- Power through Composability:
There are two ways to make something flexible: Have a knob for everything or
have a few knobs that you can combine in many ways. Typst is designed with the
second way in mind. We provide systems that you can compose in ways we've
never even thought of. TeX is also in the second category, but it's a bit
low-level and therefore people use LaTeX instead. But there, we don't really
have that much composability. Instead, there's a package for everything
(\usepackage{knob}).

- Performance through Incrementality:
All Typst language features must accommodate for incremental compilation.
Luckily we have [comemo], a system for incremental compilation which does
most of the hard work in the background.

Acknowledgements

We'd like to thank everyone who is supporting Typst's development, be it via
[GitHub sponsors] or elsewhere. In particular, special thanks[^1] go to:

- Posit for financing a full-time
compiler engineer
- NLnet for supporting work on Typst via multiple grants
through the NGI Zero Core fund:
- Work on HTML export
- Work on PDF accessibility
- Science & Startups for having financed
Typst development from January through June 2023 via the Berlin Startup
Scholarship
- Zerodha for their
generous one-time sponsorship

[^1]: This list only includes contributions for our open-source work that exceed
or are expected to exceed €10K.

[docs]: https://typst.app/docs/
[app]: https://typst.app/
[discord]: https://discord.gg/2uDybryKPe
[forum]: https://forum.typst.app/
[universe]: https://typst.app/universe/
[tutorial]: https://typst.app/docs/tutorial/
[show]: https://typst.app/docs/reference/styling/#show-rules
[math]: https://typst.app/docs/reference/math/
[syntax]: https://typst.app/docs/reference/syntax/
[scripting]: https://typst.app/docs/reference/scripting/
[rust]: https://rustup.rs/
[releases]: https://github.com/typst/typst/releases/
[repology]: https://repology.org/project/typst/versions
[contact]: https://typst.app/contact
[architecture]: https://github.com/typst/typst/blob/main/docs/dev/architecture.md
[contributing]: https://github.com/typst/typst/blob/main/CONTRIBUTING.md
[packages]: https://github.com/typst/packages/
[comemo]: https://github.com/typst/comemo/
[snap]: https://snapcraft.io/typst
[GitHub sponsors]: https://github.com/sponsors/typst/