Typst 0.14 | Hacker News Reader

Typst 0.14

typst.app

653 pointsoptionalsquid170 comments

There's usually some confusion about this, so to clarify in advance:

- The Typst online editor is proprietary: https://typst.app

- The Typst compiler/CLI is open source: https://github.com/typst/typst

I hear that the online editor is quite good, but personally I've only ever used the CLI.

I originally picked up Typst as yet another replacement for PowerPoint (replacing my use of Marp), but have since used it for a poster and some minor text documents. And I've been very happy the results. I know that a lot of people love using LaTeX for that kind of thing, and with good reasons, but I always forgot most of the details between my (occasional) use of LaTeX, while I've found Typst to be very easy to return to

TinyMist is a great alternative to the online editor for local development in VS Code / Cursor https://myriad-dreamin.github.io/tinymist/

Yeah, that's also what I've been using, and yes it is very good. Thank you for bringing it up

This is a great example of the open core model done right. Have a fully-featured F/LOSS product, and build value-add commercial products and services on top of it.

I've also only used the CLI tool, and didn't miss any features from it. The commercial product was never pushed or promoted to me. I personally have no need for it, and I'm only vaguely aware that it exists. But I'm sure that people who do need the friendlier UI/UX and more advanced features would be willing to pay for it, so I'm glad that the team has a stable source of income that enables them to continue maintaining the project in the long-term.

Looking at the pricing page now... Wow, the plans are quite generous and affordable. Way to go!

It’s a great example how many open source projects start … until they change.

I mean, we can be cynical about it, or we can acknowledge the fact that running a sustainable business around OSS is entrepreneurship on hard mode.

Yes, many companies start with good intentions which then change at some point, but there have also been companies that have managed to successfully balance both sides.

Grafana comes to mind, as well as ClickHouse, and TimescaleDB. I'm not as familiar with the latter two, but Grafana is certainly a good example. You can probably find some blemishes even on their record, but overall, I would say they have been excellent stewards of OSS. Especially considering the large amount of products they maintain.

So far, Typst seem to be on the right track as well, which is worthy of praise.

I don't really need the web version, but I pay for a yearly subscription to support development of Typst.

I do find the web version handy to share Typst examples and on occasion work on a document while syncing with private Github repository.

I used LaTeX for decades and had convinced myself nothing could ever replace it. Just this month, however, I converted to Typst for a large project. Absolutely no regrets: undying respect to the great Knuth, but the experience with Typst is already simply better on almost every axis. I use TinyMist with vscode and the development experience is terrific. I was modifying templates within a day of picking it up, which—-skill issue undoubtedly—-always gave me nightmares in LaTeX.

Speaking of skill, learning a new language is always daunting, but I found that LLMs do a pretty good job of generating Typst code. I relied on that a lot for generating snippets of code, and learning about the language, which would've taken me more time otherwise. Although the Typst docs are pretty good, regardless.

Yep this is how I started my Typst journey. I was intimidated by Typst at first and wanted to do some mildly complicated documents that really isn't covered by the tutorial, so I had ChatGPT generate elements of the document I need. Now I'm a more self-sufficient being able to generate functions and use more complicated features of Typst and better exercise use of the docs.

What LLMs? In my experience they do a terrible job with Typst. Very frequently ChatGPT and Gemini will produce code that doesnt work. Im not sure if it's using an older syntax or just hallucinating. Additionally, it's rarely able to fix it after I provide the error and even copy-past docs.

Maybe I was just unlucky or you had better luck with another model. But I was very surprised to here this because Typst is my chief example for a language that LLMs are bad at.

This was a few months ago, but mainly Claude Sonnet 3.5 IIRC.

You can't escape hallucinations, of course, but they can be mitigated somewhat. Don't ask it to generate a bunch of code at once. Feed it a snippet of code, and tell it precisely what you want it to do. These are general LLM rules applicable to any language and project, and I've had success with them with Typst. I also used it just to get explanations, or general ideas about how to do something, and then figure out the actual syntax and working code myself. It's strange that you haven't had luck with pasting docs. That has usually worked well for me.

I also think that LLMs don't struggle as much with Typst because the language is relatively simple, and there is little bad and outdated content about it online, so they weren't trained on it. I assume that the API probably hasn't changed as much either and there haven't been many compatibility issues, so it's not as important which version the LLM was trained on.

It failed miserably with very simple requests. It was wrong but it wasn't clear if it was hallucinating or simply using old syntax.

I did not try Claude though. Perhaps that performs better.

edit: I just prompted chatGPT with this and pasted the result into the Typst editor. 20 compile errors.

>Make a Typst doc with two columns per page and US page dimensions

Same prompt but for Latex and pasted in overleaf. No problems.

I just tried the same prompt in chatGPT and it gave 10 errors. Mostly they were because it was using `#` as a comment character, which suggests that it has not been given very much typst code to examine.

I just tried the same prompt with Claude Sonnet 4.5. (Using a generic "programming" system prompt. It's a bit long, so I won't paste it here, but I can share it if you're interested.)

It generated this:

------------------

  #set page(
    paper: "us-letter",
    columns: 2,
  )

  #lorem(100)

This creates a Typst document with: - US Letter page size (8.5" × 11") - 2-column layout - Sample text (replace `#lorem(100)` with your actual content)

------------------

Which compiled to PDF without errors using Typst CLI v0.13.1. The two column layout is not visible with `lorem(100)`, but `lorem(1000)` shows it clearly.

I'm surprised you got 20 compile errors for what should be a very simple document.

So I would call this a success. I doubt Claude is that much better than ChatGPT (GPT-5?).

I'm not saying that this invalidates your experience, but I would suggest experimenting with different strategies and LLMs. Try some prompt variations, feeding it more (or less) context, higher-quality context, documentation, etc. These tools are highly sensitive and unreliable, but can be coerced into producing helpful results with some care and patience.

EDIT: I was curious, so I tried the same with ChatGPT-4o using OpenRouter's default system prompt. It produced this:

------------------

  // Set US letter page size
  #set page(width: 8.5in, height: 11in)
  
  // Create two-column layout using grid
  #layout(grid: (
    columns: 2,
    gutter: 0.5in, // space between columns
  ))
  
  // Example content
  = My Two-Column Document
  
  This is some text in the first paragraph. It will flow into two columns across the page.
  
  == Section One
  
  Here is more content that will automatically be distributed between the two columns. Typst handles the balancing and splitting of content across columns for you.
  
  == Section Two
  
  You can continue to add as much content as you'd like, and it will remain in the two-column format automatically.

------------------

This failed to compile because of a single error with `#layout`. Still, Typst errors are clear, and I could've probably fixed it easily myself by referencing the documentation.

Then I tried the same model with my custom generic programming system prompt, and it produced this:

------------------

  #set page(
    width: 8.5in,
    height: 11in,
    margin: 1in,
    columns: 2,
    column-gap: 0.5in,
  )
  
  = Title
  
  Here is some example text in the first paragraph. It will flow into two columns automatically.
  
  == Section
  
  More text continues here, and Typst will manage the column layout accordingly.

------------------

Which is better, but still failed to compile because `column-gap` is not a valid argument. Simply removing it compiled without errors.

I still would've consulted the official documentation to determine whether this is idiomatic code or not, but these are not terrible results. As with all LLMs, you'll get the most out of them if you use them as assistants, rather than vibe coding tools.

Here is my experience.

Claude did generated a rather good template for what I needed. It did not compile at first but I copy-pasted the errors and it fixed them.

Not all was good, though. It used literal bullets instead of `-` required for lists, but on whole the experience was positive.

It had taken me less time to fix the template than it would been taken to write it from scratch.

Something which Claude was good at. I throw him a crude ASCII "art" representation of what I want and get the right Typst code back.

> but I found that LLMs do a pretty good job of generating Typst code.

Interestingly, I've had the opposite experience. ChatGPT and Claude repeatedly gave me errors, apologized profusely, and then said, "ah, I had the wrong keyword. It's actually <blahblah>"--and that would simply give me another error and a subsequent apology.

At least Gemini had the good taste of telling me that it didn't know how to do what I wanted with typst.

It's certainly possible that I was trying to do something a little too unusual (who knows), but I chalked it up to the LLMs not having a large enough corpus of training text.

On the bright side, the typst documentation is quite good and it was just a matter of adjusting example code that got me on track.

Well, that just goes to show that these tools are wildly unpredictable. I've had bad experiences generating Go, whereas I've read many experiences of the opposite.

> I chalked it up to the LLMs not having a large enough corpus of training text.

I'm inclined to believe the opposite, actually. It's not so much about the size of the training data, but the quality of it. Garbage in, garbage out. Typst is still very young, and there's not much bad code in the wild.

And the language itself plays a large role. A simple language with less esoteric syntax and features should be easier to train on and generate than something more complex. This is why I think LLMs are notoriously bad at generating Rust code. There's plenty of it to train on, but Rust is a deep pit of complexity and unusual syntax. Though it helps when the language is strict and statically typed, so that the compiler can catch issues early. I would dread relying on generated Python code, despite of how popular and simple it is on the surface.

100% agree. With tex it feels like when you use a package or template, you're stuck with every choice it made because changing it yourself is just too daunting. With Typst I feel confident that I can go in and muck with whatever I don't like. It's a really refreshing feeling.

Although this is objectively an advantage, it means I've spent just as much of my time mucking about with customisation in Typst, as I have in LaTeX :p

famously knuth was trying to (and pretty much did) solve digital typesetting not create a nice piece of hci so this is all as it should be or at least as might be expected

Staying in his lane, living his best life—dropping incredible things to humanity ever now and then. I had to check since I hadn’t thought about it for… a decade apparently, but looks like TAOCP 4B came out a couple years ago.

The two applications were developed on quite different computers and with quite different toolchains.

Interestingly, Knuth has stated that his development of Literate Programming:

http://literateprogramming.com/

was more important than TeX --- fortunately, his publishing _TeX: The Program_:

https://www.goodreads.com/book/show/499934.Computers_Typeset...

has been very helpful to folks developing successors and add-ons and new versions, facilitating the creation of web2c and change files which made tools such as pdftex and omega and xetex and luatex possible).

The first link for Literate Programming gives me a certificate warning and an off putting site for some likely malware or something? This appears to be a working link: https://www.cs.tufts.edu/~nr/cs257/archive/literate-programm...

The online editor is extremely useful for quick projects with other people where real-time editing works better than git, and where people don't want to download tools.

Speaking of core product and online editor: Over the decades many of the products I worked on developed some form of reporting feature.

Not alway, but often they required PDF output. Not always, but often they ended up being LaTeX based, with all the nice and some of the ugly consequences. Especially the security story was never great.

Does anyone know how hard it would be to integrate the Typst renderer into an existing Rust product?

I embed the typst binary in a go binary deployed to cloud run. I use this to generate pdfs on the fly.

I need to generate a 2 page invoice and i can generate it under 100 ms. IIRC, it's easier to integrate with rust. Since the pdf rendered is written in rust

Not particularly difficult. The main Typst crate should have you covered. I've seen quite a lot of projects that do it already.

I LOVE Marp! Why do you like Typst more than Marp for presentations?

I much preferred Marp to PowerPoint, but there were several parts of it I wasn't fond of:

- Using CSS for formatting resulted in a lot of one-off rules, and was a lot noisier and less readable than the equivalent in Typst.

- The use of CSS for formatting also meant that the Marp compiler couldn't catch most of my silly mistakes. With Typst the compiler will catch those mistakes.

- Using a plugin to selectively highlight lines required writing a custom "engine" in JS, which was a pain to get working. Using a package in Typst is extremely simple.

- And I had to use npm to install the plugin in the first place. Typst comes with a package manager built-in.

- Generating PDFs required that I installed Chrome/Chromium. Typst does that out of the box.

The only place, that I can think of, where Marp is ahead of Typst, is with regards to generating HTML based presentations. But that probably won't be the case forever, and I personally always use PDFs for the final presentation, since that means that a lot less can go wrong. Especially so if I am not using my own PC when giving the presentation

> I originally picked up Typst as yet another replacement for PowerPoint

I’ve also mainly used it for slides so far. Can recommend Slydst for that.

I've been using touying so far. It took some effort, since I was learning Typst at the same time, but I was able to convert our "official" PowerPoint template to a toying template that I am quite happy with.

From what I can tell, Slydst seems intended for more minimalist slides. But it looks nice, so I'll have to keep it in mind for cases where I don't need the above template

How do you translate a bit more visually complex presentation to Typst? Should I create my iconography in SVG and try to position those?

What do you mean by a "more visually complex presentation"? Typst has some built in support for drawing shapes [1], but if you need more complex figures then cetz is also an option [2].

But if you mean animations (including animated transitions), then I do not believe that it is possible in Typst, since the output it outputs PDFs. I also do not believe that it is possible to embed multimedia in a document.

[1] https://typst.app/docs/reference/visualize/

[2] https://typst.app/universe/package/cetz/

isitreallyfoss.com did a break down on typst that goes more in-depth

https://isitreallyfoss.com/projects/typst/

It seems mostly fine except for this bit:

> The compiler includes a package manager “Typst Universe” that may connect to servers owned and operated by Typst GmbH

So do most package managers...

I think most package managers take the repository urls from config, with typst its hardcoded in the binary (right?).

Converted to Typst last year from LaTeX for book authoring, invoices, and slides (was using a hand-rolled rst2ppt tool for slides). Happy to never touch LaTeX again. Typst is that good.

Did you ever use beamer? I've done a few presentations with it, and while I wouldn't call it great, I preferred it to PowerPoint or keynote

I write this in pretty much every Typst thread.

Here are some notes I wrote when I started out with typst when comparing with LaTeX and some recent additions:

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. [I've been informed this is actually incorrect and Latex does allow you to specify macros anywhere]

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.

8. Compiling with Typst is always one pass.

9. I'm not sure how this would compare with Latex but I'm starting law school in a month and I need to cite using AGLC4 which has a CSL (citationstyles.org) template supported by Typst; I have confirmed the CSL XML is correct but doesn't render properly in Typst. The workaround I found was to hand typeset my own citation and bibliography which sucks.

10. Most of what you need is built in to Typst and I've yet to need to import a package or template; even for the most basic documents with Latex you find you'll need to use many packages (such as fancyhdr for customised headers and footers).

11. Latex distributions can be a monstrosity, gigabytes in size like TexLive, and I acknowledge you can get slimmed down on-demand version such as Miktex. There's just one distribution of Typst and its pretty lean, although it might be nice to have multiple implementations in the future.

As for Typst 0.14 - I'm really happy about Accessible PDF feature and HTML export, will give each a whirl.

> It doesn't generate 5 bloody files when compiling

This was a question [0] I asked on stack overflow more than 15 years ago, and is to this day the most up votes I've gotten on SO. I still get notifications from it occasionally.

[0] https://tex.stackexchange.com/questions/11123/prevent-pdflat...

12. It isn't a ticking time bomb with untrusted input.

When I compile LaTeX files, I use tectonic¹ which automatically download dependencies, compiles in one pass, and hides temporary files. But the regulars users of LaTeX I know all use a web interface — IIRC, it's an instance of Overleaf² installed by their university, with real-time rendering.

So when I read your list, I had these tools in mind, and the only items that made sense to me were:

2. (minor compared to Overleaf) typst compiles faster.

3. Diagnostics are better.

4. (minor and arguable) Lists have 2 simpler syntaxes.

The other points were irrelevant (dependencies), wrong (macros) or really dubious (margins, Git, bibliography). I think Typst has many more interesting features over LaTeX.

¹: https://tectonic-typesetting.github.io/

²: https://docs.overleaf.com/on-premises/installation/using-the...

tangent: what syntax lets you use superscripts in HN comments?

test^1

Unicode superscript characters.

https://en.wikipedia.org/wiki/Unicode_subscripts_and_supersc...

aha, thanks!

Yeah fair enough, people have different experiences.

I would like to address that you read my point for margins/footers/etc. being difficult in Latex is dubious. (Also not sure why you mention the bibliography thing as dubious as it was a real issue of Typst, but shrug.)

A few years ago I spent many hours trying to figure out why a fancy footer wasn't rendering in a Latex document. I wanted a Page x of y counter in the footer which requires a few extra packages. So I try adding it, using two different methods \fancyfoot and \cfoot that I found on StackOverflow & OverLeaf, yet neither worked. I thought I was doing the incantations incorrectly. Spent endless hours figuring out what was going on, until I broke down and created a minimal example by selectively removing stuff which helped uncover that it was rendering but off page. The culprit was an overly large \fancyfoot that I hacked in to give a long baseline because I wanted to use up a huge chunk of the page due to Latex generous margins.

Yes I got things wrong, but Latex really didn't make this stuff easy, and took many hours to troubleshoot -- though it did improve my Latex troubleshooting skills.

In contrast setting layout parameters such as margins and specifying a footer is effortless in Typst and doesn't have that footskip footgun (at least I didn't encounter it):

    #set page(
        width: 210mm,
        height: 297mm,
        margin: (top: 15.875mm, bottom: 25.4mm, left: 15.875mm, right: 15.875mm),
        footer: context [
          #set align(center)
          #set text(size: 10pt)
          Page #counter(page).display() of #counter(page).final().first()
        ]
      )

Anyway, that's my justification for that point.

> 2. (minor compared to Overleaf) typst compiles faster.

I would argue that this isn't minor. At least in my opinion, it makes a big difference.

Overleaf, already 3 pages into a document, with a couple of TikZ figures, was getting slow, as in multiple seconds wait for each save.

Typst, on the other hand (Tinymist in VS Code) is really realtime. Text updating within some tens of milliseconds, and figures included in far below a second. It really _feels_ instant, and to me that changes the experience a lot.

I have laptop with a good-ish CPU that is only a few years old, and on page 3 tinymist is already starting to struggle. There is a noticeable input delay between me pressing a key on the keyboard, and the key getting typed & the preview updating. I think it's more of a tinymist issue though, as it has no debouncing and apparently also runs the preview updates on the same thread as vscode's input handling.

Interesting. I have not experienced that, except when trying out the pre-release version of tinymist, and did some messy multiple view+cropping into a big pdf (testing out the new pdf-image stuff.) I chalked it up to it being new and beta.

Admittedly, I have still not created large documents in Typst.

Have only lightly dabbled in latex but Typst was super easy to pickup. I recently even published a whole book[0] in Typst. The process was straightforward for the most part. It took a little time to work out how to get page numbers alternating between the left and right side and a few other small formatting details but by and large it was very easy to create a beautiful PDF that's ready for printing.

Also, pandoc has fairly good support for Typst so I use that to create a docx (which Draft2Digital converts to epub). I even opened a few issues (https://github.com/jgm/pandoc/issues?q=sort%3Aupdated-desc%2...) for pandoc support and they were almost all resolved pretty quickly.

[0]: https://thelabofthought.co/shop/p/nbmi3

It really is so much better than LaTeX. I'm only saying this because I really enjoy using it. LaTeX was always tweak something, wait for the compile, and pray that it works, without having any clue about what was happening.

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

I don't get this one, it's equally easier to diff if you use semantic line breaks.

Can I convert LaTeX templates to Typst and vice versa? Many journals have LaTeX templates and demand LaTeX.

> Meanwhile, in HTML and SVG export, PDFs are converted to an embedded SVG on-the-fly. And, finally, in PNG export and the web app preview, PDFs are rasterized. All of this PDF processing functionality lives right in the Typst compiler, with no system dependencies. This is only possible thanks to the amazing work of community member @LaurenzV, who created a new PDF processing library called hayro from scratch. The library is 100% written in the programming language Rust (which is also the language we use for the Typst compiler) and is thus highly portable.

Wow! That must’ve been quite an effort.

And the hayro library is standalone and can easily be used outside of Typst. It only uses CPU and is pure Rust so it can also be used with WebAsembly. Link to demo below.

https://github.com/LaurenzV/hayro

https://laurenzv.github.io/hayro/

Holy sh*t, I've just dropped some pretty big pdfs (>400 pages), and it rendered almost instantaneously! This is really impressive.

Indeed... I wonder to what extent the author of hayro did this work specifically for Typst or if they would have done it anyway.

Author here! Resolving one of the most-requested Typst features was definitely a big motivation for me, but I wouldn't say this was the only reason. I've done a lot of previous work on PDF (see e.g. the krilla library, although also mostly in the context of Typst), so I was already pretty familiar with how PDF works. In addition to that, I also just finished writing my master's thesis about 2D rendering (also in Rust), so I also gained a lot of knowledge in that area. Therefore, this project seemed like a good opportunity for me to create a bigger open source project myself that I could work on in my free time. :)

And a job offer I hope!

Would it be feasible, with hayro-interpret and krilla, to take an existing PDF and round-trip each of the pages while wrapping the contents in marked content spans and adding tags, to remediate the accessibility of an existing PDF? Round-tripping each of the page content streams through a full-featured PDF interpreter seems cleaner than trying to edit in-place. PDFium can round-trip the content streams and add the marked content spans, but can't do the tagging. What do you think?

Yeah, this is definitely a goal for the future. But there is still quite a bit of work needed in both libraries to make this possible.

Thanks for sharing the background. It's impressive work. Makes me curious about your thesis... Is it publicly available?

Not yet, but it should hopefully be graded in 1-2 weeks and then I can share it!

For posterity: https://github.com/LaurenzV/master-thesis

Thanks for your contribution!

Impressive work, congrats!

> is thus highly portable

Much less portable than the C ecosystem though.

> Much less portable than the C ecosystem though.

Theoretically? Yes. In practice...

Do you actually develop for a platform that (a) has a standards-compliant C compiler, (b) does not have a Rust target, and (c) has enough memory to be worth dealing with PDFs?

That’s simplistic. I maintain some large C and Rust programs, and I find Unix/windows issues much easier to fix on rust than in C, and supporting Linux and windows well matters a lot more than some obscure CPU Rust doesn’t support.

I think I'm going to subscribe without any intention of using the app just as a "financing" donation.

I love, and hate, LaTeX and the idea of a LaTeX successor / alternative is incredibly appealing.

And the fact that they are aware that microtypography IS important and that they are working on it is a huge huge plus.

LaTex is not too bad but it's hard to cook properly. My personal pain point with LaTex is that it depends so much on environment where it runs.

I've had some success setting up nix flakes for this! Using an LLM assist I even got a single font changed. I had previously run a bunch of scripts as root with no idea what I was doing in order to effect the same change. Annoying!

Typst is open source, so you can run it on your computer; it's available as a CLI and has integrations with multiples IDEs (most use tinymist). Using typst is better than subscribing and not using it IMO because you can already start creating content and advocating for it, while telling the team about bugs or pain points

you can use the cli, subscribe (to the pro features of the app) and not use the app (online editor) to provide a bit of financial support WHILE using Typst and create content

Exactly my plan yes :)

First-gen 50-year-old open source suffers from a first-mover problem of not knowing how people will use the thing. Thus, 50 years later, we end up with multiple-gigabyte distributions and messy, inconsistent syntactic approaches to hack together what people want and need.

Typst has 50 years of accumulated TeX experiences to learn from, and fit everything people actually want to use into a 45M binary, and maybe you'll download a few dozen K of package scripts.

I have used it for much more than academic publishing (book, brochure, and even card layout) and it's hands-down the best tool ever made for producing documents of any imaginable kind. Procedurally producing layouts from first-class JSON and CSV support is bliss.

Have they indicated that they are working on microtypography support?

The example in this link of character-level justification is incredibly nice (enough to get me to try Typst), but it's not clear at least from this link whether they're actively working on microtypography.

I have made direct donations and I now just support financially by paying for a subscription to the web app.

I find myself switching between cli and web app a little more; the web app seems nice to experiment, share experiments especially when you need to demonstrate an issue when getting support, and has good enough git(hub) integration.

I would like Typst to support bounties, because I would throw a bit more towards HTML support.

If you're not going to use the web app, you may as well sponsor them through GitHub instead. Also, you get stickers that way.

The killer features of LaTeX that does not let me go with typst (Although I like my typst generated resume) as an academic are.

1. Beamer, I create multiple slide decks per week and the out of the box setup that beamer provides with different styles and fonts for different needs are unmatched. The efforts to generate some of this on typst is not there yet.

2. Generating figures using tikz and be able to modify it on the source file. Because I don't bear using GUI tools. And now life is easier that LLM can help you with complex tikz generation.

3. Not that it is actually a point but I am used now to overleaf and I have professional account as CERN member. It is also better on collaboration level and features than typst cloud.

I hope that one day typst will grow into this direction so that I can stop using LaTeX. Until then I have couple of overleaf templates generated for my use.

Maybe you have already checked these, but in case you haven't: - https://touying-typ.github.io/ Creating slides in Typst - https://cetz-package.github.io/ CeTZ is a package that allows for drawing with Typst with an API inspired by TikZ and Processing. It also provides plotting and chart libraries and is used in several other packages to create circuit, fretboard and more diagrams - maybe try getting your team to use version control? You may this that it's a lost cause, but existing version control schemes (like git) work very great for textual formats, including with LaTeX or Typst

These are great suggestions, but did I understand that suggest git as an alternative to overleaf? That's... not at all reasonable, as well as completely missing what problems overleaf solves for which people. Overleaf ist git und the hood. But what it really provides is Google Docs style collaboration on Latex documents.

Reviewing the changes I review in Overleaf in GitHub pull requests would be incredibly painful and introduce a completely new, convoluted and unintuitive (until you're used to it) workflow for collaborative editing.

FWIW, there is an open-source collaborative editor for Typst that was posted a couple of weeks ago on HN: https://news.ycombinator.com/item?id=45481791

In the Typst web app, you can link a project to a Git repository. This way you can have real-time collaboration in the web app, and versioning through Git. It's not the same as Overleaf's history GUI, but it's functional.

Some quick remarks:

1) I have been using typst to create slides with some success. Adding special features tends to be simpler than in beamer.

2) cetz (https://github.com/cetz-package/cetz) works quite well and is comparable to tikz in complexity and capability. of course, there is more support for tikz, but it is bound to improve over time.

1 and 2 are already in the typst ecosystem. What you really need is a professional account as CERN member,on Typst.

> 1 and 2 are already in the typst ecosystem

No they are not already there. As others replied, there are somethings similar but not the same feature completeness. I was specific to talk about beamer not saying "slides" in general.

If you make a lot of slides with latex, then it is definitely worth it to try typst. I have a lot of presentations in latex for lectures and such things, with many animated tikz figures. But the compilation times are huge. At some point it is very time consuming to iterate. With typst, it compiles so fast that you don't have to fear to start a compilation. I finish my presentations much faster now.

Cetz has been working very good for me. I was really unsure that it could replace tikz for my applications. But apparently, as long as you have good geometrical primitives (lines, rectangle, circles, etc) you can do a lot. Also it is much nicer to program and make real functions with typst. It is true, the typst options to replace beamer are still not quite there in comparison, but they are definitely in a very useful state. See for example typst-presentate [1].

[1] https://github.com/pacaunt/typst-presentate

One thing I'm missing when making slides with typst is the ability to show short videos or animated gifs. Although to be fair this isn't easy in beamer either.

Typst can actually include gifs, but they don't move for me. I have some hopes that perhaps one could make slides straight in html which could alleviate the issue.

Maybe you can use Touying Exporter: https://github.com/touying-typ/touying-exporter

> [1]

There is one example with Fletcher... I find these also nice: https://typst.app/universe/package/fletcher

To add on what's been said already on slide decks, another great slide creation package in Typst is touying[1]. I've used it to create my own academic theme[2] for courses or conference presentations.

[1] https://touying-typ.github.io/ [2] https://typst.app/universe/package/touying-unistra-pristine/

It was easy for me to roll my own slideshow tool in Typst. I would have never attempted this in LaTeX.

Can't respond to 2 or 3. Used tikz once. I wish there were a de facto programmatic drawing tool (I usually resort to graphviz or matplotlib), but there are a bunch of 80% solutions.

As someone who generates mathematical content as their job

1. Touying

2. Cetz. Personally I think that LLMs are pretty bad at Tikz. I know you said you don't like GUI tools but Inkscape is great

3. github >>> overleaf

After over a decade of occasionally updating that one ancient .docx file, I recently rebuilt my CV/resume using typst and it's been a really fun project! My resume is now a private repo with my personal, career, and styling data stored in TOML files. Then I can pull any interesting typst resume templates, populate the information from the TOML files by looping over arrays of jobs/projects, and populate it into the doc template. It's absolutely overkill but it was a fun project and I really enjoyed working with typst. Didn't even do a tutorial, just threw myself into the language and assumed it would be intuitive enough with some examples and it absolutely is.

Did you use an existing package or did you write something from scratch? I'm also looking at rewriting my CV in Typst, though the fact that I am happy with my current job means that it is not a very high priority task

I used existing templates from the [typst universe repository](https://typst.app/universe/) for the resume then built something much simpler from scratch for a secondary document, a sort of cover letter/case study of projects I've done.

If there's interest I can maybe take some PII out of my repo and make it public. Not like there's anything wildly private in there, would just prefer to not get any more spam calls than I already do.

You don't have to go through the effort for my sake. I was mainly interested in hearing if you had recommendations with regards to existing packages, though there's a decent chance that I'll just end up creating something from scratch

Really great work. Typst continues to impress. The eventual goal of HTML and PDF both as first class output will be a such a great improvement for scientific publishing.

For everyone who is using LaTeX and hasn't tried yet, give it a try. It is actually surprisingly featurefull and surpasses LaTeX in usability by a huge margin.

It sounds like it takes up a similar niche as PanDoc. Is there any particular feature that Typst is better at or is it mostly about ease of use? (I remember Pandoc to be quite nice to use for simple use cases while also allowing the full set of latex stuff when needed)

https://pandoc.org/

Pandoc isn't a typesetter, it's more a translation engine between various typesetting languages (and it can then call the typesetter).

Pandoc is a ridiculously underrated and powerful tool but it solves a different problem. Someone still has to write typesetters ;)

These are different categories of software.

Typst is a way to define a document. Headers, paragraphs, figures, equations, tables, etc. it is a direct competitor to LaTeX and maybe in some ways similar to Word, which provides a GUI for an XML defined document.

Pandoc is a converter, which given a document in one document description language outputs a document in another document description language.

What is exciting about Typst HTML support is that its goal is that it has first class support for both PDF and HTMl, which is obviously preferable to something like pandoc, which always has to rely on an intermediate representation of the document, before a conversion can happen.

PanDoc has its own version of Markdown that (more or less?) maps 1:1 to the intermediate representation in PanDoc, plus allows embedding other formats when necessary, or conditionally include some content only for some output formats.

It's a great format to use for editing, since it converts so well to all the other formats (including Typst?).

https://pandoc.org/MANUAL.html#pandocs-markdown

>PanDoc has its own version of Markdown that (more or less?) maps 1:1 to the intermediate representation in PanDoc

Which is bad if you want a complex document, since the intermediate representation of pandoc can not represent all typst features.

Also, I do not understand what your argument is. Pandoc and typst are not competing, they are different pieces of software with different goals. Pandocs markdown is also not competing with typst, since they are completely different ways to define a document. Typst is vastly more complex, it even includes its own scripting language. Pandoc also doesn't output PDF, except by calling some external tool, which then compiles a pandoc output format to HTML. It is fundamentally different to typst.

I agree they are not competing at all, and I will definitely consider Typst as an alternative to LaTeX, which to me is one of the output formats I use in PanDoc, and I might end up using Typst instead of LaTeX as an intermediate format when generating PDFs. I have not had to fall back to write LaTeX in several years and tend to get away with at most a few lines of inlined LaTeX in my Markdown files, and I expect it will be possible to inline some Typst code if necessary as well. Happy with PanDoc's Lua filters when I need to script something.

And, HTML leads to epubs since epub is essentially HTML.

In addition to what the other commentors write, an advantage of Typst is that it is self-contained:

You just need one (large) executable to do everything, whereas with PanDoc you (by default) need to have LaTeX installed if you want to generate PDFs

PanDoc has Typst as an output format, so it should be possible to just keep using PanDoc Markdown (for instance) and just switch to Typst output if that is (or becomes) better than LaTeX.

If you are just creating a simple document with default styling, the main advantage you get from Typst is near-instant compilation speed. Pandoc to HTML is similar though, but if you’re generating PDFs with LaTeX the compilation delays can be pretty annoying.

If you are creating more complex documents, the advantages become more pronounced. Styling in Pandoc means modifying templates, at which point you’re just writing LaTeX, and styling in Typst is much nicer than in LaTeX. You can also hit the limits of Pandoc templates quite easily, at which point you have to write Lua filters. I have found those to be quite cumbersome, and now your document logic is spread out over the Markdown source file, the LaTeX template, and the Lua filters. In Typst you can have a single file with your whole document in a clean modern format, and you can decide for yourself how much you want to separate content and presentation.

I use pandoc to convert markdown to physical books (with typst) and ebooks (epub) for my self-publishing empire.

One of my biggest grievances with typst is that it still does not natively support locale-aware decimal separator formatting[1], and thus requires various kludges to present decimal numbers properly in non-English languages. Not that LaTeX is any better in that, though.

I think this should be solved quicker, because if it requires some sort of changes to syntax, we will have problems if the "legacy" syntax becomes entrenched, so this sort of decisions are better to be made sooner than later.

However, most my experiences with typst have been highly positive. It is much, much faster than LaTeX, and way easier. I am looking forward to see it to become more common.

1) https://github.com/typst/typst/issues/1093

I'm super happy that Typst continues to chip away at LaTeX's dominance. Kudos to the team and contributors! <3

This looks like a great release. Lossless embedding of PDFs seems like it would be useful in many scenarios. I'm surprised with how much better the character-level justified text actually looks. And I wasn't even aware that it supported exporting HTML. Typst—both the tool and the language—are more robust and enjoyable to use IME than something like Markdown, Pandoc, Org mode, and other formats, so I'll definitely consider using it for my next web project.

My only concern is backwards compatibility. How committed is the team to supporting older syntax? What will happen in a year or two from now when I have to generate a PDF from a .typ file written with version 0.13? They mention deprecations in v0.14, so I assume that I should expect breaking issues. I suppose only time will tell how difficult upgrading will be in the future.

This was a big problem for me when using LaTeX, which is why I maintained a TeX Live Docker image with the exact version and dependencies I needed. Upgrading it was always a nerve-racking ordeal. Since Typst is a single binary, this should at least be easier to manage.

I don't know what their official policy is on breaking changes, but packages published via Typst Universe[1] are versioned, and you specify the exact version you want when importing a package in your document. So while you may need to install an older compiler (which is a single, self-contained executable), I don't think that you'll have to worry about your dependencies

[1] https://typst.app/universe/

As long as Typst is on version 0.x,you should probably expect breaking changes. There is talk about changing even part of the parsing rules.

This is the risk of being an early adopter.

Once v1.0 is out, I hope it will stabilize for the long term.

I think by the time Typst has been around for as long as the half-life of a major LaTeX release it will be pretty stable. (Only 12 more years to go!)

> To make sure you got everything right, you can enable the new PDF/UA-1 export. PDF/UA is an international standard that helps to create universally accessible PDF files. When it is enabled, Typst will run additional checks against your document to find accessibility issues and optimize for accessibility rather than compatibility. It will find issues such as missing document titles, wrong heading hierarchies, and missing alternative descriptions.

This sounds great! Are accessible PDFs possible with LaTeX? Last time I looked, it wasn't a standard feature and there didn't seem to be any easy workaround which is a real problem when there's a requirement to produce accessible PDFs.

LaTeX has made great progress on this front in the past years and results are now available in TeX Live 2025. Compared to Typst, on one hand the tagging is still opt-in [1]. On the other hand, LaTeX already targets PDF/UA-2 including automatic tagging for math formulas, while Typst currently targets PDF/UA-1, so you have to tag the math formulas manually, like an image. This is evolving fast though: yesterday a draft PR for Typst was opened[2] to add support for MathML Core, which I guess is a big step towards automatic tagging of math since the math tags in PDF/UA-2 are based on MathML.

Another thing to consider is compatibility of third-party packages: LaTeX packages often require adjustements and many important packages work now but many still don't work, including some big ones like Beamer and tufte-book [3]. I think Typst packages should require fewer adjustments, thanks to the way "show rules" work: a package (or the user) can write a show rule to transform an element for rendering, but Typst automatically retains the semantic meaning of the original element.

[1] https://latex3.github.io/tagging-project/documentation/usage...

[2] https://github.com/typst/typst/pull/7206

[3] https://latex3.github.io/tagging-project/tagging-status/

This is great! Having PDFs as a native image format removes one of the biggest hurdles for replacing LaTeX with Typst.

I literally was just working around this two days ago with muchpdf and now it's built in. Woo.

We used GitHub/Azure markdown plus Mermaid plus MathJax for financial model documentation. Beyond a certain complexity this really hurts.

Now we use typst, both playground (which does not call home, so no document exfiltration) or the compiler. The compiler is super easy to install, as we already have the Rust build chain installed. Compared to Tex, the 40 odd years newer design of typst makes all the difference.

FYI - Typst will sell you a self-hostable version of the webapp.

How did you integrate Mermaid in the new Typst workflow?

I want to express my gratitude to the typsr team and congratulate them on their release.

I got started with typst because I wanted to put my resume in a got repository, for no reason other than to learn git.

One day I want to write a crosswords document using typst. I don't know how yet because I can't get my tables to be squares but one day... (:

You'll probably want to try CetZ!

In fact... https://github.com/micheledusi/Griddle

There are already some Tufte-inspired templates available for Typst:

https://typst.app/universe/search/?q=tufte

When I did my bachelor’s, I wrote every assignment and my thesis in LaTeX—and I absolutely loved it. I loved it so much that I swore I’d never touch MS Word again. Now I’m doing my master’s, and once again, I’m writing everything, assignments and thesis, in Typst. And boy, do I love Typst. I only had to spend a fraction of the time tweaking it to get exactly what I needed. Most things just work right out of the box. The only “bad” thing, in my opinion, is that Typst isn’t quite as feature-rich as LaTeX.

I really wish I could use Typst, but to be honest, it doesn't work with any journal I know of, let alone arXiv. It feels like a chicken-and-egg problem to me; I can't see most people who use LaTeX moving over unless journals and preprint servers adopt it, and I can't see journals or preprint servers adopting it unless people move over. Still, it's early days, I and wish the community good luck and I genuinely hope that one day I can ditch LaTeX for something markdown-like.

Yeah, from discussing this with friends in academia it seems like this is the biggest hurdle at the moment. Someone on Reddit reached out to arXiv [0] and their response was very negative towards it, which seems unfortunate:

> At this point, we’re more likely to add support for .docx than a markdown language.

[0] https://www.reddit.com/r/typst/comments/1ddlgvg/arxiv_just_a...

I've seen that too, yeah. It's unfortunate, but also completely reasonable; docx is actually surprisingly common outside of physics, maths, and CS, and it is almost surprising that it's not supported since OOXML an open format now.

Switching from LaTeX to Typst is like getting introduced to Python after a lifetime writing assembly... except it's also 10x faster

I tried it, and it's already impressive for neither requiring a login page nor having ad-nonsense. I wish more web apps were like that.

Living in a Berlin you encounter founder and CS people on funny occasions. So after starting using Typst I met one founder in an university dance course. Every time Typst is mentioned on HN, I've to recall that dance course.

Dude was definitely marketing Typist at the dance course. That's hustle.

I love typst and I tried to use it recently when shipping publications to EMNLP, AAAI, and NeurIPS. While there were a lot of upsides to it, things got very bad when the teams grew beyond just a few people. Typst is incredible for single-person or a trio of people, but the web experience is not there yet for collaboration. I’m really hoping for typst to continue and I plan to use it whenever I can for smaller projects or stuff that wont involve working with professors or students who are not interested in learning new things during publication time.

How did you deal with the usually supplied templates that you get for TeX? Did you just try to imitate as best as possible?

(I wanted to look at this at some point for replacing latex for submissions to IEEE confs/corl etc)

> Typst is incredible for single-person or a trio of people, but the web experience is not there yet for collaboration

How did collaborate in the past on LaTeX publications?

Not OP, but likely overleaf.

Typst is fantastic, I like it a lot (and have used LaTeX for over 30 years). I hope they keep up the great work!

Anyone using this for Literate Programming?

A quick search found:

https://github.com/litProgTypst/ (which I'm mystified by)

and

https://github.com/denkspuren/typst_programming (which hasn't been updated in two years)

Not seeing anything specific at: https://typst.app/docs/reference/scripting

I need to re-write my current project https://github.com/WillAdams/gcodepreview again --- maybe this would be a good fit? The unique feature I am taking advantage of is writing out code blocks in separate files, then concatenating them using .lua so there's no differentiation betwixt tangle/weave, both happen, and since it's Python, no need for a compile step either.

Would https://quarto.org/ fit the bill?

Maybe.

I looked at it a while back and will check it out again.

> alt: "Diagram with two rectangles. The first is labelled 'Tagged PDF'. An arrow points to the second, labelled 'Accessibility'"

Not trying to make any statement but I'd love to see how this level of alt text detail scales to a diagram that's more than a rectangle pointing to a rectangle

I think a simpler text would be better and less tedious for anyone in the document's audience, something along the lines of "box 'Tagged PDF' to box 'Accessibility'"

I've been really pleased with Typst so far - fast rendering, less verbose than (La)TeX in many ways (backslashes hurt now!) and unicode/emoji support really seals the deal. (Disclaimer: only using for semi-formal slides and notes, not for papers and important presentations)

Wondering how this compares to Emacs org mode, which support exports to PDF slides with beamer or plain PDF document, also support to export to lots of other format. It also allows running the embedded code and export the results. Of course embedding PDF is easy.

Slightly related:

https://github.com/jmpunkt/ox-typst

In case you want to use both org mode and typst.

(Haven't tried it out).

Typst is such a pleasure to work with! Especially compiled to wasm in the browser, super fast

This name really should have been work shopped before being chosen. This and 'slint' should get together and figure out better project names.

I've started using typst in a recent side project. An online article to PDF converter for e-Readers (reMarkable in my case): https://klartext.press/. It works like a charm. Blazing fast, beautifully typeset documents.

It's indexing with imakeidx that's keeping me on LaTeX. Does anyone know offhand the state of indexing with Typst?

https://en.wikibooks.org/wiki/LaTeX/Indexing

With a quick search I can see that the `in-dexter` package [1] provides something quite similar, though I'm not sure if it covers all usecases.

If you want to handroll this yourself you can probably have your `index` emit some `metadata` [2] which you can then `query` [3] for in your `printindex`. All of this would work inside the typst compiler and there would be no need for running an external `makeindex` command.

[1]: https://typst.app/universe/package/in-dexter

[2]: https://typst.app/docs/reference/introspection/metadata/

[3]: https://typst.app/docs/reference/introspection/query/

Thanks. My search found that also, but it didn't appear to have the features I need, at least not at the time. If LaTeX becomes vexing enough, I'll consider the custom workflow you're describing. Thanks for the tips.

Typst is great. I'm ditching Asciidoc for writing specifications. No more terrible Ruby, wahoo!

Have a look at

https://typst.app/universe/package/soviet-matrix

This is a classic Tetris game implemented using Typst!

I used to use markdown with embedded LaTeX and pandoc for scripting. I hated the stack, it was really hard to write custom functions.

Since switching to typst my happiness with my writing tools improved dramatically.

I recently jumped into typst for creating a course syllabus to learn programming. The experience has been great, especially compared with the LaTeX memories from grad school.

I have been using pandoc to convert markdown files to pdfs, and keep them in a git repo. Looking at typst, I think it can be a better replacement.

Kinda wonder how accessible the online editor is? I should try it, see if VS Code is a linter or something for it, although there is the compiler.

VScode has an extension that uses the language server tinymist, which is available in other IDEs as well. The vscode extension offers live preview, but it's also available on other IDEs

I found the online editor really easy to use, but it doesn't expose all of the functionality in GUI, you'll need to read docs.

The accessibility support (PDF/UA-1) is VERY nice, but there's still still a lot of work to do (-> tables).

Is this like DocBook/ASCIIDoc?

I tried Asciidoc for a bit (as a replacement of Markdown, because I wanted/needed more than Markdown).

While asciidoc hasn't matched my expectations (went back to Markdown), Typst has.

Yeah. I went down the rabbit hole with ASCIIdoc several years ago. I was looking for a text-only way to write complex documents like contracts with lots of nested sections and internal references. Markdown wasn't enough. ASCIIdoc was a solid language, but the ecosystem was too weak to commit to.

I'm taking another run at this with Typst. I'm getting a lot further!

Typst: A Possible LaTeX Replacement - https://news.ycombinator.com/item?id=45393842 - Sept 2025 (384 comments)

I wrote my PhD Thesis in Typst - https://news.ycombinator.com/item?id=44350322 - June 2025 (328 comments)

Typst 0.13 is out now - https://news.ycombinator.com/item?id=43105444 - Feb 2025 (60 comments)

TeX and Typst: Layout Models (2024) - https://news.ycombinator.com/item?id=43032697 - Feb 2025 (38 comments)

Using Pandoc and Typst to Produce PDFs - https://news.ycombinator.com/item?id=42271078 - Nov 2024 (19 comments)

Typst 0.12 is just... better - https://news.ycombinator.com/item?id=41888107 - Oct 2024 (4 comments)

Exploring Typst, a new typesetting system similar to LaTeX - https://news.ycombinator.com/item?id=41821361 - Oct 2024 (235 comments)

Typst: An easy to learn alternative for LaTex - https://news.ycombinator.com/item?id=41014941 - July 2024 (187 comments)

Typst – Compose Papers Faster - https://news.ycombinator.com/item?id=38354422 - Nov 2023 (134 comments)

I rewrote my CV in Typst and I'll never look back - https://news.ycombinator.com/item?id=38047224 - Oct 2023 (25 comments)

Typst: Finally a Solid LaTeX Alternative - https://news.ycombinator.com/item?id=35835703 - May 2023 (3 comments)

Typst, a new markup-based typesetting system, is now open source - https://news.ycombinator.com/item?id=35250210 - March 2023 (146 comments)

Typst: A Programmable Markup Language for Typesetting [pdf] - https://news.ycombinator.com/item?id=34423590 - Jan 2023 (53 comments)

Typst: Compose Papers Faster - https://news.ycombinator.com/item?id=32209794 - July 2022 (30 comments)

Support in sublime text?

Yeah but can it run doom

Actually, very nearly so: https://typst.app/universe/package/soviet-matrix/

Reply on news.ycombinator.com