URL Mode

Every tool's state is expressible as URL parameters. This means any combination of inputs and export settings can be bookmarked, linked, embedded or piped through automation - with no login, no cookies and no server state.

The CLI uses the same parameter names and the same conversion logic. A URL you build for the web shell runs unchanged as --flag=value arguments on the CLI.

URL structure

https://your-host/t/{toolId}?{param}={value}&{param}={value}

That path form is canonical - it's what the address bar shows once a tool has loaded, and what Share and the embed URLs build on. The older hash form, #/tool/{toolId}?…, still routes and is what a freshly-opened link often arrives as, so the two are interchangeable in everything below.

Examples:

/#/tool/qr-code?url=https://suse.com&color=%230c322c
/#/tool/qr-code?url=https://suse.com&format=png&export&filename=my-qr
/#/tool/quotes?quote=Open+source+wins.&name=Andy&format=svg&export&full

The first of those opens the QR tool with the address and the dark green already applied, no clicks in between.

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file1 path~1.4k nodes12 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file1 path~1.4k nodes12 KBTry it in the app

Clean URL redirect

If a tool is deployed at a dedicated domain or path, you can use a plain query string and the shell redirects to hash form automatically:

https://qr.brand.example.com/?url=https://suse.com
  → redirects to → /#/tool/qr-code?url=https://suse.com

Setting tool inputs

Every input defined in a tool's manifest can be set as a URL parameter using its id as the key.

String, text, longtext, url

Pass the value directly. URL-encode spaces and special characters.

?quote=The+best+way+to+predict+the+future+is+to+create+it.
?name=Andy+Fitzsimon
?url=https%3A%2F%2Fwww.suse.com

The Wordmark tool is nothing but text params, so a link is the whole brief: /#/tool/wordmark?text=Ship it&weight=800&tracking=-12&size=200.

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file1 path125 nodes5 groups4 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file1 path125 nodes5 groups4 KB

Select

Pass the option value (not the label).

?theme=dark
?ecl=H

A one-word change swaps the whole render: ?theme=dark repaints a design from the URL alone.

Number

?size=800
?padding=4

A number can also set how much of a thing gets made. Colour Palette builds one ramp cell per step, so /#/tool/color-palette?steps=11 returns a wider sheet than the default seven.

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file9 groups23 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file9 groups23 KB

Boolean

1 or true for on, 0 or false for off.

?join=1
?showBorder=false

One flag can add a whole layer of information: /#/tool/chart?showValues=1 prints the number on every bar.

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file26 paths~1.6k nodes5 groups28 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file26 paths~1.6k nodes5 groups28 KB

Color

Pass a hex value (URL-encode the #).

?color=%230c322c
?background=%23ffffff

Colour params stack. Mesh Gradient takes one per stop, so three hex values in a link are three fields of colour in the render.

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file9 groups5 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file9 groups6 KBTry it in the app

Asset

Pass the asset's library ID - the runtime resolves it to the full asset object at render time.

?logo=suse/logo/primary
?headshot=team/andy-fitzsimon

To discover asset IDs, open the asset picker in the tool UI and inspect the value shown when an asset is selected. An audio ID works the same way as an image: Audiogram decodes whichever track the link names and draws its real waveform.

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file3 paths~1.1k nodes10 groups1 image109 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file3 paths~1.1k nodes10 groups1 image111 KB

An asset value can also be another tool's render. When a user pastes a Lolly tool link into the asset picker (a share link or an embed URL), the chosen value's "id" is the canonical embed URL of that render, so it round-trips through the URL exactly like a library id - just longer:

?hero=https%3A%2F%2Flolly.tools%2Ftool%2Fqr-code.svg%3Furl%3Dhttps%3A%2F%2Fsuse.com%26w%3D600%26h%3D600

On load the runtime re-renders it via host.compose.renderUrl instead of looking it up in the catalog. This is how one tool's output (a QR code, a filtered hero graphic) flows into another tool's image slot through a plain shareable link. See Tool composition and the authoring guide.

User-uploaded images are device-local and not URL-shareable. Images a user adds from their own device (AssetRef.source: "user", ids like user/upload/…) live only in that device's local storage. There is no shareable id to encode, so they are deliberately omitted from the URL - a link that referenced one would not resolve on another device. To share a layout that uses a personal image, the recipient must select their own. (Avoiding this would require cloud hosting, which the platform intentionally does not do.)

Blocks

Blocks inputs are repeating groups of fields (e.g. a list of team members, each with a name and city). Pass the value as a JSON array of objects, URL-encoded.

?people=[{"name":"Andy","city":"Nuremberg"},{"name":"Lisa","city":"Sydney"}]

Each object's keys must match the field ids defined in the tool's manifest. Fields can be omitted - missing fields are treated as empty strings. Chart Creator's data input is a blocks list of label, value and colour, so a whole dataset travels in the link:

signed by Lollyvector SVG2026-08-10Semak sendiriGet the signed file8 paths390 nodes1 group13 KBsigned by Lollyvector SVG2026-08-10Semak sendiriGet the signed file8 paths390 nodes1 group13 KB

CLI:

lolly meeting-planner --people='[{"name":"Andy","city":"Nuremberg"},{"name":"Lisa","city":"Sydney"}]'

The URL updates automatically as block items are added, removed or edited in the UI - copy from the address bar to get a shareable link with all entries included.

Blocks with a JSON representation larger than 8 KB are not written to the URL to avoid exceeding browser URL limits. In that case, use a saved state slot for sharing.

Vector

A vector input is a fixed group of numbers edited as one control (e.g. a zoom + x/y offset). It has no single-param form - pass each field as a flat dotted param <inputId>.<fieldId>:

?imageFraming.zoom=200&imageFraming.x=30&imageFraming.y=70

One readable value per param. Used by tools such as pose-geeko, chart-creator, filter, dynamic-layout and quotes. Mesh Gradient parks each colour stop with one, so adding ?pos1.x=8&pos1.y=8&pos2.x=92&pos2.y=12&pos3.x=50&pos3.y=94 to the gradient above drives its three blooms out to the edges:

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file9 groups5 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file9 groups6 KB

File

A file input (the user's own file, processed in memory) is never put in a URL - its bytes live only on the device, so there is nothing shareable to encode. On the CLI a file param is a filesystem path, loaded into memory before rendering:

lolly strip-data --source=./photo.jpg --format=jpg --output=clean.jpg

In the web shell a file input can't be pre-filled from a URL; a link that referenced one resolves as blank, and the recipient picks their own file.

Table

A table input (a user-defined grid: column headings + rows, e.g. battlecards) is always one compact param - the header row first, then one ~-separated segment per data row, cells ,-separated and percent-escaped so prose cells full of commas survive:

?t=Pain,Summary,Strategy~Assurance,Is%20it%20open%3F,Table%20stakes%2C%20compete%20with%20why

A JSON form ({"columns":[…],"rows":[…]}) also parses. Long tables ride the packed z link like any other big state. On the CLI the same value works inline, or --<inputId>-data=table.csv fills the input from a CSV / TSV / Markdown-table file (first row = headings):

lolly battlecards --data-data=./cards.csv --output=deck.pdf

Keyframe tracks

kf is not an input type - it is a sub-field of a blocks input (one per box), and like every other sub-field it rides the block's own encoding described under Compact encoding below.

A box's kf field packs a whole animation track (position, size, scale, rotation, opacity, blur, depth) into one compact string, charset A-Za-z0-9._()- only. Keyframes are separated by ; inside a keyframe, tokens are separated by _. The first token is always t<ms> (the keyframe's local box time, unscaled). The remaining tokens are channel values and an optional ease token:

• Channels: x12.5, y-40, s1.2, r15, z140, o0.8, b2.5, the size pair w1280 / h720, the tilt pair rx-8 / ry20, plus camera-only f/a/p. Tilt is a camera channel: rx pitches the camera and ry yaws it, in degrees, about the point it is already looking at - so the centre of the frame stays put and the artwork turns around it. Negative rx pitches the camera down over the surface, which puts the near edge of a layer at the bottom of the frame and sends the far edge toward a horizon at the top. Any non-zero angle makes the projection a perspective one rather than a flat scale, and a motion export of a tilted scene is captured off the live page frame by frame; a tilted scene that also holds a video clip refuses to export as motion, with a notice saying so.
• Absolute vs relative. x/y/s/r/o/b are offsets and multipliers over what the box already had, so a track composes with the authored pose and with any enter/exit transition. z, w and h are absolute and replace the box's own field for the segment they are keyed on. Size is the channel to reach for when the content must reflow - a keyed w re-lays-out the box, so text rewraps and a border stays one pixel wide, where s scales the finished picture instead.
• Ease: one of the eight presets el/ei/eo/eio/ev/ea/es/ek, the hold eh or a paren-delimited bezier eb(0.32)(0)(0.67)(1). Absent means eio (ease-in-out), so an uneased segment is smoothed, never linear.
• Longest name wins. A token is read as the longest channel name whose remainder parses as a number: rx-8 is channel rx at -8, never channel r followed by junk. A token that matches no channel or ease form that way is skipped rather than rejected, so a hand-edited link degrades gracefully instead of failing the render.

t0_z0_b4*t1500_eo_z140_b0*t4000_eh_z140_x-60

kf is written by the app, never hand-typed in practice, and hooks always re-parse and re-serialise it rather than passing the raw field through - so an unparseable or malicious value simply emits no track.

Compact encoding (opt-in)

Tools can opt into a shorter URL form, which the web shell emits when you copy a share link (the live address bar keeps the readable long form). Both the long forms above and the compact forms below parse, so either kind of link works:

• urlKey aliases - an input (or block field) can declare a short key, e.g. textColor → tc, so ?tc=ff0000 sets it.
• Colors without # - a 6-char hex is stored bare (?color=0c322c), restored to #0c322c on parse.
• Tilde-delimited block arrays - instead of JSON, blocks serialise as field,field,field~field,field,field (one ~-separated group per item; values URL-encoded, colors #-less).
• Omitted defaults - values equal to the input's default are dropped from the URL entirely.

chart-creator is a live tool that uses urlKey, so a link copied via its Copy URL / share button won't match the long-form examples in this doc - that's expected. d3 uses them too: ?ct=radar&pl=cool&t=Short keys&lg=0 is chart type, palette, heading and legend in twelve characters of query.

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file11 paths808 nodes2 groups15 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file11 paths808 nodes2 groups15 KB

Reserved parameters

These keys are never treated as tool inputs. They control shell-level behaviour.

The reserved z (and zx) above is a top-level param only - the whole-state packed/encrypted token. A box's own z depth field and a keyframe track's z channel token live inside the boxes block's per-box sub-fields, a separate namespace decoded positionally, so there is no collision between the two.

Dimensions on a multi-artboard document (a Design doc with more than one artboard): the artboards are the size truth, and width/height describe the active artboard - the selected one for still formats, the one under the playhead for animated ones. In the app the export panel mirrors that artboard live, and editing the fields resizes it. At export time each format resolves the boards its own way: still images fan out to one file per artboard at that board's own size (zipped when there is more than one, and ?s= narrows to one board), PDF and PPTX carry every board as a page at its native size, and the animated formats composite every scene into a width×height output frame, letterboxing a board whose aspect differs. So on a framed document w/h never scales the whole set - it is the size of one board, and the video frame.

export, copy, full, options, nostage, present and kiosk are presence flags - the parameter value is ignored; what matters is whether the key appears in the URL.

lang is the one reserved param that changes the interface rather than the file. Adding ?lang=ja to any tool link hands the recipient the whole sidebar in Japanese for that session, without touching their saved preference.

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file36 paths~2.5k nodes75 groups4 images44 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file36 paths~2.5k nodes75 groups4 images44 KB

Building share links in the UI. In the web shell you don't have to hand-write these. The Share button (in the export panel) opens a dialog with the ready-to-copy link plus a toggle for each on-visit flag - _open fullscreen_ (full), _open with the export panel expanded_ (options), _download automatically_ (export), _copy to clipboard_ (copy) and _pin tool version_ (_v). The copy toggle appears only for clipboard-friendly formats (bitmap/text/html) and is hidden for SVG, PDF and video. Ticking a box rewrites the link in place. The same dialog is reachable from Projects → Share link on any saved session (it reconstructs the tool URL from the saved inputs).

Packed links (z)

Readable URLs are first-class - a simple ?color=30BA78&theme=dark link can be hand-edited. But a complex tool (e.g. Design, with dozens of boxes each carrying coordinates, colours and text) serialises to thousands of characters, past the ~2000-char ceiling that pasted links, social crawlers, QR codes and some servers still enforce.

For those, the app compresses the entire readable query into one z param:

/t/design?background=…&boxes=…&format=png   ← readable (e.g. 2729 chars)
/t/design?z=1eJyFkc…                         ← packed   (e.g. 1059 chars)

• Codec. z's value is <tag><payload>. Tag 1 is raw DEFLATE (RFC 1951, a frozen standard) via the platform-native CompressionStream, carried as base64url - the default, and the shortest form in characters. Tag 2 is the same DEFLATE bytes carried as unpadded upper-case base32 (RFC 4648): about 20% more characters, but every character sits in a QR code's alphanumeric set (5.5 bits per character instead of 8), so the Share dialog's QR button re-mints large links this way and the printed code comes out a version or two smaller. Both tags decode everywhere, forever; the tag byte versions the codec so future variants can be added without breaking links minted today.
• Stable by construction. The packed form compresses the app's own canonical readable query, so there's no separate encoding to keep in sync - and DEFLATE is standard, so a link packed in a browser decodes identically in Node's zlib (and the CLI), across app versions. There is no server-side or app-side lookup table that could drift.
• When it kicks in. Packing is used only when it's actually shorter (it loses on short links - DEFLATE framing plus base64's ⁴⁄₃ blow-up exceed tiny payloads), and the address bar switches to it automatically once the readable query passes ~1800 characters. Below that, links stay readable and editable. The Share dialog surfaces a Shortest link checkbox (auto-ticked for large states) showing the character saving.
• Expansion. expandQuery() (engine) turns a z link back into a plain query before parsing, so everything downstream - the web shell, the CLI (lolly <id> --z=1eJ…) and pasted-link composition - behaves identically to the readable form. On-visit flags (export, full, _v, …) can ride alongside z in readable form and still take effect.

Encrypted links (zx)

A password-gated variant of a packed link: share a link that only opens for someone who knows the password - with no server and no account.

The state is DEFLATE'd then AES-256-GCM-encrypted under a key derived from a password (PBKDF2-SHA256), and carried in a zx param. Opening the link prompts for the password, derives the key and decrypts entirely in the recipient's browser, then rebuilds the tool content. Wrong password → it asks again; cancel → the tool loads at its defaults.

• The password never travels. Only the ciphertext (plus a random salt and IV) is in the link. You share the password separately - and because it's not stored anywhere, it can't be recovered if lost.
• Turn it on in the Share dialog - tick Password-protect this link and set a password; the link updates to the zx form. On-visit flags still ride readable alongside it.
• Interactive-only. An encrypted link can be opened in Lolly but not embedded as an image (the embed path renders headless and can't prompt) - such a link simply renders at defaults there.
• Independent of z. zx is its own codec (<tag><base64url> of salt‖iv‖ciphertext), so it versions separately and expandQuery deliberately never touches it - decryption happens only at the interactive load boundary that can prompt.

Physical units (unit= + dpi=)

width/height are plain numbers; unit says what they mean. With a physical unit the output is rendered at the correct physical size for the format, not just a pixel count:

• PDF → a true page of that size (points, resolution-free). ?w=210&h=297&unit=mm&format=pdf is a real A4.
• SVG → width/height carry the unit (e.g. 210mm) with a px viewBox, so it scales cleanly.
• PNG / JPG / WebP → pixels at dpi (e.g. 210mm @ 300dpi = 2480px). PNG also embeds the DPI (a pHYs chunk) so print/layout software places it at the intended size.

px is the default and behaves exactly as before (the CSS 96-DPI convention). The canvas takes the physical shape straight away, so ?w=210&h=297&unit=mm&format=pdf shows you a portrait A4 before you export anything.

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file1 path141 nodes4 groups5 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file1 path141 nodes4 groups5 KB

lolly quotes --quote="Print me." --width=210 --height=297 --unit=mm --export=svg --output=a4.svg

Print marks & bleed (bleed= + marks=)

For print-ready output, bleed= and marks= add the prep a print shop expects to the pdf (RGB), pdf-cmyk (Print PDF) and cmyk-tiff (Print TIFF) formats. They're ignored for every other format. The two CMYK formats apply the same engine geometry - the PDF as vectors with declared page boxes, the TIFF rasterised onto an enlarged sheet.

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file17 paths~5.9k nodes25 groups6 images118 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file17 paths~5.9k nodes25 groups6 images118 KB

• bleed=3mm - the design is scaled to fill the bleed (the trim area is unchanged). The PDF declares its TrimBox (final cut) and BleedBox for the RIP; the TIFF is enlarged to the full sheet, the artwork composited over white to cover the bleed.
• marks=crop,reg,bleed,bars - draws, in the margin: crop (trim) marks, registration targets, bleed marks and a colour bars. In pdf-cmyk the line marks are DeviceCMYK 1 1 1 1 so they print on every plate; in cmyk-tiff they're written straight into the pixel buffer as all four channels at full ink (C=M=Y=K=255, the raster analogue), drawn after the RGB→CMYK pass so they aren't remapped; in the RGB pdf they're black. Mark length, gap and stroke weight are fixed to print standards.
• In pdf-cmyk the bar becomes a brand verification strip: the four solid process primaries (C, M, Y, K) come first as a fixed calibration reference, then - after a wider gap - each brand colour that actually substituted in this artwork appears as an RGB reference swatch touching its CMYK substitution, so a press operator can confirm the RGB→CMYK swap was applied. Only the inks really used are shown (substitution records which palette colours were hit); the pairs are capped by the available margin width and a flat ceiling of 12 brand cells. The RGB pdf and the cmyk-tiff (which does a flat per-pixel conversion with no exact substitution to verify) show a generic process/overprint/tint control bar instead.
• prov (PDF only) - adds small provenance credit text in the proof margin, taken from the export's authorship metadata: the export timestamp {YYYY-MM-DD HH:MM} at the top-left, "Made with https://lolly.tools" at the top-right and "{Tool} by {Author}" climbing the bottom-left. Like the other marks it sits outside the trim, so it's removed at the final cut (a proof annotation, not artwork). The author appears only when the user has opted into personal details (Profile → "Use my details").

The CMYK press condition (profile=, e.g. fogra51) is carried for both CMYK formats: the Print PDF declares it in the document's output intent; the Print TIFF records it as provenance in ImageDescription (the pixels stay untagged DeviceCMYK - no embedded profile, so the file is never mislabelled).

A named condition tells a RIP what the DeviceCMYK values mean, but PDF/X-4 also wants the profile itself inside the file, and no CMYK ICC ships with Lolly. So a named condition writes the output intent and not the GTS_PDFXVersion conformance claim. Load a CMYK profile of your own (Colour Lab, or the export panel's Colour profile control) and pick its Embed row - profile=own in a link - and the profile is embedded as the DestOutputProfile, at which point the file can claim PDF/X-4 - and does, unless something else in the export makes the claim untrue: RGB artwork the CMYK pass couldn't convert, marks=prov (its credit text is set in a standard font that isn't embedded, which X-4 doesn't excuse) or a strong password (X-4 forbids encryption). The output intent is written either way. The intent then declares the registered condition only where the profile itself proves one (its own targ characterization data, or a fetch Lolly made from the ICC registry); otherwise it declares Custom under the profile's own name, which is the honest reading of an unpaired profile.

?format=cmyk-tiff&bleed=3mm&marks=crop,reg,bleed,bars&profile=fogra51&export

Marks/bleed and the PDF open-password are mutually exclusive: print finishing is applied via pdf-lib, which can't write encrypted PDFs, so a password is ignored when marks/bleed are on. (cmyk-tiff has no password concept.)

Contact sheets (cuts=)

A still export of a timed composition renders the frame at the playhead. That's the contract: what you see on the stage is what goes into the file. A contact sheet asks for more than that frame - N stills sampled at equal intervals across the sequence, for a storyboard, a thumbnail sheet or a social carousel.

Set this in the export panel, not the link. The Frames field in the export panel is what produces a contact sheet today - see Exporting. cuts is reserved, parsed and clamped by the engine, but the web shell takes the count from that field rather than from the URL, so a link carrying ?cuts=6 renders the single playhead frame and a Share link never carries the value. The CLI does read it, and answers plainly: --cuts=6 (or a pasted link carrying it) exits 3 and writes nothing, because the sequence renderer lives in the web shell and a single frame under the filename you asked for would be a different artefact. The rest of this section describes the behaviour the Frames field drives.

With N > 1 and PDF chosen you get one N-page PDF, one page per sample, in time order; with png/jpg/webp/svg you get a zip of N files (-01 … -0N) instead, because PDF is the only still format that can hold several frames in one file. 1 is the single playhead frame.

Samples land at the midpoint of each slice - t_i = duration x (i + 0.5) / N, so a 6-cut render of a 12-second sequence samples at 1s, 3s, 5s, 7s, 9s and 11s. Sampling the endpoints instead (0s and 12s) would hand you two blank cards: at t = 0 an enter transition hasn't faded in yet, and at t = duration every clip has already ended.

Values are clamped to 1-64 (a contact sheet is for a human to look at; 64 is already an 8x8 wall), and anything unparseable falls back to 1 rather than failing the export. Non-still formats ignore cuts entirely - a video already contains every frame.

Format with format=

format=<fmt> selects the output format for both export (download) and copy (clipboard).

Supported values:

Not all tools support all formats - only the formats listed in the tool's manifest render.formats are valid. The authority on the whole set is the render.formats enum in schemas/tool.schema.json; this table names what each value produces. Requesting an unsupported format falls back gracefully.

Download with export

Adding export (no value needed) triggers an automatic download the moment the tool finishes rendering. Pair it with format= to set the file type; if format is omitted the tool's default format is used.

/#/tool/qr-code?url=https://suse.com&format=svg&export
/#/tool/qr-code?url=https://suse.com&format=png&export
/#/tool/qr-code?url=https://suse.com&format=pdf&export

export without format downloads in the tool's first listed format:

/#/tool/qr-code?url=https://suse.com&export

Download filename with filename=

Sets the name of the downloaded file. The format extension is appended automatically - do not include it.

/#/tool/qr-code?url=https://suse.com&format=png&export&filename=homepage-qr
→ downloads as homepage-qr.png

/#/tool/qr-code?url=https://suse.com&format=svg&export&filename=event-badge
→ downloads as event-badge.svg

Without filename=, the download is named after the tool ID (e.g. qr-code.png).

Copy to clipboard with copy

copy (no value needed) arms the tool's copy-to-clipboard action. Pair it with format= to choose the format; if format is omitted the tool's default is used.

/#/tool/email-signature?firstname=Andy&format=html&copy
/#/tool/qr-code?url=https://suse.com&copy
/#/tool/qr-code?url=https://suse.com&format=png&copy

It does not fire silently on load. Browsers only allow a clipboard write in response to a user gesture (navigator.clipboard.write rejects otherwise, and the image path would fall back to an unexpected download). So when copy is present, the shell highlights the Copy button and performs the copy on your first interaction with the page - the click that supplies the required gesture.

Use export instead if you want a genuinely unattended result (a download needs no gesture). copy is for "open this link, then it's ready to paste." It is a web-shell affordance; the CLI ignores it (use --output / stdout).

Canvas dimensions with width= / height=

width and height (short aliases w and h) set both the canvas document size and pre-fill the export dimensions panel. They are not passed to the tool as inputs.

?width=1200&height=630
?w=800&h=800
?w=1920&h=1080

Mixing long and short forms is fine - ?width=1200&h=630 works. The canvas preview updates to the new aspect ratio.

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file11 groups7 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file11 groups7 KB

Fullscreen with full

full collapses the sidebar so the canvas fills the entire viewport. The value is ignored - presence of the param is enough.

/#/tool/qr-code?url=https://suse.com&full

Any tool takes it. Mesh Gradient with full is artwork and nothing else.

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file16 paths299 nodes47 groups18 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file16 paths286 nodes47 groups18 KB

Combine with export for a clean unattended export flow:

/#/tool/qr-code?url=https://suse.com&format=png&filename=my-qr&export&full

Land on the export panel with options

options opens the tool with the export-settings panel already expanded (format, dimensions, DPI and the export/copy buttons) instead of the collapsed Render button. Use it to share a link where the recipient is one click from downloading.

/#/tool/qr-code?url=https://suse.com&options

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file49 paths~3.3k nodes61 groups3 images74 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file49 paths~3.3k nodes61 groups3 images74 KB

options is the opposite of full: full hides all chrome to show only the preview, while options surfaces the export chrome. If both appear, full wins (there's nowhere to anchor the export panel once the sidebar is collapsed). The flag is web-only - the CLI ignores it.

Transparent background

Tools that support transparent export expose a transparentBg boolean input. Pass it like any other boolean input:

?transparentBg=1

Transparency is preserved in formats that support an alpha channel: png, webp and avif. It is ignored for jpg, pdf and svg (SVG has no background rect when transparent).

Full example:

/#/tool/qr-code?url=https://suse.com&color=%230c322c&transparentBg=1&format=png&export&filename=qr-transparent

The engine injects a second export toggle the same way: convertPaths (the Convert paths text-to-vector outlining control) is added automatically to tools that export a vector format. It is URL-expressible as any boolean - ?convertPaths=0 to leave text live, ?convertPaths=1 to outline it - and defaults on. A tool that sets render.convertPaths: false suppresses it (and the param has no effect).

Loading saved state with slot=

Saved state slots are named snapshots of input values stored in the browser. The slot param loads one by name. Any URL params present alongside slot override the saved values for that render only.

/#/tool/quotes?slot=andy-quote-v2
/#/tool/qr-code?slot=homepage-qr&format=png&export

Combining parameters

All parameters compose freely. A fully-specified automation URL might look like:

/#/tool/qr-code?url=https://suse.com/event&color=%230c322c&background=%23ffffff&ecl=H&padding=4&format=png&export&filename=event-qr&w=600&h=600&full

This opens the QR tool, applies all inputs, sets the canvas to 600×600, collapses the sidebar and immediately downloads event-qr.png.

The same stacking works on a chart, where inputs, compact keys, canvas size and full arrive together:

/#/tool/chart?ct=donut&pl=warm&t=Everything+in+one+link&lg=1&lp=right&sv=1&w=1200&h=800&full

signed by Lollyvector SVG2026-08-24Semak sendiriGet the signed file23 paths330 nodes41 groups22 KBsigned by Lollyvector SVG2026-08-24Semak sendiriGet the signed file23 paths317 nodes41 groups21 KB

CLI usage

The CLI uses the same param names as URL mode - --key=value instead of ?key=value. --export=<fmt> sets the output format and --output the destination; all other params are tool inputs. Note that on the CLI --export takes the format - it is not URL mode's presence flag, which has no CLI equivalent because writing a file is the export. (--format=<fmt> is accepted as a synonym, but never pass a bare --export alongside it: the bare form is read as the format 1 and the render aborts.)

# Web equivalent: /t/qr-code?url=https://suse.com&format=png&export&filename=my-qr
lolly qr-code --url=https://suse.com --export=png --output=my-qr.png

# Pipe SVG to another tool
lolly qr-code --url=https://suse.com --export=svg > qr.svg

# Print available inputs for a tool
lolly qr-code

Integration patterns

Shareable link

The web shell writes the current input state to the URL query automatically as inputs change - copy from the address bar at any time.

Pre-filled embed

Embed the tool in an iframe with inputs pre-filled via URL:

<iframe src="https://brand.example.com/#/tool/qr-code?url=https://suse.com&full"
        width="900" height="700" frameborder="0"></iframe>

Embedding a page into another origin is off unless the deployment turns it on. Lolly ships frame-ancestors 'self' in its Content-Security-Policy, so a shell frames inside its own site but not inside someone else's. That is the safer default for an app holding your documents and offering export actions, since a page you do not control can otherwise position an invisible frame over its own buttons. Framing within one origin (your marketing page embedding your own Lolly) needs no change. To allow another origin, the operator adds it to frame-ancestors where the headers are set (vercel.json, or deploy/docker/security-headers.conf for the container), naming the specific origins rather than widening it to every site.

Tool composition (portable embed URL)

A tool can embed another tool's render with no tool-to-tool imports. The URL-mode face of this is a portable embed URL - a real-looking image URL whose query is ordinary URL-mode params:

<img src="https://lolly.tools/tool/qr-code.svg?url=https://suse.com&color=0c322c">

Nothing is ever fetched from lolly.tools. A shell recognises this exact shape and renders the named tool locally, substituting the result (a placeholder pixel shows until the local render resolves). Anything that isn't exactly this grammar is treated as an ordinary image - that strict match is the security boundary.

The path extension is the author's fidelity choice. Compose any tool's render: an SVG child stays a true vector when the parent exports to SVG or PDF and rasterises crisply for PNG; raster children (png, jpg/jpeg, webp) embed as images. (pdf appears in the grammar but is not inlined as a child format.)

This is the URL-mode surface of composition. The declarative form - a manifest composes: [{ id, tool, inputs, format? }] block resolved by the engine and placed in the template as {{asset <id>}} - is not a URL param; see the authoring guide. Either form requires the tool to declare the compose capability. event-name-badge composes qr-code as SVG today.

Automation / CI

Call the CLI in a build pipeline to generate assets on demand:

lolly qr-code \
  --url=https://suse.com/product/${SLUG} \
  --color=#0c322c \
  --export=svg \
  --output=./dist/qr-${SLUG}.svg

App links

Everything above addresses a tool. The rest of the app is addressable the same way: the browse views, the studio, the dashboard and the settings pages each read a few params off their own route, so a link can land someone on a particular shelf of the catalogue or a particular settings card rather than on the front door.

Two audiences use this, and they want the same thing for different reasons:

• Sharing. "Here, look at this" - a link that opens where you were looking, so the person on the other end doesn't have to be talked through four clicks.
• Automation. A screenshot run, an agent driving the app, a docs recipe. Every /info screenshot in these docs is one of these links handed to url-shot; the app has to arrive in a known state, deterministically, with no clicking.

Three rules hold everywhere below, and they are what make the links safe to paste:

1. Consumed on arrival. These params are read once, when the view mounts. They are never written back into a link the app generates for you, so a state you deep-linked into doesn't get re-shared by accident.
2. Never persisted. A param that overrides a saved preference - sort order, view mode, theme - does so for that page load only. Opening someone's link never rewrites your own settings.
3. Unknown values are ignored. A param naming something that doesn't exist (a retired category, a typo'd section) is dropped and the view opens normally. Links don't break; they just stop steering.

The lolly:// scheme

The installed apps register lolly:// as their own URL scheme, so anything that can open a URL can open Lolly at an exact place: a launcher's "open URL" action (Raycast, Alfred, PowerToys Run), a macOS Shortcut, a .desktop Action, a GNOME Shell or KRunner result, a link in a note or a QR code on a slide, or a terminal:

open      "lolly://t/qr-code?url=https://suse.com"     # macOS
xdg-open  "lolly://t/qr-code?url=https://suse.com"     # Linux
start     "lolly://t/qr-code?url=https://suse.com"     # Windows

The grammar is the web address with the site name taken for granted: lolly://<route> is https://lolly.tools/<route>. Every tool form works (lolly://t/<id>?…, lolly://tool/<id>?…, a bare lolly://<id>?…, and the embed form lolly://tool/<id>.svg?…, whose extension becomes format=), with the same inputs, reserved parameters and packed z= links as the https form. Any app route works too (lolly://lab, lolly://verify?asset=lolly/logo/primary, lolly://docs/build/authoring-tools). A copied https link with https:// swapped for lolly:// keeps working - the lolly.tools host segment is dropped rather than read as a tool id.

The Share dialog can write this form for you: open Link options and turn on Open in the installed app. The field and its Copy and QR actions switch to lolly:// while keeping the exact same state, password/packing token and behaviour flags. Turn it off and the field returns to the ordinary web link. That makes the web URL the safe default for a recipient who may not have Lolly, and the app URI an explicit choice for shortcuts and automation.

Read an app URI in three pieces; there is no second parameter vocabulary hiding behind the scheme:

So lolly://t/qr-code?url=https%3A%2F%2Fsuse.com&full launches Lolly, opens QR Code with its url input filled, and uses the reserved full behaviour. z= and zx= are just compact or encrypted versions of the same query state; every readable flag that follows them still wins in the usual way.

A link that names no route the app owns is refused, not guessed at: the OS hands the app an untrusted string, so the mapper only ever opens a tool id that parses or a word from the app's frozen route vocabulary. Pasting a lolly:// link anywhere the app already accepts a Lolly link (the asset picker, the pasted-link paths, the CLI's Lolly <link> form) works the same way.

Where it is registered: the macOS and Windows installers and the Linux .desktop entries all declare the scheme, as do the Android and iOS apps. A tauri dev build registers itself on Windows and Linux at launch; on macOS only the installed .app can receive the scheme. Spotlight itself opens web addresses, not custom schemes - on a Mac, reach the scheme through open, a Shortcut or a launcher. The MCP server's resource URIs (lolly://catalog, lolly://tool/{id}) share the prefix but are a different namespace: resources an agent reads, not routes the app opens.

App-wide

Gallery (#/, and #/u for utilities)

Catalogue (#/c)

Projects (#/p, #/p/<folderId>)

view, sort and rev override both the device-wide and the per-folder saved preference for that visit, and neither is rewritten.

Batch (#/batch)

#/batch?s=<slot>,<slot> opens those saved sessions as rows in the grid - what Edit as sheet builds. #/pro was the route's name before 2026-08-20 and still redirects here with its query intact, as does the /pro path form.

Multi-edit (#/multi)

#/multi?s=<slot>,<slot> opens those sessions side by side.

Design system studio (#/start)

Everything except area is one-shot: it acts on arrival and is dropped from the address bar as soon as you move between rooms. That is deliberate, so a link copied mid-session says which room you're in rather than re-firing a modal for the next person.

Dashboard (#/d)

#/d?tab=<tab> opens a primary tab - device, brand, caps, activity. #/d?<section-id> scrolls to and opens one section directly (#/d?dash-storage, #/d?cap-formats); the section ids are the DASH_SECTIONS rows in shells/web/src/views/dashboard-registry.ts. #/b and #/brand are shortlinks to the Design system tab.

Profile (#/profile)

#/profile?focus=<section> opens and scrolls to one settings card. The sections are details-section, identity-section, appearance-section, a11y-section, connections-section, renders-section, storage-section, offline-section, activity-section, feature-flags-section and instance-section.

The remaining views

On a tool route

For completeness, the app-state flags that live on a tool link rather than on a view. All but one are in the reserved-parameter table above: options (open on the export panel), full (fullscreen, no chrome), template=<id> (start from that template, skipping the chooser - a bare ?template= opens the chooser itself, which is what the gallery's +New chip links to), present + s= + kiosk (presentation mode), slot= (resume a saved session). The exception is share, a presence flag read by the tool view rather than by the engine: it opens the Share dialog on load, so a click-only surface has an address.

A few more, on the canvas editors only, set EDITOR state rather than the document and are one-shot (read on load, dropped from the address on the first edit): _sel=<id>,<id> selects those boxes, _t=<seconds> opens the timeline with the playhead parked there, and _panel=choreograph opens the Choreograph picker over the selection. The object form _ui= carries the same state as one param - base64url JSON of { "v": 1, "sel": ["a", "b"], "t": 2.5, "panel": "choreograph" } - for links built by other apps; every key is optional, unknown keys are ignored so the object can grow, and the three shorthands stay first-class and win on conflict. They all live in the _ namespace, which the engine reserves outright (no tool input can ever be named that way), so they need no row in the table above. They exist so a link can open on a state - a documentation screenshot, a bug report, a "look at this frame" message - without a script of clicks. The same object drives a runtime channel while a canvas editor is mounted: window.lolly.ui exposes getState() (the object a link to the current view would carry) and apply(state), and an embedding page can postMessage({ type: 'lolly:ui', state }) to the same effect.