Presto Glossary
This glossary is organized by topic, with entries sorted alphabetically within each group. Each entry includes a one-sentence definition, a concrete example, and cross-references.
Core Concepts
Binary Template
A template distributed as a compiled executable file, rather than source code files. Presto templates are not "copy files into your project" -- they are standalone small programs. You feed content in, and they produce a formatted document.
Example: A resume template written in Go compiles into a 6MB binary file resume-template. Users can use it without installing the Go environment.
See also: Template, Template Protocol, manifest.json
Frontmatter
A metadata section at the very top of a document, wrapped in --- delimiters. It tells the template information like "what is the title of this document, who is the author, what layout to use" -- similar to a recipient address on an envelope.
Example:
---
title: My Resume
author: Zhang San
layout: modern
---
Body content starts here...The template's manifest.json uses the frontmatterSchema field to define which frontmatter fields are required and their types.
See also: manifest.json, Typst
manifest.json
The template's "ID card" -- a JSON configuration file that declares the template's name, version, author, required fonts, and other key information. Both the registry (template registry) and the Presto application read it to understand the template's capabilities.
Example:
{
"name": "resume-zh",
"displayName": "Chinese Resume Template",
"version": "1.0.0",
"author": "Presto-io",
"minPrestoVersion": "0.2.0",
"requiredFonts": [{ "family": "Noto Sans SC" }],
"frontmatterSchema": {
"title": { "type": "string", "required": true }
}
}In Go templates, this file is embedded into the binary via //go:embed manifest.json.
See also: Binary Template, Template Protocol, Frontmatter
Template
A reusable document typesetting program in the Presto ecosystem. It receives the user's Markdown/Typst content and outputs a formatted document (usually PDF). Each template is a standalone binary executable with an embedded manifest describing itself.
Example: presto-resume is a resume template. After the user writes their resume content, the template handles typesetting it into a professional PDF.
See also: Binary Template, manifest.json, Registry
Presto
A desktop application built with Wails that helps users quickly generate high-quality typeset documents through templates. Go handles the backend logic, Svelte 5 handles the frontend interface, and Typst handles the typesetting engine -- the three work together to complete the entire flow from editing to output.
Example: A user selects a resume template in Presto, fills in personal information, previews the typesetting in real time, and exports a PDF with one click.
See also: Wails, Typst, Template
Typst
A modern typesetting language and engine -- think of it as "a simpler LaTeX." Presto uses it as the underlying typesetting engine to render user content into polished PDFs. Its syntax is much more concise than LaTeX, and it compiles much faster.
Example: In Typst, setting heading style only requires #set heading(numbering: "1.1"), while LaTeX requires importing packages and writing extensive configuration.
See also: Presto, Template
Template Ecosystem
Template Protocol
The communication rules between Presto and template binaries. It defines 4 invocation methods, a 30-second timeout limit, and runs in a minimal environment (PATH=/usr/local/bin:/usr/bin:/bin).
| Invocation | Trigger | Purpose |
|---|---|---|
| Convert | Content via stdin, result from stdout | Perform typesetting conversion |
| GetManifest | --manifest flag | Retrieve template identity info |
| GetExample | --example flag | Retrieve example document |
| GetVersion | --version flag | Retrieve template version |
Example: When Presto invokes a template, it actually executes echo "content" | ./resume-template. The template program reads content from stdin, processes it, and writes the PDF byte stream to stdout.
See also: Binary Template, stdin/stdout
Starter Repository
An official template development scaffold that helps you quickly set up a new template project. It comes pre-configured with manifest.json, example files, build scripts, and more -- you only need to focus on writing the typesetting logic.
Example: The starter-go repository contains a complete Go template skeleton with built-in //go:embed manifest.json and //go:embed example.md. Just clone it and start developing your own template.
See also: Binary Template, manifest.json
Trust Level
A graded trust label assigned by the registry to indicate the reliability of a template's source, helping users assess whether a template is safe and trustworthy. There are 4 levels:
| Level | Meaning |
|---|---|
| official | Maintained by the Presto-io organization |
| verified | Built from source via CI, approved through PR review |
| community | Listed in the registry but not verified |
| unrecorded | Not in the registry, manually installed by the user |
Example: If you see a template marked verified in the registry, it means its binary was automatically compiled from public source code -- not a mysterious file uploaded by the author.
See also: Registry
Registry
A centralized platform for publishing and discovering templates -- similar to an "app store" on your phone. Developers publish templates here, and users search for and install templates from here. Each template has a trust level label.
Example: When you run presto install resume-zh, Presto looks up the template named resume-zh in the registry and downloads the binary for your platform.
See also: Trust Level, Template
Development Tools
Claude Code
An AI programming assistant CLI tool from Anthropic that can directly read/write local files and execute commands. The Presto project uses it to assist development, providing project context through CLAUDE.md files.
Example: Type claude in the terminal to start a conversation. It can help you write code, debug, generate tests, and automatically follow project conventions defined in CLAUDE.md.
See also: CLAUDE.md, Context Engineering
CLAUDE.md
An instruction file placed in the project root that tells Claude Code the project's rules, architecture, and important notes. Think of it as a "new employee onboarding handbook" written for the AI assistant.
Example: The Presto-io workspace's CLAUDE.md specifies rules like "commit messages in Chinese," "use uv not pip for Python," and "local architecture is arm64." Claude Code reads and follows these rules every time it starts.
See also: Claude Code, Context Engineering
Context Engineering
The practice of carefully organizing and managing background information provided to AI, enabling it to understand the project more accurately and produce higher-quality results. The core idea is "the right information, at the right time."
Example: Organize architecture docs, coding conventions, and the glossary (the very file you're reading) in fixed locations so AI tools can automatically load this context, avoiding the need to re-explain project background in every conversation.
See also: CLAUDE.md, Claude Code
Wails
A framework for building desktop applications with Go, similar to Electron but lighter -- it uses the system's built-in WebView instead of bundling an entire Chrome browser. Go handles backend logic, and the frontend uses any web framework (Presto chose Svelte 5).
Example: Presto's frontend code is compiled and embedded into the Go binary via //go:embed all:build. The end user receives a single-file application with no need to install Node.js.
See also: Presto
General Appendix (For Beginners)
These are general software development concepts, not specific to Presto, but understanding them helps you read the terms above.
API (Application Programming Interface)
A set of rules for programs to "talk" to each other. Like a restaurant menu -- you don't need to know how the kitchen prepares the food; you just order from the menu, and the kitchen delivers.
Example: Presto communicates with templates through the Template Protocol (a type of API): content goes in, PDF comes out. Both sides agree on the data format and that's it.
See also: Template Protocol
CLI (Command Line Interface)
A command-line interface where you operate programs by typing text commands in a terminal, rather than clicking graphical buttons.
Example: presto install resume-zh is a CLI command meaning "install the template named resume-zh."
See also: stdin/stdout
JSON (JavaScript Object Notation)
A lightweight data format that uses curly braces and key-value pairs to organize information, easily readable by both humans and machines.
Example: manifest.json is a JSON file: {"name": "resume-zh", "version": "1.0.0"}.
See also: manifest.json
stdin/stdout (Standard Input/Output)
A program's "standard input" and "standard output" -- the default channels for receiving and sending data. Think of them as the program's "ears" (stdin, listening to what you say) and "mouth" (stdout, speaking the results).
Example: In the Template Protocol's Convert invocation, user content is passed to the template program via stdin, and the template sends the generated Typst code back via stdout. In the terminal, you connect them with the pipe character |: echo "content" | ./template.
See also: Template Protocol, CLI
Token
Has different meanings in different contexts, but the core idea is always "a short string with a specific purpose." In authentication, it's a "pass"; in AI contexts, it's "the smallest unit of text processing."
Example: When publishing a template to the registry, you need to provide an API Token (a string like ghp_xxxx) to prove your identity -- like swiping an access card to enter a gated community.
See also: API, Registry
Package Manager
A tool that automatically downloads, installs, and updates software dependencies, saving you the hassle of manually finding files and configuring paths.
Example: Go's package manager is go mod, Node.js uses npm, and Python has pip and uv. Presto's registry is essentially a "package manager" for templates.
See also: Registry
Environment Variable
A system-level global configuration item that programs can read at runtime. Think of it as a sticky note on the fridge -- all family members (programs) can see it.
Example: The Template Protocol specifies that templates run in a minimal environment with only PATH=/usr/local/bin:/usr/bin:/bin as an environment variable, ensuring templates cannot depend on special configurations on the user's machine.
See also: Template Protocol
Alias Index
The following are common aliases or easily confused spellings, pointing to their corresponding main entries:
- registry -- see Registry
- manifest -- see manifest.json
- protocol -- see Template Protocol
- trust level -- see Trust Level
- starter -- see Starter Repository
- standard input/output -- see stdin/stdout
- command line -- see CLI
- context management -- see Context Engineering