Run notebook sandboxes with Pixi (#10697)

This PR remains draft until a Pixi release includes
[prefix-dev/pixi#6648](prefix-dev/pixi#6648).
The required upstream change has merged.

The notebook-owned lifecycle in the previous PR describes operations in
terms of a manifest and its realized environment. This PR supplies those
operations with Pixi and makes the choice explicit at the CLI:

```console
marimo edit --sandbox notebook.py       # uv
marimo edit --sandbox=pixi notebook.py  # pixi
```

```text
NotebookSandbox(source, "pixi")
    -> PixiBackendAdapter
    -> add / remove / sync / packages / launch
```

Pixi reads the same PEP 723 metadata. Package changes use Pixi script
commands, synchronization recovers the interpreter and environment root
from structured output, and package inspection reads `pixi list` JSON.
Launches layer the running marimo through `pixi exec`, so the shared
manifest does not pin marimo to the machine that opened it.

Selecting one manager does not import or probe the other. Pixi rejects
Python interpreter overrides, which its script environments cannot
honor, and falls back cleanly for app-host notebooks without script
metadata. CLI, adapter, and fixture tests cover both managers; the guide
documents the remaining Pixi limitations.

Author: manzt

docs/guides/package_management/inlining_dependencies.md

@@ -51,10 +51,49 @@ uv run notebook.py
 
 !!! note "Requires uv"
 
-    Sandboxed notebooks require the uv package manager
+    The default `--sandbox` backend requires the uv package manager
     ([installation
     instructions](https://docs.astral.sh/uv/getting-started/installation/)).
 
+## Pixi sandboxes
+
+If your notebook needs conda packages, use Pixi as the sandbox backend.
+[Install Pixi](https://pixi.prefix.dev/latest/installation/) with support for
+`pixi install --script` (available in Pixi 0.80.0). marimo checks this capability
+at startup; use `pixi self-update` if your installation predates it.
+
+```bash
+marimo edit --sandbox=pixi notebook.py
+```
+
+Pixi sandboxes resolve conda dependencies (declared under `[tool.pixi]`
+tables in the inline metadata) alongside PyPI dependencies, and require
+only pixi — uv is fetched through `pixi exec` when needed. A pixi
+notebook also runs standalone with `pixi run --script notebook.py`.
+
+```python
+# /// script
+# dependencies = ["marimo", "polars"]
+#
+# [tool.pixi.workspace]
+# channels = ["conda-forge"]
+#
+# [tool.pixi.dependencies]
+# gdal = "*"
+# ///
+```
+
+!!! warning "Pixi limitations"
+
+    - Pixi activation scripts and activation environment variables are not
+      applied when marimo launches the notebook sandbox.
+    - `marimo export html-wasm --execute` runs notebooks under
+      [Pyodide](https://pyodide.org)'s package set, which has no conda
+      equivalent: notebooks that rely on `[tool.pixi.dependencies]`
+      cannot be exported to WASM.
+    - The `--sandbox` flag on `marimo export` commands always uses uv,
+      so conda dependencies are not available during export.
+
 !!! tip "Solving the notebook reproducibility crisis"
 
     marimo's support for package sandboxing is only possible because marimo
@@ -276,5 +315,3 @@ pyproject: |
     - altair==<version>
 ---
 ```
-
-

frontend/src/__mocks__/requests.ts

@@ -136,8 +136,13 @@ export const MockRequestClient = {
       updateCellOutputs: vi.fn().mockResolvedValue({}),
       addPackage: vi.fn().mockResolvedValue({}),
       removePackage: vi.fn().mockResolvedValue({}),
-      getPackageList: vi.fn().mockResolvedValue({ packages: [] }),
-      getDependencyTree: vi.fn().mockResolvedValue({}),
+      getPackageList: vi.fn().mockResolvedValue({
+        packages: [],
+      }),
+      getDependencyTree: vi.fn().mockResolvedValue({
+        tree: null,
+        context: { kind: "package-manager", name: "pip" },
+      }),
       listSecretKeys: vi.fn().mockResolvedValue({ keys: [] }),
       writeSecret: vi.fn().mockResolvedValue({}),
       invokeAiTool: vi.fn().mockResolvedValue({}),

frontend/src/components/editor/chrome/panels/__tests__/packages-panel.test.tsx

@@ -0,0 +1,143 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { fireEvent, render, screen } from "@testing-library/react";
+import { Provider } from "jotai";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { MockRequestClient } from "@/__mocks__/requests";
+import { TooltipProvider } from "@/components/ui/tooltip";
+import { requestClientAtom } from "@/core/network/requests";
+import type {
+  DependencyTreeNode,
+  DependencyTreeResponse,
+} from "@/core/network/types";
+import { store } from "@/core/state/jotai";
+import PackagesPanel from "../packages-panel";
+
+const { openSettings } = vi.hoisted(() => ({
+  openSettings: vi.fn(),
+}));
+
+vi.mock("@/components/app-config/state", () => ({
+  useOpenSettingsToTab: () => ({ handleClick: openSettings }),
+}));
+
+const emptyTree: DependencyTreeNode = {
+  name: "<root>",
+  version: null,
+  tags: [],
+  dependencies: [],
+};
+
+const populatedTree: DependencyTreeNode = {
+  ...emptyTree,
+  dependencies: [
+    {
+      name: "polars",
+      version: "1.44.1",
+      tags: [],
+      dependencies: [
+        {
+          name: "numpy",
+          version: "2.5.2",
+          tags: [{ kind: "dedupe", value: "true" }],
+          dependencies: [],
+        },
+      ],
+    },
+  ],
+};
+
+function renderPanel(
+  context: DependencyTreeResponse["context"],
+  tree: DependencyTreeNode = emptyTree,
+) {
+  const getPackageList = vi.fn().mockResolvedValue({ packages: [] });
+  store.set(
+    requestClientAtom,
+    MockRequestClient.create({
+      getPackageList,
+      getDependencyTree: vi.fn().mockResolvedValue({ tree, context }),
+    }),
+  );
+
+  return {
+    getPackageList,
+    ...render(
+      <Provider store={store}>
+        <TooltipProvider>
+          <PackagesPanel />
+        </TooltipProvider>
+      </Provider>,
+    ),
+  };
+}
+
+describe("PackagesPanel", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it.each(["pixi", "uv"] as const)(
+    "shows the effective %s sandbox backend as a fixed context",
+    async (backend) => {
+      const { getPackageList } = renderPanel({ kind: "sandbox", backend });
+
+      expect(
+        await screen.findByPlaceholderText(
+          `Add packages to ${backend} sandbox...`,
+        ),
+      ).toBeInTheDocument();
+      expect(screen.getByText(`${backend} sandbox`)).toBeInTheDocument();
+      expect(
+        screen.queryByRole("button", { name: "Change package manager" }),
+      ).not.toBeInTheDocument();
+      expect(
+        screen.queryByRole("button", { name: "List" }),
+      ).not.toBeInTheDocument();
+      expect(
+        screen.queryByRole("button", { name: "Tree" }),
+      ).not.toBeInTheDocument();
+      expect(getPackageList).not.toHaveBeenCalled();
+    },
+  );
+
+  it("explains the filtered empty state for a Pixi sandbox", async () => {
+    renderPanel({ kind: "sandbox", backend: "pixi" });
+
+    expect(await screen.findByText("No PyPI dependencies")).toBeInTheDocument();
+    expect(
+      screen.getByText("Conda dependencies are not shown in this panel."),
+    ).toBeInTheDocument();
+  });
+
+  it("labels a dependency whose subtree was already displayed", async () => {
+    renderPanel({ kind: "sandbox", backend: "pixi" }, populatedTree);
+
+    fireEvent.click(await screen.findByRole("treeitem", { name: /polars/ }));
+
+    expect(screen.getByText("already in tree")).toBeInTheDocument();
+    expect(screen.queryByText("cycle")).not.toBeInTheDocument();
+  });
+
+  it("keeps the configured package manager changeable outside a sandbox", async () => {
+    const { getPackageList } = renderPanel({
+      kind: "package-manager",
+      name: "pip",
+    });
+
+    expect(
+      await screen.findByPlaceholderText("Install packages with pip..."),
+    ).toBeInTheDocument();
+    const changeManager = screen.getByRole("button", {
+      name: "Change package manager",
+    });
+
+    fireEvent.click(changeManager);
+
+    expect(openSettings).toHaveBeenCalledWith("packageManagementAndData");
+    expect(screen.getByText("environment")).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "List" })).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Tree" })).toBeInTheDocument();
+    expect(getPackageList).toHaveBeenCalledOnce();
+  });
+});