# Exporting & Formats
Press **Export** on a tool's **Export | Save as** pill, pick a format from the menu beside the file name, then press **Download**. An ordinary download is made on your device. Organisation approval and delivery options are covered below.
For most jobs one of three formats is right:
| For | Choose | Because |
|---|---|---|
| A screen, a message or a slide | **PNG** | Every app opens it, and it keeps a transparent background when the tool offers one |
| A finished page, or anything printed | **PDF** | A true page size that prints as it looks; **Print PDF**, where a tool offers it, is the CMYK version for a press |
| Artwork that must stay sharp at any size | **SVG** | Vector shapes, crisp from a badge to a banner |
**Check: Check the file at the size it will be used**
Before you send it, open it on the screen it was made for, or print it at its real size.
The rest of this page covers every format, size and option.
## How export works
The preview *is* the file. When you export, the host renders that canvas to the format you chose and hands you a download (or puts it on your clipboard). The picker hides any format your browser can't produce (see [Video](#video)).
Three paths produce a file. Most tools **render the canvas** to the chosen format. Text and data formats (HTML, MD, TXT, JSON, CSV, ICS, VCF) are instead **generated from the tool's content**, not rasterised from the picture. And privacy utilities (e.g. *Strip Hidden Data*) use a third path: the file *you* pick is transformed byte-for-byte on device and handed straight back - no canvas, no watermark and no provenance metadata added, because it's already your own file.
The actions in the Export panel:
- **Download** - save the file (the primary action). If you cannot find it afterwards, see [Find a file you downloaded](/info/create/find-your-work.html#find-a-file-you-downloaded).
- **Copy** - put the image on your clipboard to paste straight into Slack, email, a doc. Where a browser can't copy images, it downloads instead and tells you.
- **Save** - keep the current design in Projects in one click, without asking where; it never downloads a file. **Save as**, beside **Export**, asks where (see [Saving and continuing](/info/create/using.html#saving-continuing)).
- **Share** - opens the **Share dialog**: a copyable link that reproduces the design, on-visit toggles (fullscreen, export panel, download- or copy-on-open) and an optional **Shortest link** that packs the whole state into a compact token (see [URL Mode](/info/build/url-mode.html)).
(A tool's author picks which of these appear; the default set is Copy, Download and Save.)
Share opens over the tool, with the link already built and the on-visit toggles under it.
**Approvals and delivery with lolly.work (optional)**
An [organisation using lolly.work](/info/start/organisation.html) can govern available formats and export settings. Where approval is required, the app can show **Request approval** in place of **Download**. Follow the policy shown by your instance.
The service also supports governed delivery to configured S3, WebDAV and HTTP destinations, with approval steps where configured, delivery receipts and an audit record. Submitting a file for that workflow sends it to the organisation's service; ordinary local downloads remain on-device. Personal Send destinations and governed organisation delivery have separate configuration.
For operators, see the [delivery guide](/info/manage/organisation-delivery.html). For queued server renders and batches, see [CLI batch and automation](/info/build/cli-automation.html#organisation-jobs-with-lolly-work).
### Rendering many at once
A single export is one file, but you can render **many** in one pass - each delivered as one `.zip`:
- **Projects → Render folder** exports every saved session in a folder (and its sub-folders) as one nested zip; **Render selection** does the same for any multi-selection; a single saved session renders straight to its own file. No Batch/Pro needed - see [Using Lolly → Projects](/info/create/using.html).
- **Batch (Pro)** renders a grid of input sets - every variant of one template at once.
A saved session can also be re-shared as a tool link from Projects (it reconstructs the tool URL from the saved inputs), so a link reopens it with the exact same settings.
## Choosing a format
The file name and the format menu sit together as one `name.format` pair, below **Download**.
| You want… | Use | Why |
|---|---|---|
| Crisp logos / artwork that scales | **SVG** | Vector - infinitely scalable, tiny, editable; an effect the vector export cannot draw is embedded as an image |
| Vector for Office / Windows apps | **EMF** | Pastes as editable vector into PowerPoint / Word; text stays live and editable, and Google Drive opens it in Google Drawings for Slides |
| Vector for print / design apps | **EPS**, or **EPS (CMYK)** | PostScript vector for Illustrator / press workflows |
| Vector for cutting / CAD machines | **DXF** | Laser cutters, vinyl plotters, CNC - outline paths in millimetres |
| An editable slide deck | **PowerPoint** (PPTX) | Native editable text + shapes, with images and vectors kept extractable |
| A portable training course | **Export course** | Review project content and build a versioned Website, SCORM or experimental xAPI package |
| An editable text document | **Word** (DOCX) or **OpenDocument** (ODT) | Real paragraphs and headings a word processor can keep editing (Doc Studio) |
| A photo or general-purpose image | **PNG** (lossless) or **JPG** (smaller) | Universal raster |
| Smaller modern images | **WebP** / **AVIF** | Better compression, alpha |
| Print | **PDF**, or **Print PDF** (CMYK) | True page size; CMYK for press |
| Print raster for a press | **Print TIFF** (CMYK) | DeviceCMYK pixels for a RIP |
| Animated for the web | **GIF** | Works everywhere, larger files |
| Animated with full colour + real alpha | **APNG** | Animated PNG - no palette limit, true transparency |
| Animated, smallest file | **Animated WebP** | Full colour + alpha, better-compressed than GIF or APNG |
| Animated vector that scales | **Animated SVG** | Self-contained; loops in a browser or ``, no codec, any size |
| Video for social / sharing | **MP4** or **WebM** | Best quality-per-byte (see below) |
| Rich text / email signature | **HTML** | Pastes formatted into mail clients |
| Plain content | **MD** / **TXT** | Text only |
| A calendar event | **ICS** | Imports into any calendar app |
| A contact card | **VCF** | Imports into Contacts / address books |
| Structured data to re-import | **JSON** / **CSV** | Round-trips the tool's content |
| A favicon | **ICO** | Multi-size site icon (**ZIP** bundles several formats) |
The first row is the common case. A wordmark set in your brand face exports as SVG, where every letter is an outlined path rather than a pixel, so it stays crisp at a business-card size and at a building-wrap size from the same file.
## Size & print units
By default exports use the tool's native pixel size. Where a tool exposes **dimensions**, you can set width × height and a **unit**:
- **px** (default) - exact pixels.
- **mm · cm · in · pt · pc** - physical/print sizes. With a physical unit you also set **DPI** (default **300** for print); the engine converts correctly per format - **PDF** becomes a true page at that size, **raster** renders at the right pixel count for the DPI (and embeds the resolution), **SVG** keeps the physical unit with a px viewBox.
To get a higher-resolution raster, enter a larger width/height, or choose a physical unit and raise the DPI (pixels = size × DPI). There's no one-click scale toggle.
Example: width `210`, height `297`, unit `mm` → an A4 page.
## Stills from a timed composition
A **timed composition** - a [Sequence](/info/create/using.html#timeline-sequence) timeline in Design, or any timeline-driven artboard - is a moving thing, so a still export has to answer "which moment?". The rule is what you'd expect: **the frame at the playhead**. Park the playhead where you want the picture and export; what you see is what comes out.
When you want more than one moment, the **Frames** field appears beside the output size (only for a timed composition, and only for a still format - PNG, JPG, WebP, SVG or PDF). Leave it at `1` for the playhead frame. Raise it and you get that many stills sampled at equal intervals across the whole sequence:
- **Raster and SVG** come back as one **zip** - `-01.png`, `-02.png` and so on.
- **PDF** comes back as a **single document of that many pages**.
Useful for a storyboard, a thumbnail sheet, a contact sheet for review or a social carousel cut straight from a video edit.
Sampling is taken at the **midpoint** of each interval rather than at the edges, because the first instant of a sequence is often an enter transition that hasn't faded in yet and the last is the state after every clip has ended - endpoint sampling would spend two of your frames on near-blank ones. The count is capped at **64** (a contact sheet is for a human to read), and anything nonsensical typed into the field falls back to `1` rather than failing the export. Each frame is an ordinary still, so Content Credentials, the imprint, physical units and DPI all behave exactly as they do for a single export.
The **Frames** field is the way to get a sheet today. The engine reserves a matching `cuts` URL param, but no shell reads it from a link yet, so a shared link always reopens on the playhead frame - see [URL Mode](/info/build/url-parameters.html#contact-sheets-cuts).
## Multi-page PDF
Some tools build a **multi-page PDF document** instead of a single artwork - a cover, content that flows onto as many pages as it needs and a back page, all in one file (see the *Booklet* tool). Each page is a **true PDF page** sized to that page's box, so readers and printers get real pages, not one tall image.
- **Pages from content.** Add blocks of text and images; new pages are created automatically as the blocks fill, and you can force any block to start a new page.
- **Real page sizes.** Choose A4, US Letter or A5 (portrait - the two-column layout is built for it) - every page, and the exported PDF, renders at exactly that size.
Multi-page PDFs are RGB documents and don't carry crop/bleed marks - those belong to the single-page **Print PDF** path above. They do carry the same **PDF/X-4 metadata** as every PDF export (page boxes, XMP, document ID, an sRGB output intent with embedded profile), and they offer **Content Credentials** (below) - on the *Booklet* tool the option comes pre-selected.
## Making many things at once
Lolly has three distinct ways to work at volume, and they solve different jobs - batch editing is a first-class capability of the platform, not something each tool reinvents:
- **One design × a table of rows → one multi-page document.** Tools with a `table` input (like *Battlecards*) turn every row into a page automatically - paste a table from your spreadsheet, get a deck-sized PDF. Your real batch editor stays the spreadsheet: fix ten rows there, paste again. The tool itself never manages pages.
- **One design × a data file → many separate files.** The `/pro` batch grid takes a CSV and renders one export *per row* - name badges, certificates, one file each.
- **Many different assets, edited side by side.** *Multi-edit* opens several saved sessions in one view for coordinated touch-ups across distinct designs.
Rule of thumb: rows of the same design that belong in **one document** → a table-driven tool; rows that must ship as **separate files** → `/pro`; **different designs** that need the same tweak → multi-edit. (A planned "combine media" render option will bridge the first two - concatenating same-format exports into one PDF, one video or a proofing contact sheet.)
## PowerPoint (PPTX)
Design, Markdown Slides, Booklet, Doc Studio, Chart and Diagrams can export a **PowerPoint deck** - one slide per page. The point isn't a pixel-perfect screenshot; it's to hand a colleague a deck they can actually **edit and take assets out of**. So each page is decomposed into native objects:
- **Text** becomes real, **editable PowerPoint text boxes** - with the font size, colour, weight, italics and alignment from the layout - so you can fix a typo or restyle in PowerPoint.
- **Vectors** (logos, icons, the SUSE mark) are embedded as **real SVG pictures** - they stay crisp at any size, and PowerPoint can even *Convert to Shape* on them.
- **Images** come through at their native resolution as their own extractable pictures (a `cover`-cropped hero keeps the full image behind the crop, so you can re-frame it), with any on-image treatment (filters, blends) baked in faithfully.
- **Backgrounds, borders and rules** become real rectangle/line shapes.
Layout is approximate by design - the goal is faithful, reusable **content**, not a locked screenshot. Anything the walker can't express natively (a complex filtered or masked region) is embedded as a picture so nothing is lost. A deck has a single slide size, taken from the first page.
PowerPoint is also a way **in**. Drop a `.pptx` on any upload surface and pick the slides you want - each becomes an asset to place, grade or build on. **Markdown Slides** writes a fresh deck from Markdown (and hands out a branded `.pptx` template), and the **Rebrand** utility re-themes an existing deck in place - theme palette, hardcoded colours and fonts - without touching its charts, SmartArt or animations, handing back a `.pptx`. See [Import a design → Decks and documents](/info/create/design-import.html#decks-and-documents).
## Penpot
Any tool that can export SVG can also export a **Penpot file** (`.penpot`) - the document, ready to keep editing in Penpot rather than just to look at.
- From **Design**, each frame becomes a Penpot **board**, every box on it carries over as its own editable shape - rectangle, ellipse, text, image or path - and the result arrives as a reusable **component** in the Assets panel, ready to drag out again.
- From a tool whose render is **plain geometry** - the vector tools such as QR Code, Street Map, Wordmark and Palette Lab - every path, rectangle, text run and gradient carries over the same way, as its own editable shape.
- From a tool that lays its render out in **HTML**, the **text stays text** - one editable Penpot text object per line, not an outline and not a flat picture. A piece of artwork Penpot has no construct for - a complex illustration, a live canvas - rides along on its own as an image, so it never flattens the text and boxes around it. A whole layout Penpot cannot separate faithfully can still come across as one picture at full fidelity, so nothing is ever dropped.
- A colour or font a shape **inherits from a brand token** stays **linked** to that token in the file: change the token in Penpot's Tokens panel and every shape that inherits it re-paints together, while a one-off literal colour stays exactly where it is. The brand's colours and typographies also land in the **Assets** panel and its full design-token set in the **Tokens** panel - the same DTCG token set Lolly's own palette uses. Penpot keeps its own copy from there: an edit made in its Tokens panel comes back into the brand through [Brand Studio's import](/info/create/design-import.html), not on its own.
| What you made | In Penpot |
|---|---|
| Text | Editable text objects - fix a typo or restyle |
| Shapes, paths, gradients, images | Their own editable vector shapes |
| A colour or font from a brand token | A live token link - edit the token, every shape that inherits it follows |
| The whole design | A reusable component in the Assets panel |
| A complex illustration or live canvas | Embedded on its own as an image, the editable content around it untouched |
To open it, start Penpot, pick a project and choose **Import**. Signed in to Penpot from the export panel, **Send to Penpot** does that step for you - pick a project there and the file goes straight into it.
## SCORM (course packages)
Choose **Export course** from a supported tool, a project folder or a selection. In Design, choosing **SCORM (LMS)** and Download also opens this course workflow. Lolly saves the creation, lets you review the course content and order, then opens the module and its export dialog.
- Choose the available rendition for each source: still pages, motion as video, audio or a downloadable resource. Add native lesson text and reading alternatives in the module.
- Preview the learner player and review descriptions and captions. Motion is included as video, including silent animation. Export a finished recording first when a tool cannot recreate it from saved inputs.
- Select Website, SCORM 1.2, SCORM 2004 4th Edition, or an experimental xAPI target. Check the actual content and ZIP size, then save and download the checked version.
- Completion requires acknowledging every required lesson and selecting Finish. The website player stores progress in the browser; an LMS package connects to its receiving LMS.
The package includes its finished content and does not require a Lolly account. Extract a Website ZIP onto an HTTP(S) host; import an LMS ZIP without changing its contents. Test the intended destination before distributing the course.
For a course assembled from several saved creations, imported media and resources, use [Create a training course](/info/create/training-creators.html). The learning module has its own ordered outline, explicit lesson acknowledgements, learner preview and versioned package history. Its CLI path can package media that you have already exported.
## DXF (cut files)
Vector tools (Brand Lockup, QR Code, Street Map, Wayfinding Signage, Pose Geeko, the logo lockups, Diagram Builder) can export **DXF** - the AutoCAD R12 interchange format that laser cutters, vinyl plotters and CNC/CAD software read. Geometry is written as outline **paths in millimetres** (curves flattened to a fine tolerance), text is outlined to paths and colour maps to the nearest AutoCAD Color Index (which typically drives the tool/operation on a cutter). DXF is line-art only - a photographic or filtered region has no cut-path form and is dropped (Lolly warns), so use SVG/PDF when you need to keep raster content.
Street Map is the clearest case: the whole design is already strokes, so every road and canal becomes a cut path with nothing to drop.
::: showcase
Scroll, and the camera pulls back through the actual geometry: seven paths, no pixels anywhere, every stroke hairline-crisp at any zoom. That is the same file a cutter reads.
:::
## Animated SVG
Motion tools (Animated Ad, Lottie Ad) can export **Animated SVG** - a self-contained, *vector* animation. Unlike GIF/APNG/WebP (which sample each frame to pixels), an animated SVG stacks vector snapshots with embedded CSS keyframes, so it **scales to any size with no codec and no external runtime** - it loops in a browser tab or an ``. Text stays outlined so it renders anywhere. It shares the animated formats' **Duration** / frame-rate controls, and (being heavier per frame than a bitmap) uses a lower default frame rate.
## Transparency
Tools that support it offer a **transparent background** toggle (e.g. *No BG*). Transparency is preserved by PNG, WebP, AVIF, SVG (still and animated), APNG and Animated WebP. JPG and PDF are always opaque, and TIFF flattens onto white (onto black on the HDR path - see below).
## Colour spaces
Two different questions, worth keeping apart: which colour spaces Lolly can **read and think in**, and which ones it **writes**.
**Reading.** Wherever a colour is written - a tool's stylesheet, an imported SVG's paint, a design token's value, a shadow or gradient inside a CSS shorthand - Lolly reads the full **CSS Color 4** vocabulary: `#hex`, `rgb()`, `hsl()`, `hwb()`, `lab()`, `lch()`, `oklab()`, `oklch()`, the CSS named colours and `color()` in the predefined spaces - `srgb`, `srgb-linear`, `display-p3`, `a98-rgb`, `prophoto-rgb`, `rec2020`, `xyz-d50`, `xyz-d65` - including components written as the `none` keyword. One parser does this for the whole platform, so the browser and every export walker agree on what a colour string means.
That matters more than it sounds, because a browser resolves modern CSS into modern CSS. Write `color-mix(in oklab, …)` and Chrome computes `oklab(…)`; use a brand token stored as `oklch()` and that's the literal value the export walker sees. Colours in those forms are read correctly rather than dropped - which is what a walker that only understood `rgb()` did, exporting brand-coloured text as black, losing tinted panels and table rules and reading `oklch(0.7 0.1 200) 0px 2px 4px` as a shadow offset of 0.7 by 0.1.
**Thinking.** Colour maths happens perceptually rather than in raw channels. Palette derivation, ramps, harmonies and contrast run in **OKLCH/OKLab**, and an out-of-gamut colour is brought into range by CSS Color 4's own gamut-mapping algorithm - chroma reduction with a perceptual-distance check - rather than by clipping channels, so a vivid colour settles on the nearest colour you'd actually accept instead of a flattened one. Gradients interpolate in a space you pick (OKLab by default, or `oklch`, `lab`, `lch`, `srgb`, `srgb-linear`, `hsl`, with a hue-travel direction for the polar ones), and mixing is **premultiplied**, so a fade to transparent stays the right colour instead of darkening toward black on the way. One interpolator serves both the preview and the export walkers - which is what stopped a conic gradient from being blended one way on screen and another in the exported file.
**Writing.** The output is deliberately narrower than the input, because a file has to be readable by whatever opens it, and a space is only ever *declared* on output when the numbers were really converted into it. Screen and web formats are written as **sRGB** and tagged as such; the print formats are written as **CMYK** against a named press condition (below); and the HDR path is **Rec.2100 PQ** (above). A wide-gamut colour that reaches an export is mapped into sRGB rather than mislabelled - carrying `color(display-p3 …)` through into a vector file is a planned extension, not something today's exports claim to do. A gradient authored in OKLab is *baked* to plain sRGB stops on the way out, with extra stops inserted only where sRGB would visibly diverge from the perceptual curve, because an SVG `` and a PDF axial shading have no interpolation-space setting to carry the intent. One authored value, three renderers, no drift.
## Colour profiles
So colours reproduce faithfully in colour-managed apps (print shops, Photoshop, browsers), exports are **tagged with a colour profile**:
- **PNG / JPG** carry an embedded **sRGB** ICC profile - the colour space the preview is actually rendered in - so nothing is left to guess. (Tagging only; the pixels aren't re-encoded.)
- **Print PDF (CMYK)** declares a target **press condition** in its *OutputIntent* (default *Coated FOGRA39*), telling a RIP/print shop how its CMYK inks are meant to be read. Brand swatches with measured ink values are converted exactly; other colours use a standard device conversion. That declaration is a *name*: no CMYK profile ships with Lolly, and PDF/X-4 wants the profile embedded, so a named condition writes the output intent without claiming PDF/X-4 conformance. Load a CMYK profile of your own and choose its **Embed** row in the Colour profile control and it is embedded as the file's *DestOutputProfile* - at which point the PDF can genuinely be PDF/X-4, and claims it whenever the rest of the file allows. Three things withhold the claim while keeping the output intent (a RIP still wants that): RGB artwork the CMYK pass couldn't convert, the `prov` proof-margin credit text (drawn in a standard font that isn't embedded, and X-4 makes no exception for those) and a **Strong** password, since X-4 forbids encryption. The condition it declares is then read off that profile: a registered name where the profile proves one, `Custom` under the profile's own name where it does not, so the file can never name one press condition while carrying another's measurements.
- **Print TIFF (CMYK)** writes untagged **DeviceCMYK** pixels and records the same press condition as provenance in its TIFF metadata (*ImageDescription*) rather than embedding a profile. The same Colour-profile control drives both CMYK formats - a TIFF cannot embed a press profile at all, so an **Embed** row records that profile's own name there and nothing more.
- **TIFF (RGB)** is the plain, uncompressed sRGB sibling - a lossless raster at the chosen DPI for archival or an editor round-trip, with provenance recorded in the same TIFF metadata. Any transparency is flattened onto white (this profile carries no alpha). Like the CMYK TIFF it's desktop-only, since browsers can't preview a TIFF and mobile downloads dead-end.
- **SVG**, **EMF**, **EPS** and **DXF** are resolution- and profile-independent vectors with no embedded profile - SVG's colours are plain sRGB, EMF's and EPS's are device RGB (and **EPS (CMYK)** writes naive DeviceCMYK) and **DXF** carries the nearest AutoCAD Color Index. (SVG, EPS and DXF, like PDF, outline any text to vector paths, so the result renders even where the font isn't installed. EMF instead keeps text LIVE by default - real metafile text records that stay selectable and editable in Office and Google Slides, falling back to outlines only for runs the format cannot express; the export panel's "Outline fonts" option forces paths everywhere.) **SVG** also reproduces CSS `box-shadow` from the HTML - each outer shadow is painted behind the box, offset/spread and Gaussian-blurred to match the browser, and inset shadows are painted inside it the same way.
This is automatic - no setting to fiddle with. Thumbnails and previews skip the tag to stay small. One profile *is* a choice, because it changes the pixels rather than just labelling them - see **HDR** below.
## HDR (bright colours)
Ordinary exports are sRGB: white is white, and a saturated brand colour is as bright as the screen's normal white. On an HDR-capable display there's a lot of headroom above that, and the **HDR** card in the export panel uses it - your brand colours and white text are boosted toward peak brightness so they genuinely *glow*, while the dark areas stay dark and give the glow its contrast.
- **Formats.** The raster formats with a place to carry the signal: **PNG**, **JPG**, **AVIF** and **TIFF**. (Not WebP - it's 8-bit with no working HDR decode path, so a PQ WebP would simply look dark. Vectors and PDF have no HDR model at all.)
- **Off by default**, unlike colour tagging - it changes the pixels, so it's opt-in. Tick the card, or pass `hdr=1` in a share link.
- **What's actually written.** The pixels are re-encoded to **Rec.2100 PQ** - BT.2020 primaries with the SMPTE ST 2084 (PQ) transfer curve - and the container carries the matching signal so a colour-managed app knows to read them that way: a generated **ICC v4 profile with a `cicp` tag** (JPG, TIFF), a **`cICP` chunk** (PNG) or a rewritten `colr` box (AVIF). The boost is gated on **perceptual (OKLab) lightness**, so mid-and-above colours punch to peak and dark ones are calmed rather than blown out, and it's hue-preserving - a brand green gets brighter, not minty.
- **The dials.** Four, revealed when the card is on: **White** (the peak-brightness ceiling, 400–2000 nits), **Reach** (how far down the tones the glow spreads), **Dark lift** (how much the darks brighten - `0` keeps them dark) and **Focus** (how much colour richness the boost keeps). They ride in the same param as a compact tuned value - `hdr=1600-60-0-50` is White 1600, Reach 60, Dark lift 0, Focus 50 - so a tuned look is reproducible from the link.
- **Where you'll see it.** Colour-managed viewers on an HDR display: Preview / Quick Look / Safari on Apple devices, Chrome on an HDR monitor. On an ordinary SDR screen the file still shows as a normal image.
- **Know before you ship it.** Many platforms **re-encode** what you upload and strip the HDR signal - social networks, messaging apps, some CMSes - which can leave the image looking dark or washed out. Use HDR where you control the destination (a site you build, a video wall, a deck on a bright panel), not as a default for everything.
- **Transparency.** PNG and AVIF keep their alpha; JPG is opaque as always. The **TIFF** path flattens onto **black**, not the SDR path's white - in PQ, white is the 10,000-nit code, so flattening onto it would ring every edge with a blinding halo.
- **The same bytes from the terminal.** `--hdr=1` with `--export=png` or `--export=jpg` writes the 16-bit Rec.2100 PQ PNG and the ISO 21496-1 gain-map JPEG on the [CLI](/info/build/cli.html) too, out of the same engine encoders rather than a browser - so an `