Google Docs/Microsoft Word

I’ve successfully used Google Docs to make a slightly but not that dense cheatsheet for an operating systems course in the past (which, as any computer science or engineering student can tell you, has oodles of terminology and concepts that you need to remember), and while it was decent to some degree, it’s lacking in a lot of ways (almost all of which are remedied by Typst). Here’s just a few of why you shouldn’t be using Google Docs for your cheatsheet:

• It gets real slow when word count gets real high, especially in Google Docs.
• Zooming in/out to parse through really small text is a hassle, especially when it comes to finding specific words or phrases amongst an ocean of text.
• Making document-wide changes to text formatting (like changing the highlight colour of all bolded text) is at best a finnicky modification of document styles and at worst a completely manual endeavour involving lots of copy-pasting (and trust me, trying to use the format painter with paragraphs of teeny-tiny text without accidentally modifying anything you don’t want to modify is a lesson in pure frustration).
• It’s really hard to plan out how to organize content (tables would be the ideal way of grouping text together, if they weren’t so finicky to adjust), and moving content from one place to another requires so much reshuffling that it makes you question whether the whole thing is even worth it in the first place (and it is, just not if you’re doing in Google Docs).
• Adding, updating, and removing images is an exercise in frustration and a reminder of how true to life that one meme is (about Word spazzing out your delicately edited formatting for the entire document when you slightly move an image by 1 mm).

So the WYSIWYG editor approach just isn’t going to cut it for making all the small changes you’re going to need to make for your awe-inspiring cheatsheet. Which leads us to the programmatic approach, and the obvious choice, LaTeX.

LaTeX

Look, I love LaTeX as much as the next guy, but there’s a couple of key pain points with LaTeX that make it suboptimal compared to Typst. Specifically…

• It’s slow to render when there’s a whole lot of text (and frustratingly, will need to render the entire document even if all you do is change a single word).
• Anything and everything requires a metric ton of boilerplate syntax (typing out backslashes and curly brackets is the last thing I want to do 1k words in).
• It’s practically impossible for the layperson to reasonably extend LaTeX code beyond something simple like shorthand functions for formatting text (which is most people just use templates built by people who’ve spent a lot of time on them).

On that last point, I took a quick search on Github¹ for any LaTeX cheatsheet templates that might be a suitable starting point for something more complex. And… yeah, while it might pass for a cheatsheet for Vim commands, it’s wholly inadequate for dealing with the sheer amount of content in your average university course, and is really a microcosm of the whole boilerplate and limited (practical) extensibility issues surrounding the use of LaTeX for making a cheatsheet. I mean, just look at that code 😔.

A decent-looking LaTeX cheatsheet, albeit one that isn’t necessarily the best use of space and is an absolute *pain* to edit in LaTeX. Source: https://wch.github.io/latexsheet

...
\subsection{Common \texttt{documentclass} options}
\newlength{\MyLen}
\settowidth{\MyLen}{\texttt{letterpaper}/\texttt{a4paper} \ }
\begin{tabular}{@{}p{\the\MyLen}%
                @{}p{\linewidth-\the\MyLen}@{}}
\texttt{10pt}/\texttt{11pt}/\texttt{12pt} & Font size. \\
\texttt{letterpaper}/\texttt{a4paper} & Paper size. \\
\texttt{twocolumn} & Use two columns. \\
\texttt{twoside}   & Set margins for two-sided. \\
\texttt{landscape} & Landscape orientation.  Must use
                     \texttt{dvips -t landscape}. \\
\texttt{draft}     & Double-space lines.
\end{tabular}
 
Usage:
\verb!\documentclass[!\textit{opt,opt}\verb!]{!\textit{class}\verb!}!.
 
 
\subsection{Packages}
\settowidth{\MyLen}{\texttt{multicol} }
\begin{tabular}{@{}p{\the\MyLen}%
                @{}p{\linewidth-\the\MyLen}@{}}
%\begin{tabular}{@{}ll@{}}
\texttt{fullpage}  &  Use 1 inch margins. \\
\texttt{anysize}   &  Set margins: \verb!\marginsize{!\textit{l}%
                        \verb!}{!\textit{r}\verb!}{!\textit{t}%
                        \verb!}{!\textit{b}\verb!}!.            \\
\texttt{multicol}  &  Use $n$ columns:
                        \verb!\begin{multicols}{!$n$\verb!}!.   \\
\texttt{latexsym}  &  Use \LaTeX\ symbol font. \\
\texttt{graphicx}  &  Show image:
                        \verb!\includegraphics[width=!%
                        \textit{x}\verb!]{!%
                        \textit{file}\verb!}!. \\
\texttt{url}       & Insert URL: \verb!\url{!%
                        \textit{http://\ldots}%
                        \verb!}!.
\end{tabular}
 
Use before \verb!\begin{document}!.
Usage: \verb!\usepackage{!\textit{package}\verb!}!
 
 
\subsection{Title}
\settowidth{\MyLen}{\texttt{.author.text.} }
\begin{tabular}{@{}p{\the\MyLen}%
                @{}p{\linewidth-\the\MyLen}@{}}
\verb!\author{!\textit{text}\verb!}! & Author of document. \\
\verb!\title{!\textit{text}\verb!}!  & Title of document. \\
\verb!\date{!\textit{text}\verb!}!   & Date. \\
\end{tabular}
 
These commands go before \verb!\begin{document}!.  The declaration
\verb!\maketitle! goes at the top of the document.
 
\subsection{Miscellaneous}
\settowidth{\MyLen}{\texttt{.pagestyle.empty.} }
\begin{tabular}{@{}p{\the\MyLen}%
                @{}p{\linewidth-\the\MyLen}@{}}
\verb!\pagestyle{empty}!     &   Empty header, footer
                                 and no page numbers. \\
\verb!\tableofcontents!      &   Add a table of contents here. \\
 
\end{tabular}
...

Typst (the ideal typesetting engine)

Typst is a new markup-based typesetting system that is designed to be as powerful as LaTeX while being much easier to learn and use (literally, just take a look at it’s GitHub: github.com/typst/typst). It’s so damn good that it absolutely deserves it’s own post, but for now we’ll leave that for another day. What’s important to note is that it’s so much easier to write virtually anything in Typst than in LaTeX, and it solves almost all of the pain points in the other tools mentioned above, including:

• Incremental compilation, which means that editing content updates in documents/previews instantly (rather than having wait between 1 and many seconds for LaTeX to compile, or for Google Docs/Microsoft Word to stop lagging).
• Easy extensibility: Typst has batteries-included functions for creating tables, drawing lines, setting colours for text and highlighted text (even gradient support is built-in), and so much more. Even the documentation for Typst is amazing, with examples to showcase how to use each of the different functions and how different arguments can affect the output (meanwhile, you pretty much have to learn how to use the intricate features of Google Docs/Microsoft Word by playing around with buttons, and I’m not even sure where you can get the core LaTeX documentation; latex-project.org/help/documentation is so complicated that it’s rather unhelpful, and the Overleaf docs at overleaf.com/learn are nice for beginners but woefully lack the complexity needed for more advanced documents).
  • Similar to LaTeX, Typst supports importing third-party extensions and files built by other people (they’re even importable into your current document in the same way, using a single line with an #import ... statement rather than \usepackage{...}).

Another key characteristic of Typst is that you don’t need any complicated template with tens of lines of boilerplate code to start off writing your cheatsheet so that you have some modicum of structure to follow; you can just start of with something simple (e.g. a single table with a single row and column that fills the entire page) and then build on top of it (e.g. adding more rows and columns that are dynamically sized, with optional adjustments such that some rows/columns can be larger/smaller than others, such that the single table remains filling the entire page with no additional modifications required).

And what’s brilliant about all of this, is that the Typst team have been generous enough to build a fully functional web application (typst.app) to only store your Typst project files, but also edit them with dynamically updating previews and all sorts of bits and bobs to make your Typst writing experience oh-so-sweet (probably my favourite feature is the ability to not only click on some text or box in the output PDF preview and be immediately directed to the line of Typst markup that’s generating that specific output but also, with a line of code selected, jump and zoom in directly to the specific page and portion of the generated PDF that the markup is creating; remember this for later, because it comes in incredibly handy when you’re writing text at a size that’s on par with some smaller species of ants). typst.app is to Typst as overleaf.com is to LaTeX (except the Typst web app is so much better than Overleaf that the folks over at Overleaf actually copied their “new” landing page design to mimic Typst’s, which I’m not too surprised about given just how much better Typst is to use).

It’s awe-inspiring to think of just how powerful Typst is given how easy it is to use as well, making it a fantastic option not just for writing cheatsheets but for replacing LaTeX for a ridiculous number of purposes (as for myself, I now exclusively use Typst to typeset pretty much any PDF requiring math notation, which at the time of writing is pretty much just relegated to homework assignments for calculus/algorithms/data structures/database design courses). But we’re here to figure out how to write a kickass cheatsheet, so let’s get to it.

A reminder

Now, something that I’d like to point out before we dive into the meat of how exactly we can use Typst to make our denser-than-osmium cheatsheet is that this isn’t the only good way of writing a cheatsheet. By all means, you should use whatever you’re comfortable with to type it out, especially if your goal is to write something that’s good enough instead of something that’s incredibly dense (and may also might require a wee bit more squinting than some would prefer). What I’m investigating here is a way pushing the maximum readable word count in a typed-up cheatsheet to the very limit, which is why breaking down what makes one methodology or tool suboptimal for that purpose compared to another is so important.

How to Make Tiny Text Readable

Other things to keep in mind

Convert JPGs to SVGs (which are better than PNGs since you can easily edit them to remove backgrounds or non-essential elements from slides so that you’re left with the most important details that remain readable at small sizes).

Implementing it in Typst

To see the whole project in action, take a look at typst.app/project/rbJ15a29M2OcglqKcAuWkM ². But for an overview of how each individual part of the Typst project works together, continue on reading below.

📁cheatsheet/
├── 📁fonts/
├── 📁images/
├── aidsheet.typ
├── content.typ
└── lazy.typ

First order of business before we get to the task of structuring our content: the page layout.

Programmability is one of Typst’s strong suits, and so it’s good practice to set variables for your cheatsheet’s document formatting properties (e.g. line spacing, image width, font size) because it can enable making minor document-wide changes down the road a whole lot easier. Of course, you’ll notice that I don’t do this all the time in my code below (and that’s largely because I wrote this cheatsheet under the time crunch of studying for 2 exams in 2 days, which meant that many a corner had to be cut to get it done).

#import "content.typ": *
#import "lazy.typ": *
 
#set page(
  paper: "us-letter",
  margin: (
      top: 0.2in, 
      bottom: 0.1in, 
      left: 0.2in, 
      right: 0.2in
  )
)
 
...

#let img_width = 70%
#let font_size = 3.6pt
#let line_spacing = 0.2em
#let main_color = purple.lighten(20%).transparentize(20%)
 
...

Add another couple hundred lines of formatting code (using alias for headers, bolded text, math, highlights, and more), along with a couple thousand lines of actual cheatsheet content, and you find yourself staring at what can only be described as a marvel of modern (text) engineering.