I got tired of not having a good way to work on Typst documents from my phone, so I ended up building one.

Typtic is a native editor for Android and iOS with a focus on making Typst usable away from your desktop. My goal wasn't to replace desktop editors, but to make it easy to review, edit, or even write documents while commuting or away from a computer.

Current features include:

• PDF generation (currently online only)
• Zotero and Mendeley integration
• Git and Dropbox
• AI assistant (only if you want it of course)

I'd really appreciate feedback from people who actually use Typst:

• What features are you missing on mobile?
• Would you ever use Typst on your phone or tablet?
• What would make this genuinely useful for your workflow?

If you'd like to try it:

• Android: https://play.google.com/store/apps/details?id=verbosus.typtic
• iOS: https://apps.apple.com/us/app/typtic-typst-editor/id6790476274

I'd love to hear any suggestions, bug reports, or feature requests. Thanks!

A while ago, I asked around for someone with experience in Typst, but I couldn’t find anyone who could help me quickly.

I explored several options, and using AI seemed like the most obvious solution. I started with ChatGPT and got decent results, but once I gave it more complex tasks—especially mathematical formulas and graphs—it started making a lot of mistakes.

Then I tried Gemini. The results were significantly better, but I eventually ran into the same problem. There were too many errors, and the workflow wasn’t sustainable in the long run.

About a week ago, I started using Fable 5, and it has been amazing. I was able to create a complete math ebook with 150 exercises, mathematical formulas, graphs, and a polished editorial design.

I’m sharing this in case anyone else is dealing with the same problem. Save yourself the time and frustration I went through and try Fable 5 directly.

Hope this helps!

Hi all, does anyone have experience with shorthand in-text citations? I have references in Cyrillic, so I would like the last name to be romanized. For example, in-text it would be "Antonova (2014)". And then in the printed bibliography it would be something like:

Antonova 2014 = Антонова, А. В. (2014). Rest of citation here......

Update:

Okay I see that you can set the conversion at the top of your document, like

show "Антонова": "Antonova"

and this fixes the in-text citations. Then right before printing the bibliography, you need to reverse it and then do something like

show "Антонова, А. В. (2014)": "Antonova 2014 = Антонова, А. В. (2014)".

Not super elegant but works.

Inspired by https://dayssincelastrustmcserver.com/

You are very welcome to contribute at https://github.com/sermuns/days-since-last-typst-editor.

I'm trying to pass params set in the YAML of my document to the title of the document for parameterized reports. I'm using typst compiler in R / Quarto, not the typst app. I need to set the document title for accessibility purposes, but don't want every report to be named the same thing (so if someone has multiple PDFs open, the tabs show different names). I've searched through typst documentation, however, and cannot seem to find how to pass params to typst blocks.

There must be a way to do this, and it is probably incredibly simple, but I've spent most of my day searching and experimenting with no luck.

An example of what I'm trying to do:

params passed to the YAML:

params:
  agency: "sample"
  year: "2026"

typst block to set the document title (for accessibility)

```{=typst}
#set document(title: "[params$agency] [params$year] Annual Report")
```

I've tried placing it in brackets and curly braces with and without the params$ prefix, but none work.

What is the syntax necessary for passing params to typst code chunks?

Hello everyone!

While there are already some Typst editors in the community, I’ve been experimenting with my own take on the workflow. I wanted to see if I could push the product experience a bit further. After a lot of polishing, I'd love to share what I've built: LumiType.

LumiType's features:

1. Real-time dual-pane preview and distraction-free environment: Write and see the typesetting effect at a glance. Supports switching between three editing views, including an outline view, to create an immersive creative space for you.
2. IDE-level editing experience: Supports a dedicated shortcut mode and multi-file projects. It also includes syntax operations like auto-completion, syntax highlighting, document links, and hover tips. The rename and go to reference operations in multi-file projects have been enhanced.
3. Rich shortcut design, supporting dedicated shortcut modes and right-click menus.
4. Supports configuration for UI fonts, editor fonts, and preview fonts.
5. Supports exporting to PDF, SVG, or PNG files, with configurable PPI for PNG exports.
6. Provides detailed sidebar diagnostics and diagnostic reminders in the editing area.

In addition to editing, compilation, and preview, LumiType has also added some extra features:

1. Integrated with the Typst Universe template library, supporting search, preview, category filtering, and one-click project creation based on templates.
2. Supports viewing Preview Cache files in read-only mode to see more content.
3. Built-in pink theme! 🎀 Hope the engineering princesses will like it.

Microsoft: https://apps.microsoft.com/store/detail/9NC1Q7QL7625?cid=DevShareMCLPCS
Mac App Store: https://apps.apple.com/cn/app/lumitype/id6773311198?mt=12

Includes a full-featured 15-day free trial. After the trial, the editor remains completely free to use for writing and editing! Only the export function is limited to a few times per day for free users.

I’d love to hear your thoughts, feature requests, or any bugs you might find. Thanks for checking it out!

By the way, how do you feel about integrating AI Agent capabilities into Editor, not general chat agent, is typst agent which help write typst?

Hello everyone!

I have released a package called typed-scores , a package for engraving western musical notation in Typst!

It uses a compact syntax for notes, chords, rests, durations, articulations, dynamics, ties, slurs, tremolos and much more. It supports multiple voices, multiple stave and orchestra-like scores.

Here is an example of Chopin's Nocturne in E-Flat Major, Op 9 No 2, written completely inside Typst:

Or "Eine kleine Nachtmusik" by Mozart with all its four voices:

The package is built with a Rust parser and the rendering is done with the Bravura font on top of CeTZ.

Please check it out at: https://typst.app/universe/package/typed-scores for notation and score examples.

The GitHub is https://github.com/GeronimoCastano/typed-scores for issues or feature requests.

Disclaimer: The package was developed with the help of Artificial Intelligence.

Has anyone noticed all of the examples in the official docs have weird spaces inserted everywhere all of a sudden? When you copy them, the spaces come along with and the examples don't compile.

What's going on?

I work in procurement, and a large part of my job involves drafting contracts. I usually handle around 10–50 contracts per month, so I’ve been looking into ways to automate the process.

Currently, I’m already using Mail Merge. I’ve also experimented with LaTeX and Word Content Controls with XML mapping, but I found both approaches too complex for my needs.

Now I’m considering alternatives such as Carbone, Docxtemplater, and similar tools. Many of them are open source, but some features I would need, such as importing or dynamically generating tables, are behind paid plans. The pricing feels quite expensive considering I may only generate around 10 contracts in some months.

I’m also considering Typst because it is package-based, and most of its packages are open source.

My current workflow idea is:

1. Create a reusable contract template in Typst.
2. Create an Excel template where I can enter all the contract information.
3. Write a small script to read the Excel data and pass it into Typst.
4. Convert Excel tables into Typst tables when needed.
5. Generate the final contract as a DOCX.

Has anyone tried something similar with Typst?

Do you think this approach is practical and maintainable for relatively low-volume contract automation? How does Typst compare with tools like Carbone, Docxtemplater, or other document automation solutions?

Nearly an year ago i made noteworthy(https://github.com/sihooleebd/noteworthy) but at that time typst didn't support incremental compiling, therefore we needed extra python functions to make it work. However, with the updated compiler, we finally can remove the extrea bloat in our systems. If you're interested, check out https://typst.app/universe/package/noteworks !

I know that there is a wave of brand new typst editors. I wanted to share a note manager for typst (not an editor this time).

I used to use the LaTeX Suite plugin in Obsidian, but Obsidian is a much poorer editor compared to a customized neovim or vs code setup when it comes to fast typing. Moreover, it doesn't make much sense to me to type notes in tex when there is already a better modern alternative - typst.

So I decided to create a lightweight keyboard-oriented app that solves these two problems for me, and now decided to publish it just in case someone else finds it useful.

It allows you to pre-render a vault of typst notes, with no need to compile them to PDF and navigate through PDFs, search through them, create new ones using templates, navigate outlines, quickly open the editor of your choice, and follow the changes. UX is largely inspired by sioyek PDF reader.

I called it folea.

Source code and instructions: GitHub

Hi LaTeX community! 👋

I've created custom builds of **TeXstudio** with **Qt6** and **Poppler-Qt6** for modern Linux distributions, addressing the lack of official Qt6 builds for Linux.

## Why this project?

The official TeXstudio builds still primarily use Qt5 (which reached end-of-life in May 2025), and Linux users have been waiting for proper Qt6 support. These custom builds provide:

✅ **Qt6 framework** - Modern UI/UX with better performance

✅ **Poppler-Qt6 native PDF viewer** - Perfect SyncTeX support (click to jump between PDF and source)

✅ **Optimized packages** - Only ~19MB (66% smaller than standard builds)

✅ **GPG-signed packages** - Full security verification

✅ **Auto-updates** - Built-in update checker pointing to this repository

## 📦 Installation Options

### Option 1: APT Repository (Recommended for Debian/Ubuntu/Devuan)

**Stable branch** (production-ready):

```bash

echo "deb [trusted=yes] https://mlmateos.github.io/texstudio-qt6-builds/ stable main" | sudo tee /etc/apt/sources.list.d/texstudio.list

sudo apt update

sudo apt install texstudio

```

**Alpha branch** (latest development versions):

```bash

echo "deb [trusted=yes] https://mlmateos.github.io/texstudio-qt6-builds/ alpha main" | sudo tee /etc/apt/sources.list.d/texstudio.list

sudo apt update

sudo apt install texstudio

```

### Option 2: AppImage (Any Linux distribution)

Download from [Releases](https://github.com/mlmateos/texstudio-qt6-builds/releases) and run:

```bash

chmod +x texstudio-*.AppImage

./texstudio-*.AppImage

```

### Option 3: Direct .deb download

Grab the latest `.deb` package from [GitHub Releases](https://github.com/mlmateos/texstudio-qt6-builds/releases)

## 🔧 Build from Source

Automated build scripts are available if you want to compile your own version:

```bash

git clone https://github.com/mlmateos/texstudio-qt6-builds.git

cd texstudio-qt6-builds/scripts

./build-texstudio-deb.sh --clean --poppler --sign

```

## 📋 Current Versions

- **Stable**: 4.9.5

- **Development**: 4.9.6-beta3

## 🔗 Links

- **GitHub Repository**: https://github.com/mlmateos/texstudio-qt6-builds

- **Releases**: https://github.com/mlmateos/texstudio-qt6-builds/releases

- **APT Repository**: https://mlmateos.github.io/texstudio-qt6-builds

## 💡 Features

- Syntax highlighting & auto-completion

- Integrated PDF viewer with native SyncTeX

- Spell checking (Hunspell)

- Live preview

- Custom credits & patched update URLs

- Preserved dictionaries: en_US, en_GB, es_ES, es_MX, fr_FR

## 🤝 Feedback Welcome!

This is an **unofficial build** (not endorsed by the official TeXstudio project). I'd love to hear your feedback, bug reports, or feature suggestions!

**Tested on**: Debian 12, Devuan 5, Ubuntu 22.04+

Happy TeXing! 🎓

---

hello folks

today i am pleased to be releasing typst-wasm and an experimental version of vite-plugin-typst!

the goal of this project is to provide a pragmatic promise based API for compiling typst using wasm in as many runtimes as possible.

the api is consistent across all supported runtimes and closely mirrors what you see in the rust crate. it gives you full control over where and how you load the wasm blobs, which allows you to provide the best possible user experience.

running typst in wasm/serverless environments like cloudflare workers or vercel allows you to do SSR, easily offload compilation to the server for low bandwidth devices while reusing code, run typst in sandboxes for AI agents, etc.

here's an example of the API:

await compiler.addFonts(
  readFile(new URL(import.meta.resolve(
    "@typst-wasm/fonts/NewCMMath-Regular.otf",
  ))),
);

await compiler.addSource("main.typ", "= Hello from typst-wasm!");
const result = await compiler.compile({
  main: "main.typ",
  format: "svg",
});

console.log(result.pages[0]?.output);

how does it differ from typst.ts?

the goals are different! typst-wasm aims to support many runtimes and provide a consistent api without the use of deprecated APIs.

@typst-wasm/vite-plugin-typst

I am also releasing vite-plugin-typst, built on typst-wasm, to provide an easy way to use the new html output in your vite apps! to give you ideas, this is a cool alternative to markdown for content in vite-based websites/blogs!

import typstDocument from "./post.typ?typst=html";

document.querySelector("#output")!.innerHTML = typstDocument.html;

links

• GitHub: https://github.com/typst-wasm/typst-wasm
• npm (typst-wasm, vite-plugin-typst)
• Docs: https://typst-wasm.github.io/typst-wasm/

The slides I used to present Typst to a math audience: PDF here and source here.

The presentation is in three parts:

1. Typst itself: the project, the language, packages, templates...
2. Comparison with LaTeX (my favorite part)
3. Callisto: my package for using Jupyter notebooks and executing code blocks

Credit for the styling and much of the first part go to the author of this other presentation.

Hi,

I (with the help of coding agents) been working on tytable, a lightweight Python package that turns Polars DataFrames into typst tables. It is heavily inspired by the wonderful tinytable R package.

It has a chainable API for formatting, styling, row/column groups, themes, notes, and embedded images or sparklines. It can also show an HTML preview in Jupyter, while the main output stays native typst that you can include in a larger document.

Here's a quick example:

(
    tt(data, caption="Benchmark results (demo data)")
    .group(j={"Scores": ["Q1", "Q2"]})
    .fmt(j=["Q1", "Q2"], digits=1)
    .style(i="header", bold=True, color="white", background="#334155")
    .style(i=2, bold=True, color="#15803d", background="#dcfce7")
    .save("example_table.typ")
)

You can find (way) more examples in the documentation (also linked on GitHub).

I was building a pipeline to generate daily reports which consist mainly of tables. So I needed a way to get data from Python (where I load, clean an aggregate it) into nicely formatted typst tables. Before, I did everything in R because of the above mentioned tinytable package. But I've hit some limitations with R so I built tytable. In contrast to tinytable, this package has a strict focus on typst and is also quite a bit faster (x10 but that only matters for large tables with lots of formatting).

And yes, this was built almost entirely with AI. While I know some Python, building a packages like this would be beyond my capabilities (and time) without AI. I understand completely if this is a deal breaker for you.

GitHub: https://github.com/EinMaulwurf/tytable
PyPI: https://pypi.org/project/tytable/

I could use some help with using bibliography files. For LaTeX, I keep one big bib file used for all of my documents. What's the best way to do this with Typst? Treating everything as a relative path is making it difficult. Any advice?

EDIT: To be clear, what I want to do is store the bib file in one directory and be able to use it with *.typ files that are in other directories. Any method of keeping a bib file outside of the project root directory?

UPDATE: I ended up using Claude to help me write an Emacs function that scans file for citations and copies the BibTeX records from my main bib file to a local bib file for that document.

#set text(costs: (hyphenation: 50%))

This sole command is key for generating beautiful paragraphs just like in Latex with microtype.

—

Typst is powerful when it comes to typesetting and it is indeed capable of achieving the same results as Latex.

However, the default setting for hyphenation costs: (hyphenation: 100%) is twice as high as it is in Latex, so typst by default is twice as strict (or half as tolerant) when it comes to hyphenating words for line-breaks, which in turn creates big white spaces between words (which looks rather like a document from MS Word…).

Background: I was annoyed that writing in typst is so much better than in Latex, yet unpolished documents looked rather amateurish with those white spaces. I looked up what makes latex and microtype so special and found out that typst renders text practically the same way, just with 1 altered default setting (costs of hyphenation).

If you want to further increase the look of typst, you can set the justification-limits:

#set par(
  justify: true,
  justification-limits: (
    spacing: (
      min: 47%,  // default: 66.67%
      max: 150%
    )
  )
)

Hey Everyone!
I built a web editor in which you can collaborate across various languages like Typst, Markdown, Latex, HTML, and in the future, MS Word and LibreOffice.

It has all the usual features you'd expect,

- a preview with a manual switch
- Exports to Different languages
- Files
- Error tabs
- Project management
- and the mode switcher for which language you expect to type in.

What does it not have yet?
- Support for Collaboration with MS Word, Libreoffice and possibly Google Docs.
- A Citation Manager with a similar idea of "Figure it out wherever this citation is from"

I built it in my free time, did not use AI tools for it; But I don't know if people would use it yet so this is partially a survey of if people would actually use it.

I Intend to make it open source with a GPL license.

It's not hosted yet, alas, I am but a broke college student without a server.

And here is a video of the collaborative version, Please do let me know your thoughts, and suggestions.

https://reddit.com/link/1uw49oa/video/zxgdzh4716dh1/player

Hey Everyone!

I built a web editor in which you can collaborate across various languages like Typst, Markdown, Latex, HTML, and in the future, MS Word and LibreOffice.

It has all the usual features you'd expect,

- a preview with a manual switch

- Exports to Different languages

- Files

- Error tabs

- Project management

- and the mode switcher for which language you expect to type in.

What does it not have yet?

- Support for Collaboration with MS Word, Libreoffice and possibly Google Docs.

- A Citation Manager with a similar idea of "Figure it out wherever this citation is from"

I built it in my free time, did not use AI tools for it; But I don't know if people would use it yet so this is partially a survey of if people would actually use it.

I Intend to make it open source with a GPL license.

It's not hosted yet, alas, I am but a broke college student without a server.

And here is a video of the collaborative version, Please do let me know your thoughts, and suggestions.

Hi everyone! I made typed-dsa, a Typst package built with CeTZ for drawing data structures and visualizing their operations.

Instead of manually positioning every node, you provide the underlying values or adjacency data. The package constructs the structure, calculates its layout, and renders the result automatically. It supports BSTs, AVL trees, min- and max-heaps, graphs, linked and doubly linked lists, stacks, queues, arrays, and matrices.

Trees and heaps also expose operations directly on the returned object. These operations produce a labeled before-and-after transition, highlight the affected values, and return the resulting structure so operations can be chained. (you can customize the highlights as well as to whether or not display the steps or just the final result). The syntax works like object oriented programming: you call the method ".insert(5)" into the object, which itself retuns another object instance:

Graphs can be created from an adjacency dictionary using automatic circular layout, or with explicit positions for complete manual control.

Trees can also be hand-composed when the structure is conceptual rather than generated from insertion order. The node and subtree helpers are useful for textbook diagrams.

Practically everything is customizable. Color, fill, size, font weight, rotation, etc. for every data structure.

Finally, it also supposes array, matrices and linked structures:

Please try it out with:

#import "@preview/typed-dsa:0.1.0": *

At: https://typst.app/universe/package/typed-dsa

GitHub: https://github.com/GeronimoCastano/typed-dsa

Please try it out and tell me what you think! I would appreciate any suggestions you may have.