Import a design (Figma, Penpot, Illustrator, InDesign)

signed by Lollykookaburra.webpWEBP2026-08-28AI generatedCompruébalo tú mismoGet the signed filepixels, not shapes193 KB

Trae lo que ya has creado

Tus archivos de diseño no se quedan atrapados

El trabajo terminado en Figma, Penpot, Illustrator, InDesign o cualquier app de SVG no tiene por qué quedarse encerrado en una sola app. Abre Design, haz clic en Importar un diseño, y el archivo se abre como un layout vivo - no como una imagen aplanada. Cada capa se convierte en una caja editable, lista para seguir trabajando en ella, combinar con herramientas y renderizar bajo las mismas reglas.

Fig Figma .fig · SVG

Pen Penpot .penpot

Ai Illustrator .ai · PDF

Id InDesign .idml

SVG Cualquier SVG universal

Tu archivo de diseño

Figma, Penpot, Illustrator, InDesign o cualquier SVG

→

Lienzo editable

Cada capa es una caja en la que puedes cambiar el texto, el estilo y la posición

→

Combina herramientas

Añade un código QR, un gráfico en vivo u otro render

→

Renderiza donde quieras

SVG, PDF, PNG, vídeo - reproducible desde una URL

Se mantiene editable

El texto sigue siendo texto, las formas siguen siendo formas, y las imágenes se suman a tu biblioteca. Sigues trabajando sobre el diseño - nunca repintas una captura de pantalla.

Llega ya conforme a las reglas

Las fuentes se remapean a tus tipografías y cada relleno pasa por el mismo control de color que una caja nativa. Una mesa de trabajo externa llega ya gobernada.

Se convierte en una plantilla

Guárdalo y el layout se convierte en una herramienta reutilizable y direccionable por URL - una que cualquiera con Lolly puede abrir, rellenar y renderizar. No hace falta ninguna app de diseño.

Bring a finished design out of Figma, Penpot, Illustrator or InDesign and into Lolly - not as a frozen picture, but as a live, editable layout you can keep working on, mix with tools and render through Lolly's deterministic export path. Like everything else, the whole import happens on your device: the file is parsed in your browser and nothing is uploaded.

The good news for everything you've already made: none of it is stranded in the app you drew it in. A design you spent hours on in another tool arrives as an editable session, already conformed to your design globals - and once you save it, it's a reusable template anyone with Lolly can open and refill.

Import lives in Design, Lolly's free canvas: open it, click Import a design in the canvas toolbar and choose a file. The artboard resizes to the file's frame and every layer becomes an editable box on the same open canvas - so an imported artboard is just an ordinary Design session from the first click.

signed by LollyPNG2026-08-28Compruébalo tú mismoGet the signed filepixels, not shapes543 KBsigned by LollyPNG2026-08-28Compruébalo tú mismoGet the signed filepixels, not shapes490 KB

What you can import

Several file kinds go in - a native Figma binary, a Penpot export, an Illustrator or PDF file, an InDesign markup file or any SVG. That last one is the wide door: SVG is a universal export (or native save) format, so almost any design app can reach Lolly through it.

Bringing a PowerPoint deck instead? Decks have their own doors - file slides as assets, rebrand in place, or write a new deck in Markdown Slides. See Decks and documents below.

What each app is for

• Figma - File → Save local copy for a native .fig, or export a frame as SVG. (Untick Outline text on the SVG export to keep headlines retypable.)
• Penpot - its standard .penpot export, or any SVG export. Penpot is also where the brand tokens round-trip both ways - see below.
• Illustrator - a native .ai (kept PDF-compatible, the default) or a .pdf opens directly; no SVG step needed.
• InDesign - File → Export → InDesign Markup for an .idml. A print layout becomes an editable, brand-conformed Lolly session. (A raw .indd isn't readable - export IDML.)

What happens to the layers

The importer maps design layers onto the free canvas's box model, keeping as much editable as it can:

• Text stays text. Frames of type become real text boxes - content, size, alignment, weight, line-height and per-run colours carry over - so you can retype a headline, not repaint it.
• Shapes stay shapes. Rectangles, rounded rects, ellipses and pills become native shape boxes with their fills, opacity, rotation and corner radii.
• Images are extracted. Bitmaps land in My images (your on-device library) and are placed as image boxes.
• Complex vector art is flattened faithfully. Paths, gradients and other paint Lolly's box model can't express are baked into crisp standalone SVG image boxes, so the visual result survives even where editability can't.
• Geometry is exact. Positions, sizes and rotations are resolved by the browser itself (the same maths that rendered the original), so the imported layout lines up with the source.

It conforms to the brand

This is the point of importing rather than pasting a screenshot: the result is a governed layout, not a foreign artboard.

• Type remaps to the brand faces. Every imported font becomes one of the faces your brand pack ships (monospace families map to your brand's mono face, weights clamp to the cuts that exist). That's intended behaviour - the design arrives already on-brand.
• Colours are guarded. Every imported fill passes the same colour sanitiser native boxes use; from there you can snap them to brand swatches with the normal pickers.
• Everything else is a normal session. Drag, rotate, snap, group, clip; place themable icons and library assets; save it, share it as a URL, run it through Batch.

Rendering

An imported design exports exactly like a native one: SVG, PDF, print CMYK PDF, CMYK TIFF, PNG, JPG, WebP through the same deterministic pipeline - true page sizes and physical units, outlined type in vector output, Content Credentials on every stampable format. The design's new home is its URL, so a once-off Figma file becomes a reproducible, parameter-addressable asset.

Frames become a video

The same files open on Design's timeline - and there the import means something different: every frame becomes a scene on the timeline. A Figma file's top-level frames, a Penpot file's boards, a PDF's pages - each arrives as its own timed clip, already playing through in order. From that first play-through you're in an ordinary sequence session: drag clips to reorder, trim and retime them, add a music bed, record a voiceover, drop text overlays on top and export MP4, WebM, GIF or APNG through the same deterministic pipeline.

Two ways in:

• In Design, open Import a design from the canvas menu and choose the file.
• Drop the file anywhere on the gallery or dashboard and pick Make a video from its frames.

A deck that stays a click deck can still leave as a video. Export slides as video in the Present menu opens the export sheet on MP4, and the render places the slides on a timeline in order for that export only: each slide plays for its own dwell, or for the Duration in the export sheet when it has none, and the deck's slide transition plays between them as a dissolve. The document itself is not changed.

Each frame is baked through the Design tool's own renderer into a crisp vector still (text as outlines, images embedded), so scenes stay sharp at any export size and need no fonts at playback. A storyboard drawn in Penpot or Figma becomes a finished cut - titles, soundtrack, provenance and all - without a video editor in sight.

From a one-off design to a reusable template

This is where import stops being a conversion and starts being authoring. An imported layout is an ordinary Design session, so it inherits everything a native session can do:

• It's a template anyone can reuse. Save it and the layout lives at a URL. Anyone with Lolly can open that URL, change the words, swap an image and render their own version - no design app, no design skill and the parts the author locked stay locked. The person who imported the artboard becomes its author; everyone else just fills in the blanks.
• It mixes with tools. Any box can hold another Lolly tool as a live asset - a badge that renders its own QR code, a card with a live chart, another render dropped in through the asset picker. Those stay live and re-render on load; they're never flattened pictures. So an imported poster can carry generated, always-current content the original file never could.
• It scales like any session. Drive it from the batch grid (one finished asset per spreadsheet row), keep it in a Projects folder or render a whole folder as one zip. A single imported design turns into a whole run of consistent variants.

For a fully declarative tool - sidebar inputs, hard-coded constraints, the works - you'd still author a tool.json by hand (see Authoring Tools). Import gets you the fast, visual 90%: a governed, shareable, tool-embedding layout without writing a manifest.

Round-tripping the brand itself

Import travels one direction; the brand primitives travel both ways. Lolly's colours are DTCG design tokens - the same format Penpot imports/exports natively and Tokens Studio brings to Figma - so the palette you design with in Figma/Penpot and the palette Lolly enforces are one document, not two hand-synced lists.

signed by Lollyvector SVG2026-08-24Compruébalo tú mismoGet the signed file19 paths~3.2k nodes35 groups2 images175 KBsigned by Lollyvector SVG2026-08-24Compruébalo tú mismoGet the signed file19 paths~3.2k nodes35 groups2 images175 KB

Limits & safety

• Imported SVG is treated as untrusted: scripts, event handlers and foreign objects are stripped before parsing, and anything flattened to disk is sanitised a second time on ingest. Nothing executes, nothing leaves the device.
• Very large files are capped at 2,000 elements - anything past that is dropped with a warning rather than locking the tab.
• Effects outside the box model (complex blend stacks, exotic strokes) flatten into the image fallback rather than round-tripping as editable properties.

Every format Lolly can read

Design files are one way in - the table above covers them. For the complete picture, here is everything Lolly ingests. As with a design import, every file is parsed on your device and nothing is uploaded.

Images

Drop a photo or graphic into any image picker or your My images library.

Decks and documents

Data

Paste or drop a table and a tool's repeating blocks fill from it (up to 1,000 rows).

Video

Audio

Audio arrives in the asset picker - ready as a music bed under a video export, or in Neurospicy Mode's ambient player.

Content Credentials (verify)

Lolly reads and cryptographically verifies a signed C2PA manifest embedded in PDF, PNG/APNG, JPG, GIF, SVG, TIFF, WebP, AVIF, MP4, WebM/MKV and the audio containers MP3, WAV, M4A and OGG/Opus - entirely on-device, against the signing certificate. The /verify view goes further: it flags AI-generated content, detects Lolly's own pixel Imprint, verifies SEAL signatures, optionally deep-scans for third-party pixel watermarks and surfaces hidden data - none of it uploaded. See Content Credentials and Content Credentials Identity. (HEIC/HEIF is read as an image but carries no credential.)

Metadata (to strip it)

The Strip Hidden Data utility reads embedded metadata so it can remove it - EXIF/GPS/IPTC/XMP from JPEG, text and time chunks from PNG, comments and editor namespaces from SVG and document info from PDF. The cleaned file never leaves your device.