marimo-studio 0.2.0__tar.gz → 0.2.2__tar.gz

{marimo_studio-0.2.0 → marimo_studio-0.2.2}/.agent-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "marimo-studio",
-  "description": "Author and validate focused views from Marimo notebooks.",
+  "description": "Author and validate focused views from marimo notebooks.",
   "author": {
     "name": "Péter Ferenc Gyarmati",
     "email": "dev.petergy@gmail.com"

{marimo_studio-0.2.0 → marimo_studio-0.2.2}/.agent-plugin/skills/marimo-studio/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: marimo-studio
 description: >-
-  Create, inspect, and refine web views of a Marimo notebook. Use for Studio
+  Create, inspect, and refine web views of a marimo notebook. Use for Studio
   view source, live notebook projections, browser verification, selected
   feedback, and running or exporting a named view.
 ---
 
-# Author Marimo Studio views
+# Author Studio views
 
 Studio turns one reactive notebook into named web views. The notebook owns
 computation, data, controls, and domain decisions. A view owns its presentation
@@ -14,13 +14,14 @@ and browser interaction. Studio owns view projects, builds, and delivery.
 
 ## Choose the requested work
 
-| Request                            | Start with                                                                          |
-| ---------------------------------- | ----------------------------------------------------------------------------------- |
-| Explain or inspect a view          | Inspect its source and notebook producers. Keep the task read-only.                 |
-| Create a dashboard or presentation | Inspect existing views, choose a starter, build and show a first result.            |
-| Change an existing view            | Read its project instructions and affected documents, then edit and verify.         |
-| Address a Lens selection           | Read [Lens in Studio](references/lens.md) and the installed Lens skill.             |
-| Run, publish, or export            | Read [delivery](references/delivery.md) before designing controls or exposing data. |
+| Request                                                                | Start with                                                                          |
+| ---------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
+| Explain or inspect a view                                              | Inspect its source and notebook producers. Keep the task read-only.                 |
+| Create a dashboard or presentation                                     | Inspect existing views, choose a starter, build and show a first result.            |
+| Build views about a topic that has no notebook                         | Start a new notebook, write its cells through code mode, then create each view.     |
+| Change an existing view                                                | Read its project instructions and affected documents, then edit and verify.         |
+| Address a [Lens](https://marimo-team.github.io/marimo-lens/) selection | Read [Lens in Studio](references/lens.md) and the installed Lens skill.             |
+| Run, publish, or export                                                | Read [delivery](references/delivery.md) before designing controls or exposing data. |
 
 This core contains the ordinary authoring workflow. Read conditional references
 when the task needs their detail. Reuse this briefing while the Python
@@ -28,28 +29,60 @@ environment and Studio installation remain unchanged.
 
 ## Bind to the intended notebook
 
-Live Studio work runs in the notebook's kernel through Marimo code mode. Two
-hosts provide it:
+Live Studio work runs in the notebook's kernel through marimo code mode.
+marimo's chat sidebar in **Code Mode** already runs there. A terminal agent
+pairs with the running notebook through the `marimo pair` CLI. Read its help
+once, then list running notebooks:
 
-- Marimo's chat sidebar in **Code Mode** already runs the agent in the
-  notebook's kernel.
-- An external agent pairs with a running notebook through the `marimo-pair`
-  skill, which owns finding, starting, and connecting to notebook servers and
-  executing code in them.
+```console
+uvx marimo@latest pair --help
+uvx marimo@latest pair notebook list
+```
+
+Pick the user's notebook and pass its server URL and absolute `path` to every
+execution. Run each Python example below as one execution:
+
+```console
+uvx marimo@latest pair execute --url <URL> --file <PATH> --code-file - <<'PY'
+import marimo_studio
+print(await marimo_studio.agent.current_workspace().status())
+PY
+```
+
+The list shows local servers started with `--no-token`. For a server that
+requires a token, ask the user for its URL and a token file. List that server
+to read the notebook's absolute `path`, and pass `--token-file <PATH>` to every
+`pair` command:
+
+```console
+uvx marimo@latest pair notebook list --url <URL> --token-file <PATH>
+```
+
+When the notebook is not running, start it in the background. For a topic with
+no notebook, choose a new file name and marimo creates the file. marimo opens a
+Studio tab in the user's browser, and the notebook appears in the list once
+that tab connects:
+
+```console
+uvx --with "marimo-studio[deno]" marimo edit notebook.py --sandbox --watch --no-token
+```
 
-Studio adds one requirement to either host. The Marimo server must run with
-`marimo-studio` installed, for example through `uvx --with marimo-studio` or
-the notebook project's dependencies. Sandboxed kernels then import the same
-Studio as the server. When neither host is connected, ask the user to open the
-notebook in Studio and connect one. Saved-notebook authoring continues from a
-terminal as described below.
+`--watch` reloads the notebook in Studio after you or another tool edits the
+file. `--no-token` serves the editor on localhost without an access token,
+which lets `pair notebook list` find it. Studio needs `marimo-studio` in the
+marimo server's environment, as in that command or the notebook project's
+dependencies. `help(marimo._code_mode)` then lists Studio as the `studio`
+capability, and sandboxed kernels import the same Studio as the server. Create,
+edit, and run cells through `marimo._code_mode`, following the `pair --help`
+workflow. Without a way to run the notebook, continue with saved-notebook
+authoring from a terminal.
 
 Inside notebook code mode, combine connection with the first inspection:
 
 ```python
-import marimo_studio.agent as studio_agent
+import marimo_studio
 
-workspace = studio_agent.current_workspace()
+workspace = marimo_studio.agent.current_workspace()
 status = await workspace.status()
 print(status)
 ```
@@ -84,7 +117,8 @@ for starter in starters:
 ```
 
 Pass the selected returned `starter.id` as `starter=` to `create_view()`.
-Resolve unavailable requirements before building. For an ordinary dashboard,
+Build a slide deck from the starter titled `Reveal.js slides`. Resolve
+unavailable requirements before building. For an ordinary dashboard,
 the default starter creates an editable HTML page with notebook output hosts:
 
 ```python
@@ -99,9 +133,9 @@ Use the requested name in place of `dashboard`. Finish that execution, then
 activate the view in a fresh code-mode call:
 
 ```python
-import marimo_studio.agent as studio_agent
+import marimo_studio
 
-await studio_agent.current_workspace().view("dashboard").show()
+await marimo_studio.agent.current_workspace().view("dashboard").show()
 ```
 
 `show()` activates the user's Studio tab. If build or activation fails, repair
@@ -113,9 +147,9 @@ view's preview URL to open the result.
 Acquire the view and inspect its editable documents:
 
 ```python
-import marimo_studio.agent as studio_agent
+import marimo_studio
 
-workspace = studio_agent.current_workspace()
+workspace = marimo_studio.agent.current_workspace()
 view = workspace.view("dashboard")
 inspection = await view.inspect()
 print(inspection.root)
@@ -130,11 +164,11 @@ dependencies, and toolchain. Preserve its accumulated decisions. Record durable
 audience, analytical goals, interaction priorities, and design choices there.
 Keep transient task status out of project instructions.
 Use the user's visual direction, then `DESIGN.md` if inspection lists it, then
-[Marimo's design guidance](https://raw.githubusercontent.com/marimo-team/marimo/refs/heads/main/DESIGN.md).
+[marimo's design guidance](https://raw.githubusercontent.com/marimo-team/marimo/refs/heads/main/DESIGN.md).
 Read the chosen design source before styling. Native notebook output is an
 opaque subtree, so theme it through projection variables on its host:
 `--marimo-cell-font`, `--marimo-cell-heading-font`, `--marimo-cell-foreground`,
-`--marimo-cell-accent` for links and Marimo controls, and
+`--marimo-cell-accent` for links and marimo controls, and
 `--marimo-cell-font-size` for Markdown. The
 [styling guide](https://marimo-team.github.io/marimo-studio/guide/styling.md)
 lists the complete set.
@@ -148,8 +182,8 @@ for cell in notebook.cells:
     print(cell.name, cell.definitions, cell.has_output_expression)
 ```
 
-Print selected fields rather than the full inspection record, which also
-contains the complete saved notebook. Read code for the chosen selector:
+Print selected fields. The full inspection record also contains the complete
+saved notebook. Read code for the chosen selector:
 
 ```python
 producer = await workspace.inspect_notebook(
@@ -187,7 +221,7 @@ focused components and use the project's formatter when available.
 | Needed result                                            | Authored host                                   |
 | -------------------------------------------------------- | ----------------------------------------------- |
 | Complete displayed cell, including controls and errors   | `<marimo-cell name="summary"></marimo-cell>`    |
-| One Python object rendered by Marimo                     | `<marimo-output value="chart"></marimo-output>` |
+| One Python object rendered by marimo                     | `<marimo-output value="chart"></marimo-output>` |
 | JSON-compatible data or eager dataframe for browser code | `<strong mo-value="metrics.total"></strong>`    |
 
 Read a cell's `name`, `definitions`, and `has_output_expression` before choosing
@@ -200,7 +234,7 @@ expression.
 Never copy notebook-derived values or analytical claims into frontend source.
 Project metrics, dates, categories, chart inputs, and analytical prose from
 named notebook results. Literal UI copy and design constants can stay in the
-view. Keep native Marimo output subtrees opaque and authored hosts inside
+view. Keep native marimo output subtrees opaque and authored hosts inside
 `#app-shell`.
 
 Custom renderers must consume current projections, subscribe to updates, and
@@ -214,9 +248,9 @@ contract. These conventions apply even when Lens is not installed.
 After editing, build and check source freshness in the same call:
 
 ```python
-import marimo_studio.agent as studio_agent
+import marimo_studio
 
-view = studio_agent.current_workspace().view("dashboard")
+view = marimo_studio.agent.current_workspace().view("dashboard")
 build = await view.build()
 inspection = await view.inspect()
 print(build.revision, inspection.freshness)
@@ -264,7 +298,7 @@ performed. Keep the notebook and view runnable.
 Read a packaged reference from the same installation:
 
 ```python
-import marimo_studio.agent
+import marimo_studio
 
 print(marimo_studio.agent.skill().file("references/projections.md").read_text())
 ```

{marimo_studio-0.2.0 → marimo_studio-0.2.2}/.agent-plugin/skills/marimo-studio/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
-  display_name: "Marimo Studio"
-  short_description: "Build focused views from Marimo notebooks"
+  display_name: "marimo-studio"
+  short_description: "Build focused views from marimo notebooks"
   default_prompt: "Use $marimo-studio to complete the requested notebook view work, preserving its live data connections and verifying the result."

{marimo_studio-0.2.0 → marimo_studio-0.2.2}/.agent-plugin/skills/marimo-studio/references/delivery.md

@@ -45,7 +45,7 @@ marimo-studio view preflight dashboard \
 
 Read every projection portability record and delivery diagnostic. Prepared
 must verify finite projection targets across the configured input states. Use
-WebAssembly when visitors must recompute unprepared states and the notebook can
+Browser when visitors must recompute unprepared states and the notebook can
 run through Pyodide.
 
 For Prepared controls, configure `states.yaml` in the selected view project.
@@ -63,7 +63,7 @@ from a preset, keeps its previous value and the combination matches no prepared
 state. Make each prepared control an independent input, and derive the dependent
 values in Python.
 
-The state walk can restore a cell whose inputs did not change from Marimo's
+The state walk can restore a cell whose inputs did not change from marimo's
 cache. The cache restores each definition of that cell separately, so objects
 that must stay shared, such as a CVXPY problem and the `Parameter` a function
 assigns before solving, return as independent copies. Build those objects inside
@@ -109,7 +109,7 @@ marimo-studio view export dashboard \
 Use `--runtime wasm` on both commands for a Browser export.
 
 Export runs the same preflight before committing its destination. Progress is
-written to stderr, including marimo-export prepared-state reuse and cache
+written to stderr, including `marimo-export` prepared-state reuse and cache
 activity. Each progress record names its owning source and nests that owner's
 event. With `--json`, stdout remains one terminal result and stderr contains
 JSON Lines progress and diagnostics. Events are flushed during environment
@@ -117,8 +117,9 @@ re-entry. Five-second heartbeats report the phase, state, elapsed time, and
 latest cache evidence. Unavailable state, cache, or active-cell evidence is
 `null`.
 
-Prepared keeps Python source on the build machine and publishes prepared
-outputs. WebAssembly includes saved notebook source for browser execution.
+Prepared keeps notebook source on the machine that runs the export and
+publishes prepared outputs. Browser includes saved notebook source for browser
+execution.
 Review public files, data URLs, authored browser code, and remote dependencies
 before publishing.
 

{marimo_studio-0.2.0 → marimo_studio-0.2.2}/.agent-plugin/skills/marimo-studio/references/lens.md

@@ -1,6 +1,6 @@
 # Lens in Studio views
 
-[Marimo Lens](https://marimo-team.github.io/marimo-lens/) lets a person mark a
+[Lens](https://marimo-team.github.io/marimo-lens/) lets a person mark a
 rendered result or authored page region and give that exact surface to a
 code-mode agent. When enabling Lens, addressing selections, or needing metadata
 details beyond the traceability conventions, import `marimo_lens.agent` and run
@@ -12,7 +12,7 @@ authoring follows the conventions directly, without Lens setup prompts or
 additional discovery calls.
 
 To enable feedback, install `marimo-studio[lens]` in the notebook environment
-and restart a running notebook. When the notebook imports no Lens, Marimo mounts
+and restart a running notebook. When the notebook imports no Lens, marimo mounts
 one and the development preview reuses it, so selections from the Notebook pane
 dock and the preview dock reach you together. Use that instance without adding a
 Lens cell or projection. For an explicitly authored Lens in another Python-runtime view,
@@ -28,7 +28,7 @@ None
 
 The final `None` keeps the Lens dock on the projected Studio surface. Rendering
 `studio_lens` as the notebook cell output also mounts a notebook dock. Studio
-skips Marimo's automatic Lens in a notebook that imports Lens, so `studio_lens`
+skips marimo's automatic Lens in a notebook that imports Lens, so `studio_lens`
 is the notebook's only Lens.
 
 Project the value once in each view that should collect feedback. Link custom
@@ -59,7 +59,7 @@ for a declared authored region. Each view owns these regions in its markup.
 Keep labels and rendering-source references on the selected root. Plain HTML
 regions without notebook input hosts have empty notebook provenance.
 
-Use the packaged Marimo Lens skill for the feedback lifecycle. Pass the
+Use the packaged Lens skill for the feedback lifecycle. Pass the
 captured `SelectionReference` to Lens activity and reveal calls. Use its
 `cells` as notebook provenance and `target["sources"]` for exact value selectors.
 For a DOM target, use `documentPath`,

{marimo_studio-0.2.0 → marimo_studio-0.2.2}/.agent-plugin/skills/marimo-studio/references/notebook-analysis.md

@@ -1,7 +1,9 @@
 # Notebook analysis
 
 Read when adding or changing notebook computation. Inspect the saved producers
-and the relevant live values before editing. Execute changed cells in the live
+and the relevant live values before editing. Create, edit, and run cells
+through `marimo._code_mode` while the notebook runs, because the kernel can
+overwrite direct file edits when it saves. Execute changed cells in the live
 notebook before checking the view.
 
 For dataset work, keep the notebook markdown-led and reactive. Build named
@@ -69,13 +71,13 @@ segment_summary_sql
 - Keep the graph acyclic. Define each shared variable once and let downstream
   cells react to it.
 
-### Parameterize dimensions with Marimo controls
+### Parameterize dimensions with marimo controls
 
 Create a control in one cell, display it as that cell's final expression, and
 read its `.value` from downstream transformation cells. Choose the control from
 the dimension's datatype and selection semantics:
 
-| Dimension                                 | Marimo control                                     |
+| Dimension                                 | marimo control                                     |
 | ----------------------------------------- | -------------------------------------------------- |
 | One value from a small categorical domain | `mo.ui.dropdown`                                   |
 | Several categorical values                | `mo.ui.multiselect`                                |

{marimo_studio-0.2.0 → marimo_studio-0.2.2}/.agent-plugin/skills/marimo-studio/references/projections.md

@@ -45,7 +45,7 @@ notebook already defines the intended value.
 
 Apply these conventions while authoring every view, even when Lens is not
 installed, so adding Lens exposes named targets and their source context.
-Keep metadata on authored regions and projection hosts, outside native Marimo
+Keep metadata on authored regions and projection hosts, outside native marimo
 output subtrees.
 
 Custom JavaScript rendering must consume live projections, handle their

{marimo_studio-0.2.0 → marimo_studio-0.2.2}/.agent-plugin/skills/marimo-studio/references/setup.md

@@ -1,24 +1,28 @@
 # Connect and select the environment
 
-Use the notebook's Python environment for Studio operations. If the briefing
-came from a disposable terminal environment, read the installed briefing after
-connecting to the notebook through Marimo's Code Mode sidebar or `marimo-pair`:
-
-```python
-import agent_plugins as ap
-
-print(ap.read("marimo-studio"))
-```
-
-`help(marimo_studio.agent)` exposes the same installed core briefing
-with Python API help. Reading guidance is passive. It does not bind a workspace
-or activate a view. Reuse instructions while the environment and installation
-remain the same. A terminal can obtain a briefing before connecting:
+Use the notebook's Python environment for Studio operations. A terminal can
+read the briefing before any notebook runs:
 
 ```console
 uvx --with marimo-studio agent-plugins read marimo-studio
 ```
 
+Inside the notebook kernel, `help(marimo_studio.agent)` prints the same core
+briefing with Python API help for the Studio version the notebook runs.
+Reading guidance is passive. It does not bind a workspace or activate a view.
+Reuse instructions while the environment and installation remain the same.
+
+`uvx marimo@latest pair notebook list` reports local servers started with
+`--no-token`, with their notebooks and sessions. Target the notebook the user
+opened in Studio with `marimo pair execute --url <URL> --file <PATH>`, passing
+the absolute `path` from that list. A relative file resolves against the
+agent's working directory. A notebook has a session once a browser opens it,
+and `view.show()` needs that open Studio tab. A server that requires a token
+stays out of the list. Ask the user for its URL and a token file, then run
+`pair notebook list --url <URL> --token-file <PATH>` to read its notebook
+paths. Pass `--token-file <PATH>` to every `pair` command, or rely on
+`MARIMO_TOKEN` when the user has set it.
+
 ## Work from a saved notebook
 
 Outside code mode, bind the saved notebook explicitly:

{marimo_studio-0.2.0 → marimo_studio-0.2.2}/.agent-plugin/skills/marimo-studio/references/verification.md

@@ -20,16 +20,16 @@ production build. Verify production through the exact URL and its displayed
 presentation revision, then assert the application's behavior.
 
 Building view source does not execute modified notebook cells. After editing
-notebook Python, run the changed cells in the live notebook, using Marimo's
+notebook Python, run the changed cells in the live notebook, using marimo's
 **Run all** action when appropriate. Static checks and isolated runtime
 validation do not update the live notebook session.
 
 Obtain its URL in code mode:
 
 ```python
-import marimo_studio.agent as studio_agent
+import marimo_studio
 
-view = studio_agent.current_workspace().view("dashboard")
+view = marimo_studio.agent.current_workspace().view("dashboard")
 print(await view.preview_url(runtime="server"))
 ```
 
@@ -39,7 +39,7 @@ waits through an external tool or interpreter. Waiting synchronously inside
 code mode can block the notebook work being awaited. The URL renders a separate top-level
 presentation with the server's authentication and document sandbox. Keep the
 notebook session open on an edit-mode server.
-Authenticate the chosen browser through Marimo's normal login. An API access
+Authenticate the chosen browser through marimo's normal login. An API access
 token authorizes URL lookup. It is never embedded in the returned URL.
 
 Outside code mode, supply the running server URL:

marimo_studio-0.2.2/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: marimo-studio
+Version: 0.2.2
+Summary: Custom views for marimo notebooks
+Author: Péter Ferenc Gyarmati
+Author-email: Péter Ferenc Gyarmati <dev.petergy@gmail.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Dist: agent-plugins>=0.2.4
+Requires-Dist: click>=8.2
+Requires-Dist: htpy>=26.5.1
+Requires-Dist: marimo==0.25.0
+Requires-Dist: marimo-export>=0.1.0
+Requires-Dist: markupsafe>=3
+Requires-Dist: packaging>=25
+Requires-Dist: tomli>=2 ; python_full_version < '3.11'
+Requires-Dist: tomlkit>=0.14
+Requires-Dist: tree-sitter>=0.25.2
+Requires-Dist: tree-sitter-javascript>=0.25.0
+Requires-Dist: watchdog>=6.0.0
+Requires-Dist: deno>=2.9.5 ; extra == 'deno'
+Requires-Dist: marimo-lens>=0.2.2 ; extra == 'lens'
+Requires-Dist: marimo-studio[deno,lens] ; extra == 'recommended'
+Requires-Python: >=3.10, <3.15
+Project-URL: Homepage, https://marimo-team.github.io/marimo-studio/
+Project-URL: Documentation, https://marimo-team.github.io/marimo-studio/
+Project-URL: Documentation Index, https://marimo-team.github.io/marimo-studio/llms.txt
+Project-URL: Repository, https://github.com/marimo-team/marimo-studio
+Project-URL: Issues, https://github.com/marimo-team/marimo-studio/issues
+Provides-Extra: deno
+Provides-Extra: lens
+Provides-Extra: recommended
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <a href="https://marimo-team.github.io/marimo-studio/">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://marimo-team.github.io/marimo-studio/brand/marimo-studio-lockup-horizontal-dark.svg">
+      <img alt="marimo-studio" src="https://marimo-team.github.io/marimo-studio/brand/marimo-studio-lockup-horizontal-light.svg" width="360">
+    </picture>
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://marimo-team.github.io/marimo-studio/examples/">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://marimo-team.github.io/marimo-studio/showcase/marimo-studio-wall-dark.webp">
+      <img alt="Four example notebooks, each heading a column of its views" src="https://marimo-team.github.io/marimo-studio/showcase/marimo-studio-wall-light.webp" width="100%">
+    </picture>
+  </a>
+</p>
+
+<p align="center">
+  <b>One reactive notebook. Many views.</b><br>
+  Turn a <a href="https://marimo.io/">marimo</a> notebook into reports, apps, and presentations, by hand or with a coding agent.
+</p>
+
+<p align="center">
+  <a href="https://github.com/marimo-team/marimo-studio/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/marimo-team/marimo-studio/actions/workflows/ci.yml/badge.svg"></a>
+  <a href="https://pypi.org/project/marimo-studio/"><img alt="PyPI" src="https://img.shields.io/pypi/v/marimo-studio.svg"></a>
+  <a href="https://pypi.org/project/marimo-studio/"><img alt="Python 3.10 through 3.14" src="https://img.shields.io/badge/python-3.10%E2%80%933.14-blue.svg"></a>
+</p>
+
+Studio keeps data, computation, and controls in the notebook and gives each
+audience its own view, such as a report, a dashboard, a lab, or a slide deck.
+Views render the notebook's live cells and controls, so changing an input
+updates the results that depend on it. Each view is its own frontend project,
+and every result it shows traces back to the notebook cell that computed it.
+
+Studio is experimental and changing rapidly. Pin `marimo-studio` and
+third-party view providers in saved projects.
+
+## Start with a coding agent
+
+Paste this request into Claude Code, Codex, or another terminal agent:
+
+```text
+Run `uvx --with marimo-studio agent-plugins read marimo-studio` and create
+a scrollytelling report and a slide deck explaining calculus basics.
+```
+
+The agent reads the instructions Studio ships for coding agents, starts a
+notebook with Studio in your browser, and writes the calculus in Python cells.
+It then builds both views and shows them beside the notebook. Change the topic,
+or name a notebook you already have. [uv](https://docs.astral.sh/uv/) supplies
+`uvx`.
+
+[Author with a coding agent](https://marimo-team.github.io/marimo-studio/guide/coding-agents)
+covers pairing with a running notebook and pointing at results with
+[Lens](https://marimo-team.github.io/marimo-lens/).
+
+## Start by hand
+
+```console
+uvx --with marimo-studio marimo edit analysis.py --sandbox --watch
+```
+
+Add a cell that displays a result, then click **Add view** in the Studio
+toolbar. Save the notebook if prompted, choose **HTML document**, and create
+the view. Notebook and Preview open side by side. Saving view source rebuilds
+Preview, and a failed build keeps the last successful view.
+
+![Notebook, Preview, and view source in Studio](https://marimo-team.github.io/marimo-studio/screenshots/studio-develop.png)
+
+[Getting started](https://marimo-team.github.io/marimo-studio/guide/getting-started)
+walks through a complete first view.
+
+## Examples
+
+Each example notebook serves three views, built with different frontend stacks.
+
+| Notebook                                                                                      | Views                                                                                                                                                                                                                                                                                                             | Built with                                                |
+| --------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
+| [Quadratic programs](https://marimo-team.github.io/marimo-studio/examples/quadratic-programs) | [Lecture](https://marimo-team.github.io/marimo-studio/examples/quadratic-programs/lecture/index.html) · [Explainer](https://marimo-team.github.io/marimo-studio/examples/quadratic-programs/explainer/index.html) · [Lab](https://marimo-team.github.io/marimo-studio/examples/quadratic-programs/lab/index.html) | React, Reveal.js, HTML, Svelte, D3                        |
+| [Rio 2016 athletes](https://marimo-team.github.io/marimo-studio/examples/athletes)            | [Overview](https://marimo-team.github.io/marimo-studio/examples/athletes/overview/index.html) · [Explorer](https://marimo-team.github.io/marimo-studio/examples/athletes/explorer/index.html) · [Field](https://marimo-team.github.io/marimo-studio/examples/athletes/field/index.html)                           | HTML, Svelte, Mosaic, Shower, Three.js                    |
+| [Earthquake watch](https://marimo-team.github.io/marimo-studio/examples/earthquakes)          | [Story](https://marimo-team.github.io/marimo-studio/examples/earthquakes/story/index.html) · [Operations](https://marimo-team.github.io/marimo-studio/examples/earthquakes/operations/index.html) · [Briefing](https://marimo-team.github.io/marimo-studio/examples/earthquakes/briefing/index.html)              | HTML, Observable Plot, React, MapLibre, Reveal.js, D3     |
+| [Building occupancy](https://marimo-team.github.io/marimo-studio/examples/occupancy)          | [Monitor](https://marimo-team.github.io/marimo-studio/examples/occupancy/monitor/index.html) · [Model review](https://marimo-team.github.io/marimo-studio/examples/occupancy/model-review/index.html) · [PDF report](https://marimo-team.github.io/marimo-studio/examples/occupancy/pdf-report/index.html)        | Notebook Kit, Observable Plot, React, Recharts, React PDF |
+
+## Run or export a view
+
+Serve the notebook's views as a live **Python** app:
+
+```console
+uvx --with marimo-studio marimo run analysis.py --sandbox
+```
+
+Export the `report` view with **Prepared** results as a static site:
+
+```console
+uvx marimo-studio view export report --target analysis.py --output dist/report
+```
+
+A Prepared export publishes the exported results and finite input states and
+keeps notebook source on the machine that runs the export. Views can also run
+Python in the visitor's **Browser**.
+[Run or export a view](https://marimo-team.github.io/marimo-studio/guide/run-and-share)
+compares what visitors receive.
+
+## Documentation
+
+[Guide](https://marimo-team.github.io/marimo-studio/guide/) ·
+[Examples](https://marimo-team.github.io/marimo-studio/examples/) ·
+[Reference](https://marimo-team.github.io/marimo-studio/reference/) ·
+[Compatibility](https://marimo-team.github.io/marimo-studio/reference/compatibility) ·
+[Troubleshooting](https://marimo-team.github.io/marimo-studio/guide/troubleshooting)
+
+Report bugs through [GitHub Issues](https://github.com/marimo-team/marimo-studio/issues).
+See the [security policy](https://github.com/marimo-team/marimo-studio/blob/main/SECURITY.md)
+for private reports.
+
+## License
+
+[Apache License 2.0](https://github.com/marimo-team/marimo-studio/blob/main/LICENSE).