Export & Share

Chinilla exports your design in many formats — pick the one that matches where it’s going. Open the export button in the header (or Ctrl/Cmd+E).

At a glance

Format	Best for	Tab
Repro bundle	Sharing the full project so a collaborator can rerun and get the same numbers	Repro bundle
PNG image	README screenshots, docs embeds, Slack	Image
SVG	Lossless scaling for papers, slides, print	SVG
Animated GIF	Showing the simulation playback in motion (Pro)	GIF
System Spec	Deterministic architecture document, no AI	System Spec
Mermaid	Inline diagrams in any Markdown renderer	Mermaid
Citation bundle	Markdown / LaTeX block for paper writeups (Pro)	Citation

Repro bundle (.chinilla.json)

Your full project saved as a .chinilla.json file. The export tab is labeled Repro bundle because the file is structured for reproducibility, not just backup. Anyone with the file can import it, hit Run, and reproduce the same numbers bit-identically.

Includes:

• Every block with positions, numbers, requirements, behaviors, and costs.
• Every line with directions, latency, weights, and sync/async flags.
• Every drawing, note, and group.
• Run results (if you’ve run a sim).
• Runtime parameters (seed packets, traffic multiplier, arrival interval, outage component).
• Monte Carlo seed list (if you’ve run MC) — preserved so reruns match.
• Warm-up frame count.
• Queueing aggregates (lambda, L, W, Lq, Wq, rho, max-rho hotspot).

To bring it back, click the import button in the header. v1 backups (pre-2026-05) still load — they just don’t carry the simulation parameters.

Citation bundle

Markdown or LaTeX document for paper writeups (Pro). Bundles the four things every sim figure caption needs:

• Experimental setup paragraph.
• Component parameter table.
• Monte Carlo summary table with mean ± 95% CI (Student’s t).
• Queueing analysis with Little’s Law variables.
• Seed list for reproducibility.

LaTeX output is plain LaTeX with no extra packages required (uses \hline). Pastes straight into Overleaf. Switch the toggle in the export tab between Markdown (GitHub-flavored) and LaTeX.

System Spec

A written architecture document built from your canvas (no AI needed):

• Layout — block count, line count, density numbers.
• Blocks by type — grouped list with descriptions, numbers, protocol, scaling, full behavior settings (mode, expression, failure rate, drop rate, capacity, delay, etc.).
• Data flow — entry blocks, exit blocks, critical paths.
• Connections table — start, end, label, direction, latency, routing weight.
• Quality scores — Six Instincts scores (if validated).
• Run results — timeline and failure analysis (if simulated).

Copy to clipboard or download as markdown.

Image (PNG)

Open the Export modal and click the Image tab (the default). You get:

• Live preview of how the export will look.
• Dark / Light toggle for the export theme.
• Grid checkbox to show or hide the background grid.
• Labels checkbox to show or hide line labels.
• Copy to clipboard for one-click pasting.
• Download PNG at high resolution (up to 8192px per side).

Icons, smooth curves, behavior colors, groups, notes, and tickets all render at full quality.

Copy as Markdown

Click Markdown in the Image tab footer to copy a ready-to-paste image embed:

• If your design is published, the embed links to your share URL: [![Project](url/og.png)](url).
• If not published, the PNG is encoded directly into the link as base64: ![Project](data:image/png;base64,...).

Paste it into GitHub READMEs, Notion pages, blog posts, or anywhere markdown works.

SVG

The SVG tab makes a vector image of your canvas:

• Blocks as SVG text with behavior-colored icons.
• Lines as smooth <path> curves with proper arrowheads.
• Groups as rounded <rect> elements with labels.
• Freehand drawings as SVG paths.
• Line labels in rounded pill backgrounds.
• Same Dark / Light, Grid, Labels, and Descriptions checkboxes as the Image tab.
• Copy SVG to clipboard.
• Download SVG as a .svg file.
• Markdown button copies the same embed format as the Image tab.

SVGs scale perfectly at any size, are small files, and look crisp in docs, presentations, and print.

Animated GIF

The GIF tab in the Export modal makes an animated GIF of your simulation playback:

• Runs the full flow with items moving through.
• Each frame shows active blocks (cyan highlight), active lines (dashed cyan), used-before lines (faded cyan), and queue dots.
• Heads-up overlay on every frame: health % with color, running In / Out / Lost / Queue counters, a delivery bar, time, step counter, bottleneck callout.
• Status pills on blocks: green “delivered” on exit blocks, blue “entered” on entry blocks, amber “processing” on slow blocks with items waiting, accent “done” / “waiting” / “lost” on active blocks.
• Speed: 1x, 2x (default), or 4x.
• Dark / Light toggle for the GIF theme.
• Loops forever by default.
• Download the GIF for READMEs, docs, or presentations.

The GIF encoder is built in (no extra setup). Frame delay is 2400ms / speed, so at 2x each step holds for 1.2 seconds.

Python

A runnable Python scaffold generated from your canvas (no AI needed). You get a .py file with:

• Right imports based on each block’s protocol (httpx for HTTP/GraphQL, grpc for gRPC, websockets, pika for AMQP, kafka-python for Kafka, paho-mqtt for MQTT).
• One class per block with behavior-accurate logic:
  • Transform: converts transformExpr into Python dict access (data['total'] = data['price'] * data['qty']).
  • Retry: injects simulated failures at the configured rate with exponential backoff.
  • Circuit Breaker: simulates failures at the configured rate with threshold-based state transitions.
  • Split: supports both round-robin and weighted routing based on line weights.
  • Condition: converts JavaScript expressions into Python-safe dict access.
• Thread pools for any block with Max instances above 1, sized to the max.
• Pipeline function that wires the blocks together to match your canvas, including weighted targets for split blocks.

The export reads straight from your canvas. No API key required.

Mermaid

A Mermaid flowchart from your canvas:

• Blocks mapped to Mermaid shapes by type (cylinder for storage, diamond for decision, etc.).
• Numbers included in labels (rate, capacity, time per item).
• Line directions kept (forward, backward).
• Line labels and routing weights on edges (w:70).
• Groups as Mermaid subgraphs.
• Line styles preserved (solid, dashed, dotted).

Copy to clipboard or download as .mmd for GitHub, Notion, or any Mermaid renderer.

Integrations

Integration	What it does
GitHub Gist	Publish your System Spec as a Gist.
Slack	Send a design summary to a Slack channel.
Notion	Export to a Notion page.
Jira	Create a Jira issue from your design.

Publish (interactive preview)

Turn any design into a public, read-only page anyone can open without an account.

How to publish

1. Open the File menu in the workspace toolbar.
2. Click Publish.
3. Toggle the Published switch on.
4. Copy the link.

The link looks like chinilla.com/share/abc123xyz. Anyone with the link can:

• Pan and zoom the canvas.
• Inspect every block and line.
• Toggle the simulation timeline on or off.
• Toggle the live counter overlay on or off.
• Switch dark or light mode.
• Copy the design into their own workspace with “Open in Chinilla”.

Publish from the dashboard

Click the publish icon on any project card on your dashboard. Same toggle and link.

Views and likes

Each published design tracks:

• Views — counted every time someone opens the preview.
• Likes — logged-in users can like a design (one like each).

Both numbers show on the preview page and on your dashboard cards.

Unpublishing

Toggle the Published switch off in the same modal. The link stops working right away. Views and likes are kept in case you publish again later.