Outputs & exports.

Outputs save back into the .orchid file so reopening a notebook shows yesterday's results today. When outputs get big, they spill cleanly to disk.

Where outputs live

Each cell's last output is serialized inside the notebook YAML — printed values, DataFrame previews, error tracebacks, chart specs. Open the file on another machine and you see the same results you left behind, without re-running anything.

Outputs over 5 MB or with binary payloads spill to .orchid/outputs/ next to the notebook. The YAML keeps a small pointer; the heavy content lives in a side file. Diffs stay readable, large rendered tables keep working.

# Inline output (small)
- id: q1
  type: sql
  output_variable: order_count
  source: SELECT count(*) FROM orders;
  outputs:
    - type: dataframe
      summary: '1 row × 1 column'
      variable: order_count
      data:
        columns: [count]
        rows: [[12483]]

# Truncated large output — first N rows in the YAML, full rows in sidecar
- id: q2
  type: sql
  output_variable: all_events
  outputs:
    - type: dataframe
      summary: '2,400,000 rows × 8 columns'
      variable: all_events
      data:
        truncated: true
        truncatedAt: 1000
The project file tree showing .orchid/outputs with parquet files for each spilled cell./docs-images/notebooks/outputs-folder.png
Big tables spill to .orchid/outputs/ to keep notebooks diff-friendly.

The result viewer

DataFrames render in a virtualized table — millions of rows, smooth scroll. Sort and filter without re-running the source cell. Charts render with their original Plotly controls and any pan/zoom state from the last interaction.

Errors include the full traceback with clickable frames. Stdout and stderr from a cell run sit above the value output, color-coded.

Exports

Three export paths, picked from the notebook menu:

  • Download as HTML — static, self-contained, opens in any browser. Charts stay interactive (Plotly bundled inline). Useful for emailing a write-up.
  • Download as Jupyter (.ipynb) — converts cell-by-cell into the standard Jupyter format. SQL cells become %%sql magic cells; chart cells become Plotly code.
  • Publish — see Publishing.
Tip

The HTML export is the right move when the recipient just needs to read the result. Jupyter export is right when they need to re-run or edit. Publish is right when you want a permanent link you can update.

Clearing outputs

From the notebook menu: Clear all outputs empties every cell's output and drops anything in .orchid/outputs/. Clear outputs in this cell from the cell menu does just that one.

Clearing before a commit can be useful if you don't want results in git. We'd rather you didn't though — the diff format is designed to handle outputs gracefully.

Re-runs vs. cached outputs

Opening a notebook never re-runs cells. Outputs come straight from the file. You decide when to re-run: Run all, Run from here, or per-cell with Shift+Enter.

SQL cells show a stale badge if their connection isn't currently reachable from your machine but the cached output is still visible. Charts show stale if their source DataFrame has changed shape since the chart last ran.

Heads up

Connection credentials are never serialized into outputs. SQL cells store the connection profile name, never the password or token.

Up next: Dashboards, Publishing, or back to the Notebooks overview.