Typst: A Possible LaTeX Replacement

It's great to see Typst getting more visibility. We migrated a real-world workload to it a couple of years back: generating and e-mailing 1.5M+ PDFs daily at my org, Zerodha.

Our previous pipeline was LaTeX-based (first pdflatex, then lualatex), but we were constantly fighting cryptic memory errors on large documents and huge Docker image sizes that slowed down boot times of our ephemeral workers.

Switching to Typst was a massive win for us. The single static binary resulted in tiny images and faster boot times. More importantly, the performance gains were huge. Overall compile times were ~3–4× faster than LaTeX. On really large documents (2000+ pages, mostly tables), Typst compiles in ~1 minute vs. ~18 minutes with lualatex.

Beyond performance, the better developer experience and good error messages was a nice bonus too.

We wrote a detailed post about the entire architecture - from the job orchestration with Nomad to the S3 optimizations and the Typst migration in particular. If you're curious, you can read it here: https://zerodha.tech/blog/1-5-million-pdfs-in-25-minutes

It's night and day.

I'm a PhD student currently writing my thesis in Typst. On paper this is an absurdly risky decision: it's a new technology without a huge user-base, it's not totally stable yet, etc. But I tried Typst and I had no choice. It was obviously the right thing to do, even though I'm going to have to make a pixel-perfect clone of my university's LaTeX template.

I've been using LaTeX for over ten years and I still wouldn't say that I "know" TeX in any meaningful way. I was not only productive but proficient in Typst in a day or two. If there isn't a package for something that I need (and, surprisingly often, there are packages for what I need, and excellent ones!), I find that I can just do it myself. Quickly. Things that never would have been possible for me with LaTeX are within easy reach. In ways I'd be happy to talk about if anyone's curious, it's been a huge enabler of my productivity as a researcher. I owe this tool so much.

Interestingly, I spend far, far less time yak-shaving in Typst than in TeX, since I can just Do The Thing That I Want. I'm actually focusing on writing instead of figuring out why package A conflicts with package B, and then how to install a different version of just a single package to override one of them, and then... [this sort of thing doesn't/can't happen in Typst; it's a real programming language with real modules] I could go on and on about the (relative) quality of the ergonomics and devex: fast compilation times, as others have said, but so much more than that. Try it out. Just try it out.

I should also say that it's not perfect. There are some funky design decisions for sure. There are some missing features, like including pdfs as images in your document (that one's on its way, I believe). Critically, the quality of the typesetting is maybe... 95% as good as TeX, which is perfect every time. Sometimes things don't kern quite right, and you have to adjust them by hand. It's a work in progress. I'm optimistic that it will achieve parity on that front.

These are some notes I wrote when I started out with typst when comparing with LaTeX:

1. It doesn't generate 5 bloody files when compiling.

2. Compiling is instant.

3. Diagnostics are way easier to understand (sort of like Rust compiler suggestion style).

4. List items can be either - item1 - item2, etc. or [item1], [item2]. The latter is way better because you can use anchoring to match on the braces (like "%" in vim), which means navigating long item entries is much easier.

5. In latex you have the \document{...} where you can't specify macros so they need to be at the top, in Typst you can specify the macros close to where you need them.

6. It's easier to version control and diff, especially if you use semantic line breaks.

7. Changing page layout, margins, spacing between things, etc., footers with page counters, etc. just seems way easier to do.

It's my duty bring up that plain TeX, the Knuth language in which the large macro collection LaTeX is written, isn't as verbose and opaque as LaTeX when people complain about that.

It has the opposite problem where you may have more control than you'd like. But it is in some sense very simple. e.g. this is a valid plain TeX document:

$$\aleph_0$$

\bye

Things don't have to begin{ and end{ etc.

There are simple collections of useful macros like [extended plain] kind of like lodash where the aim is to enhance the classic syntax by ` input eplain` at the top, not take over.

NB: I was so proud to write my thesis entirely in [extended plain], but when it was time to submit it to the library they basically said, "That's nice, nerd, but we have specific style files." and I had to rewrite it into LaTeX anyway!

[extended plain]: https://tug.org/eplain/

The crucial component for the success of this, in my opinion, is the acceptance of Typst templates in scientific journals and conferences. The adoption of something like this in universities relies entirely on the adoption by these publishers.

I see almost no support in the scientific community for Typst since everyone already has a LaTeX template for a thesis, paper, slides, etc. Researchers need to take the initiative and create a template that is accepted by first a chair, then propagate it in the university and try and get it popular enough so that it hopefully forces the creation of templates for conferences and journals.

This is an incredibly long, tedious, (and I am guessing ongoing) process, but one that is crucial for Typst to be a real contender with LaTeX

I have written a couple of lecture notes in LaTeX and I wrote my master's thesis (mathematics) in LaTeX as well[1]. It's actually a fine language if all you want to do is write and rely on other people's templates. But actually writing my own package or understand how the underlying systems work has always seemed like black magic where individual packages have to avoid stepping on each other's toes, or add specific workarounds. Maybe I'm wrong, but that's the impression I got.

It would be nice if Typst could be a LaTeX replacement that makes actually layout and designing the document approachable. I have only used it once for a quick one-off experiment and I did like the language, but as I have said above the language is not the problem if you just want to write text.

[1] That's not quite true, actually. I first wrote my thesis in reStructuredText and used Pandoc to generate the LaTeX and subsequent PDF. This allowed me to get started without having to write a lengthy preamble first. Then after I had more than half of it written down and had a good idea of what I wanted the document to look like did I clean up the generated LaTeX, adjust the formatting to my needs, redid the drawing in TikZ, and then kept writing LaTeX from there. I still think the language is not the problem, but it's easy to get hung up in the design phase before even the first chapter is written.

Typst is just wonderful, I hear maths majors now procrastinate on thesis writing by writing typst packages instead. Give it ten years and see how it developed.

Pros:

- Instant compile. It just sits there waiting, and once you save your .typ, boom, your .pdf is ready.

- Surprisingly often I find myself using it as markdown replacement, e.g., for random meeting notes. Syntax is as easy as markdown and without boilerplate it produces a nice pdf.

What's not to like?

- IMO debugging can be tricky with quite concise error messages. And it does not produce any pdf once there is a single syntax error, precluding one favourite latex debugging route.

- When using packages, one does encounter hickups, but no surprise here for long-time latex users.

I've ditched Pandoc + Latex for Typst for a book [1] that I'm writing. Typst is as easy to write a Markdown, and so much easier to program than Latex (though it is still a bit rough in some places). In Latex I would have to rely on a slew of packages to get anything done, and then work around their quirky interactions. With Typst it's feasible to just write it myself. It's also really fast and doesn't poo all over the file system. Strong recommend if you're producing technical documentation with PDF as your primary target.

[1]: https://github.com/scalawithcats/scala-with-cats/tree/featur...

Among alternative typesetting systems, there is also SILE, which supports two syntaxes (XML-based and TeX-style), supports scripting in lua, comes with freely available sort-of-specification (unlike (La)TeX or Typst, unless one counts program sources as specification). For formulae, it additionally allows direct MathML input. I have not used either Typst or SILE though, only looked into their documentation.

HTML with MathML may make a decent system as well; possibly with an XML source and XSLT for templating, which is apparently how OpenStax textbooks are composed (via CNXML, though that also has just a couple of rain frog pictures in its documentation repository -- seems to be a common pattern around typesetting systems).

Then there is troff with eqn(1), which looks simpler, but not sure if there is an actual specification for it around, either.

And then there are Texinfo, org-mode with LaTeX embedding, other TeX-adjacent options, perhaps Markdown with HTML and MathML embedding.

I have been planning to put out a quarterly Sanskrit newsletter for some time now, and was dreading having to deal with LaTeX. For basic stuff, LibreOffice PDF export works. But that is not a plain text workflow.

I then discovered typst and it is a breath of fresh air. Unicode/Dēvanāgarī support out-of-the-box, no installing gigabytes of packages, near-instant compilation.

My complements to those who got this done.

As a long time latex user, and one who is occasionally frustrated by usual things about latex, I have two qualms about attempting to switch to a new system. The first is I already have found solutions to many of my edge cases in latex. Will I have to do this all over again in something like Typst? It can't be so good as to not have any. And when I do encounter them, is the user base big enough to have already encountered it and solved it and wrote about it, so I can just look it up?

Looking at the example in the link, in principle it looks great. But one of the strengths of latex is that I can customize things. Like for the list example, I can have fine tune control over the indent on both sides, the list marker symbol, the space between the marker and the text, and so on and so on. Does typst have this level of control?

One advantage of LaTeX is that it's virtually impossible to generate markup by accident. This contrasts with other platforms which often decide that I'm trying to create a bulleted list, write something in boldface, etc. -- which hasn't always been the case.

It seems that part of the design philosophy of Typst is to make more assumptions about what the user is trying to do. For example, apparently if the user wants "dif" to appear in a math formula, typing "dif" would instead produce a differential -- although I presume there is some easy way to handle this.

Anyone who has used Typst -- did this potential disadvantage materialize in any way which was at all significant? Or did it turn out to be a nonissue?

God it's so much easier than LaTeX. I wrote so many things in LaTeX over the years, and writing (and debugging) switching to Typst felt like, well, like somebody had been fighting me every step of the way, and then finally stopped. I'm not going back, if I can help it.

But I will say I've mostly written relatively simple documents in it, so maybe that colors my experience.

Nobody seems to be taking about how great typst is to use programmatically. It’s absolutely trivial for example to build a Lambda function that parses some json input into a PDF. We’re using it to generate PDF invoices for our customers. We save massive amounts of compute because of how fast typst compiles into the PDF.

I've started using typst for small local documents that I would previously have written in markdown (or R-markdown). Typst offers programming features that are very helpful for small writing tasks that need more customization than markdown provides but that don't need the wildly expansive set of templates available in the latex world.

Like other academics, I plan to stick with latex for journal articles and books, unless publishers provide support for typst.

Markdown still has a place for files on github, because that means that web browsers will display formatted material, not just the raw code. A similar thing applies to code documentation, with many systems (R, Julia, etc) supporting various flavours of markdown.

I recommend typst to students for small tasks like assignments. It offers more typesetting power than markdown, it's a great replacement for msword, and it's easier to learn than latex.

Long story short, typst fills a niche. But it's not the be-all and end-all, at least in my (natural science) field.

Typst is great. I'm sure it's not a complete LaTeX replacement, given the dominance of TeX for many decades, but for simple documents it's a breath of fresh air.

Not having to deal with the insanity of the LaTeX distribution system alone is worth the switch. Everything is contained in a single binary. The language itself is much simpler to read and write, and seems just as flexible. LLMs do a decent job of generating it. Compilation takes less than a second, making it so much faster to iterate.

Many thanks to the authors and contributors, and please don't ruin it. :)

Almost all my computer science students are using Typst on my recommendation to write up their programming projects, vs most using Microsoft Word last year. Specifically, writing in VSCode with the Tinymist Typist extension. All going very well so far and no complaints.

Typst is fantastic and I recommend to dive into it to see how much value it offers. To me personally, the biggest strength is the ergonomics of both the tooling and the language, and how ergonomics persist even between documents of various complexity. Writing a paper in LaTeX is nice, but making something like a CV takes some patience. Meanwhile, in typst it was quick to get started and go all the way to building resumes, character sheets, and I know of at least one occurrence of implementing symbolic math in typst language. It's not without quirks, but still, very solid alternative

I must say I really like the more straightforward syntax, semantics, and distribution model of Typst. LaTeX is akin to programming with the C preprocessor, it's both ridiculous and amazing what people have done with it but it gets quickly intractable. However, I really do enjoy the quality of graphics, diagrammatic, and scientific output from LaTeX, even if typing them is a pain (LLMs are a huge help here).

So asking the community here: what does Typst offer in place of PGF/TikZ[1], PGFPlots[2], Asymptote[3], chemfig[4], siunitx[5], physics2[6], and how does it work with existing bibliography providers? I use biber[7] with the Zotero Connector and Better BibTeX[8] so any paper I visit on the web is essentially instantly available to cite with one click on LaTeX.

A good test for Typst ought to be reproducing most of these typographic and diagrammatic exemplars: https://tex.stackexchange.com/questions/1319/

[1]: https://tikz.dev/

[2]: https://tikz.dev/pgfplots/

[3]: https://asymptote.sourceforge.io/

[4]: https://mirrors.ctan.org/macros/generic/chemfig/chemfig-en.p...

[5]: https://mirrors.ctan.org/macros/latex/contrib/siunitx/siunit...

[6]: https://mirrors.ctan.org/macros/latex/contrib/physics2/physi...

[7]: https://mirrors.ctan.org/biblio/biber/base/documentation/bib...

[8]: https://retorque.re/zotero-better-bibtex/

Assuming it's at all desirable, it's an interesting and recurring problem of how to dislodge existing sub-optimal (sometimes even harmful) standards and notations.

Almost nobody wants to learn something new when they already know something similar.

Creates a heck of a momentum effect, not just from the practitioners resisting the change, but also available resources and so on.

Fun fact: TeX was written closer in time to Alan Turing's famous paper introducing the Turing machine, than to present day.

The absolute staying power of TeX has been incredible.

The programming parts are very tempting, but I find the philosophy of the math mode input simplification to be questionable. E.g. automatically generating fractions from "/", or removing parentheses depending on whether they are redundant with other grouping. Those are all choices that I want explicit control over, and the most readable choice depends strongly on the details of the expressions. After some digging it's clear that all of that can be overridden without too much effort, but it still seems like a poor default for my use cases.

Tex doesn’t attract software developers. The programming language has remained really old fashioned and clunky. The error system is particularly bad. I use it on a daily basis, and it doesn’t feel nice, far from the experience with Python or Rust.

The output is superb though, which is why everyone in academia keep using it. It’s just the tooling that is poor.

I think it needs to be modernized.

Like other commentators, I have worked with LaTeX for a long time (> 10 years) and have to say that it very much shows its age.

For once, the compilation time is terrible - it can take several minutes to compile a typical document. I recently tried to create a poster for a conference - a single A0 page - and even this took more than a minute to compile. Because positioning in images and figures in LaTeX is not obvious, this made iteration extremely slow.

Additionally, by forgetting a single bracket, one can easily encounter cryptic error messages relating to boxes. In the past, I have also worked on LaTeXML (the LaTeX-to-HTML "converter" amongst other things being used to power ar5iv [1]). Even though this exposed me to some of (La)TeX's internals, it is still extremely difficult trying to decipher error messages.

Typst, on the other hand, is much faster when compiling and provides much clearer error messages.

For this reason, I also decided to write my 130-something PhD dissertation in Typst [2]. My university only provided a LaTeX and a Word template, but I ended up copying that in Typst extremely quickly. My thesis compiles in about 7 seconds on my laptop - I cannot imagine how long it would take had I chosen LaTeX instead. Not only that, when I showed an initial draft of my dissertation to my supervisor - also a decades-long LaTeX user - he could not tell that I wasn't using LaTeX.

I only really encountered one problem with Typst so far - citation styles. In particular, the alphanumeric style preferred by my field produced duplicate citation keys, making the output unreadable in printed form. But given all the other benefits Typst offered, I ended up switching to IEEE's citation style instead.

I am also hoping that Typst improves its HTML export - it is very barebones at the moment - but that seems to be in the works [3].

[1] https://news.ycombinator.com/item?id=36947004

[2] https://doi.org/10.25593/open-fau-1825

[3] https://github.com/typst/typst/issues/5512

I've written a system that consists of a JS front-end/backend, which then feeds a json object to a typst template to generate PDF reports with hundreds of pages, multipage tables, references to bibliography within the json strings, and translated to multiple languages. It works extremely well, and it's very intuitive to work with it.

For example, for the translations, I just made an object with every piece of text in a hierarchical structure, with the leaf being an object with keys for every language and the texts as values. Then I have a function called t() that is created after we already know the language for this report that just extracts the current language string when given an object like #t(content.section1.subsection.header.title) in the main report template (which imports this translations object from another file)

For bibliography references, I just have a regex for __REF\d+ that will replace all those references with real bibtex references.

Long term Latex user here, I've been working on generating automatic invoices in Typst for a year now.

On the plus side:

* Getting structured data into typst is sooo much simpler than into latex. For latex, you basically have to render a template, and have to know all the crazy escaping rules for special characters. In typst, you can just read a json file, and do the rendering in typst.

* Super fast. Love it.

* Mostly very easy to use.

Minus:

* Our invoices are structured as multi-page tables, and widow and orphan prevention in a multi-page table seems to be non-existent. The workarounds we tried were too disruptive (lead to text overlapping other text, for example).

* There's a bug in the Python wrapper that means we sometimes don't get a proper error message when there happens to be an error, then we have to recreate the scenario on the command line to find out what the error was.

* Docs could be better (but are mostly OK)

Overall I'm very happy with typst for this use case.

I had originally dismissed Typst, since at first glance it seemed like some closed online-only tool. But actually there's solutions such as Typstify[1] which works offline, haven't tried it yet but seemed promising.

[1]: https://typstify.com/

From the article: "Typst... can, for example, easily split large tables across page breaks, something that LaTeX struggles with even with specialized packages." That would be nice. I remember when I first started working with LaTeX that I was surprised that I needed to decide ahead of time whether a table would fit on one page or not. If Typst can make that decision on its own, that's a step forward.

One thing I have not seen mentioned as yet: cross-references. In LaTeX, I can create cross references to anything: page number, table or figure number, even an item in a numbered list. Does Typst have that capability? I saw a package for cross-referencing numbered boxes (it's called statementsp), but it wasn't clear how you xref other things. (Not saying it's not there, it just doesn't jump out at me.)

I also recently published a book written with Typst. It was absolutely a joy to work with, especially because the book was a collection of student essays. I converted them from docx to Typst and then getting all the figures and tables setup nicely and uniformly was easy. The PDF generation was perfect but converting to docx/epub I ran into a few bugs in pandoc. I reported them and a few were fixed and a few are still open. Overall, a very positive experience.

Book: https://thelabofthought.co/shop/p/nbmi3

Bugs: https://github.com/jgm/pandoc/issues?q=is%3Aissue%20state%3A...

I'm becoming acutely aware of the first-mover problem in open source software: Nobody truly knows how the software is going to be used in half a century. And once that time is past, the accumulated tech debt of the first-generation tool should probably just be thrown out entirely, for a new second-generation tool that easily does what people have shown they actually want do with it.

I've been using Typst for work documentation and hobby authorship. It is unreal how powerful it is out of the box, with no plugins. It's a Turing-complete programming language where you can switch between a code context and a document context with a simple change of brackets. Everything you WISH Latex did out of the box, it does. Highly recommend the VSCode plugin with live PDF generation and automatic scrolling.

I've tried pushing Typst on my academic friends. One of them listened and eventually wrote his entire PhD thesis with it. He didn't seem to regret it.

I love Typst! Currently rewriting my CV in Typst and it has been an excellent experience. One small hindrance is the inability to have multiple bibliographies.

In the past I have also used it to generates quotes (in terms of finances, invoice etc.). It was neat because all of the logic for adding up the subtotal was written in the language (and was fairly easy to understand). I can imagine trying to do that logic in LaTeX…

I had been using LaTeX for 25 years. I gave it a try recently to write a technical paper and I was blown away. I saved so much time. The immediate feedback and the advanced features were impressive. I had to include a budget proposal in one of the chapters and I was able to create a quick script that read a csv file with the different concepts and costs. I would modify the contents of the csv file and the document would update right away. I didn't have to recompile the document as I used to do with LaTeX... the results were there, right away, beautifully formatted. I am very impressed and will definitely consider doing more work with Typst.

Typst seems like an improvement in many respects, but I definitely prefer LaTeX when working with detailed math equations (most of my use of LaTeX). I think there is a lot of inertia for anything to replace LaTeX for mathematical research.

Any experience with using Typst to produce "pixel perfect" reproductions of existing documents? At work we have a series of contracts that are updated every year, with fillable blanks that we fill in with provided data. We currently use latex for them and have a contractor is very good at making them look basically exactly like the original contracts, but at some point she's going to retire, probably sooner rather than later.

Probably our best solution is to decide that we don't care about nearly pixel perfect reproduction of the contract, which probably makes a switch to typst a lot easier.

I just found out https://typst.app/play/ - this is an absolute gamechanger. Tried it for a minute, but already loving it.

Typst fixes pretty much every problem LaTeX has.

It replaces the macro language of LaTeX with a python/rust like language, which couldn't be easier to write.

The markup language has a markdown like syntax which makes writing simple things simple. And allows for complex, but easy to comprehend operations when useful.

It has good tooling, with helpful error messages and is not arbitrarily limited on memory or font support. (I know some LaTeX engines do not have that problem anymore, but even the Idea of competing engines with different feature sets is somewhat ridiculous)

I have used it a lot, for many different things.

With the wisdom from a TU Delft graduate student, I switched from Word to LaTeX in 2007, having never known or used it ever before, and never looked back for the next seventeen years. Using it within the corp. environ. (Shell) became progressively harder as time went by due to the need to install such a large installation (under Cygwin, which itself got on the list of not-allowed, and had to resort to `setup-x86_64.exe --no-admin` for nearly all my subsequent time there).

While I appreciate LaTeX structure, and the resulting end product (Knuth is God), it is as you know highly verbose in markup, thereby making the content somewhat unclean, and not easily readable like plain text (my yardstick on content readability and re-usability). I wrote multiple plug-ins for the text editors of my choice Sublime Text, and Vim to produce snippets for writing ease.

- https://github.com/ckunte/latex-snippets-st

- https://github.com/ckunte/latex-snippets-vim

Switched to Typst cautiously in 2023, and have never since looked back. If LaTeX was the gold standard for the 20th century, I think Typst is on track to become that for the 21st.

I wrote a little note about writing a template for Typst to remind myself how-to, and for anyone I'm working with:

- https://ckunte.net/2025/template

The LaTeX community is astonishingly good at gatekeeping. I can't think of another field where the adoption of a clearly superior modern alternative has been so slow. For some reason, they seem to take pride in clinging to a 50-year-old typesetting system—with its bloated footprint, sluggish compilation, incomprehensible error messages, and a baroque syntax that nobody truly understands. People have simply learned just enough to make it work, and now they treat that fragile familiarity as a virtue.

TBH, I'm sick about LaTeX: - compilation is heavy - it's not friendly for writing (far from the dominant markup languages) - poor support to HTML / Epub / mobile outputs - output (PDF) not friendly for parsing / digesting. - tonnes of templates, lot of mess.

We should just use human friendly markups like MyST Markdown [1] or Org Mode [2].

Unfortunately, whitepapers are predominantly written in LaTeX. Thankfully, arXiv recently made a move to parse and render those documents in the web format. It's a hard job. But this is the wrong way around: instead of keep composing documents in LaTeX (which is not human friendly), and then doing the hard job with tooling, we should start with human first approach and have win-win!

We are living in the world where web content is the primary content and friendly for desktop, mobile devices and readers and tools (select, copy, edit...). It's easy to package any web content into epub and ship it in a single file. Printing is also easy. Only cons: precise typesetting is not harder. But this is less of the problem. I would prefer a content that is friendly to read and is responsive, than a precise typesetting.

[1] https://mystmd.org/ [2] https://orgmode.org/manual/Summary.html [3] https://info.arxiv.org/about/accessible_HTML.html