diff --git a/crates/core/src/value.rs b/crates/core/src/value.rs
index c531de4dc..459372d31 100644
--- a/crates/core/src/value.rs
+++ b/crates/core/src/value.rs
@@ -21,10 +21,18 @@ pub enum CellError {
     Calc,
     /// Circular reference that could not be resolved (shown as 0 by Excel; we keep it explicit).
     Circ,
+    /// A Python cell's code raised an error, or Python stopped.
+    Python,
+    /// A Python cell is waiting to run.
+    Busy,
+    /// A Python cell ran longer than the time limit.
+    Timeout,
+    /// Python can't run here: the workbook's content isn't enabled, or this build has no Python.
+    Blocked,
 }
 
 impl CellError {
-    pub const ALL: [CellError; 10] = [
+    pub const ALL: [CellError; 14] = [
         CellError::Null,
         CellError::Div0,
         CellError::Value,
@@ -35,6 +43,10 @@ impl CellError {
         CellError::GettingData,
         CellError::Spill,
         CellError::Calc,
+        CellError::Python,
+        CellError::Busy,
+        CellError::Timeout,
+        CellError::Blocked,
     ];
     pub fn as_str(&self) -> &'static str {
         match self {
@@ -49,9 +61,16 @@ impl CellError {
             CellError::Spill => "#SPILL!",
             CellError::Calc => "#CALC!",
             CellError::Circ => "#CIRC!",
+            CellError::Python => "#PYTHON!",
+            CellError::Busy => "#BUSY!",
+            CellError::Timeout => "#TIMEOUT!",
+            CellError::Blocked => "#BLOCKED!",
         }
     }
-    /// `ERROR.TYPE` number.
+    /// `ERROR.TYPE` number. Microsoft documents 1 to 8; 9 (#SPILL!), 11 (#BLOCKED!) and 14 (#CALC!)
+    /// are the numbers Excel returns. Microsoft documents no number for #PYTHON!, #BUSY! or
+    /// #TIMEOUT!: 19, 20 and 21 are GridCraft's own choice, after the numbers Excel is known to use,
+    /// and may change if Excel's numbers become known.
     pub fn code(&self) -> u32 {
         match self {
             CellError::Null => 1,
@@ -65,6 +84,10 @@ impl CellError {
             CellError::Spill => 9,
             CellError::Calc => 14,
             CellError::Circ => 15,
+            CellError::Blocked => 11,
+            CellError::Python => 19,
+            CellError::Busy => 20,
+            CellError::Timeout => 21,
         }
     }
     pub fn parse(s: &str) -> Option<CellError> {
diff --git a/crates/engine/src/cmd/analysis.rs b/crates/engine/src/cmd/analysis.rs
index 6225b4934..ffcbccf94 100644
--- a/crates/engine/src/cmd/analysis.rs
+++ b/crates/engine/src/cmd/analysis.rs
@@ -1124,13 +1124,13 @@ fn write_report(s: &mut Session, p: &Json, tool: &str, g: Grid) -> Result<Json>
         let sh = cx.sheet_mut(si)?;
         for c in &occupied {
             let style = sh.style_id(*c);
-            sh.set_cell(*c, Cell { value: Value::Empty, formula: None, style });
+            sh.set_cell(*c, Cell { value: Value::Empty, formula: None, style, py: None });
         }
         let mut touched = occupied.clone();
         for ((r, c), v) in &g.cells {
             let cell = CellRef::new(at.row + r, at.col + c);
             let style = pct_styles.get(&cell).copied().unwrap_or_else(|| sh.style_id(cell));
-            sh.set_cell(cell, Cell { value: v.clone(), formula: None, style });
+            sh.set_cell(cell, Cell { value: v.clone(), formula: None, style, py: None });
             touched.push(cell);
         }
         for c in touched {
diff --git a/crates/engine/src/cmd/data.rs b/crates/engine/src/cmd/data.rs
index fcab9db71..0c255a689 100644
--- a/crates/engine/src/cmd/data.rs
+++ b/crates/engine/src/cmd/data.rs
@@ -976,7 +976,16 @@ fn text_to_columns(s: &mut Session, p: &Json) -> Result<Json> {
             }
         }
         for (c, t) in out {
-            let cell = super::edit::input_to_cell(&t, sheet, c, &mut cx.wb).unwrap_or(None);
+            let cell = match super::edit::input_to_cell(&t, sheet, c, &mut cx.wb) {
+                Ok(cell) => cell,
+                // `=PY(…)` doesn't make a Python cell (that takes python.set): the piece is kept
+                // as text rather than lost.
+                Err(_) if gridcraft_model::python::is_py_formula(&t) => {
+                    let style = cx.wb.sheet(sheet).map(|sh| sh.style_id(c)).unwrap_or_default();
+                    Some(Cell { value: Value::text(t.as_str()), formula: None, style, py: None })
+                }
+                Err(_) => None,
+            };
             let shm = cx.sheet_mut(sheet)?;
             match cell {
                 Some(x) => shm.set_cell(c, x),
diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs
index 28ce338d6..64b26b022 100644
--- a/crates/engine/src/cmd/edit.rs
+++ b/crates/engine/src/cmd/edit.rs
@@ -118,24 +118,30 @@ pub fn specs() -> Vec<CommandSpec> {
 
 // ---------------------------------------------------------------- entry
 
+/// Typing `=PY(` doesn't make a Python cell; this says what does.
+pub(crate) const PY_FORMULA: &str = "Python cells are made with the python.set command (the code as `code`), not by typing =PY(…).";
+
 /// What typing `input` into a cell produces (constant or formula, plus an automatic number
 /// format). Inherits the destination's cell, row or column style, including its number
 /// format, before parsing. Errors when the formula can't be parsed.
 pub(crate) fn input_to_cell(input: &str, sheet: usize, at: CellRef, wb: &mut gridcraft_model::Workbook) -> Result<Option<Cell>> {
     let style = wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default();
     if input.is_empty() {
-        let c = Cell { value: Value::Empty, formula: None, style };
+        let c = Cell { value: Value::Empty, formula: None, style, py: None };
         return Ok(if c.is_blank() { None } else { Some(c) });
     }
     let fmt_is_text = wb.styles.get(style).num_fmt.as_str() == "@";
     if fmt_is_text {
-        return Ok(Some(Cell { value: Value::text(input), formula: None, style }));
+        return Ok(Some(Cell { value: Value::text(input), formula: None, style, py: None }));
     }
     let is_formula = input.starts_with('=')
         || (input.len() > 1
             && (input.starts_with('+') || input.starts_with('-'))
             && gridcraft_core::parse::parse_number_text(input).is_none()
             && input.chars().nth(1).is_some_and(|c| c.is_ascii_alphabetic() || c == '('));
+    if is_formula && gridcraft_model::python::is_py_formula(input) {
+        return Err(EngineError::Other(PY_FORMULA.into()));
+    }
     if is_formula {
         let body = input.strip_prefix('=').unwrap_or(input);
         let expr = wb.name_call_case(parse_typed_formula(body)?);
@@ -187,7 +193,7 @@ pub(crate) fn input_to_cell(input: &str, sheet: usize, at: CellRef, wb: &mut gri
     if input.contains('\n') && !wb.styles.get(style).align.wrap {
         style = wb.styles.derive(style, |s| s.align.wrap = true);
     }
-    Ok(Some(Cell { value: parsed.value, formula: None, style }))
+    Ok(Some(Cell { value: parsed.value, formula: None, style, py: None }))
 }
 
 /// Parses a formula as it is typed (without the `=`). Excel closes missing parentheses for you,
@@ -255,7 +261,7 @@ fn cell_set(s: &mut Session, p: &Json) -> Result<Json> {
             let sh = cx.sheet_mut(sheet)?;
             // The array takes the whole range: other cells in it lose their contents.
             for c in range.iter().skip(1).take(1_000_000) {
-                if let Some(old) = sh.cells.get(c).filter(|x| !x.value.is_empty() || x.formula.is_some()) {
+                if let Some(old) = sh.cells.get(c).filter(|x| x.has_content()) {
                     let style = old.style;
                     sh.set_cell(c, Cell { style, ..Cell::default() });
                 }
@@ -327,10 +333,14 @@ fn range_set_values(s: &mut Session, p: &Json) -> Result<Json> {
                         value: Value::number(n.as_f64().unwrap_or(0.0)),
                         formula: None,
                         style: cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default(),
+                        py: None,
+                    }),
+                    Json::Bool(b) => Some(Cell {
+                        value: Value::Bool(*b),
+                        formula: None,
+                        style: cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default(),
+                        py: None,
                     }),
-                    Json::Bool(b) => {
-                        Some(Cell { value: Value::Bool(*b), formula: None, style: cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default() })
-                    }
                     // Text as given: no date or number reading, and a leading `'` is part of the
                     // text rather than the marker that makes it text. A formula is still a
                     // formula, which is what the ticket asks for and what `=` means in a cell.
@@ -340,7 +350,7 @@ fn range_set_values(s: &mut Session, p: &Json) -> Result<Json> {
                         if text.contains('\n') && !cx.wb.styles.get(style).align.wrap {
                             style = cx.wb.styles.derive(style, |s| s.align.wrap = true);
                         }
-                        Some(Cell { value: Value::Text(text.as_str().into()), formula: None, style })
+                        Some(Cell { value: Value::Text(text.as_str().into()), formula: None, style, py: None })
                     }
                     _ => input_to_cell(&input, sheet, at, &mut cx.wb)?,
                 };
@@ -743,8 +753,8 @@ fn go_to_special(s: &mut Session, p: &Json) -> Result<Json> {
         let v = sheet.value(c);
         let ok = match kind {
             "blanks" => v.is_empty(),
-            "constants" => cell.is_some_and(|x| x.formula.is_none() && !x.value.is_empty()),
-            "formulas" => cell.is_some_and(|x| x.formula.is_some()),
+            "constants" => cell.is_some_and(|x| x.formula.is_none() && x.py.is_none() && !x.value.is_empty()),
+            "formulas" => cell.is_some_and(|x| x.formula.is_some() || x.py.is_some()),
             "comments" | "notes" => sheet.comments.contains_key(&c),
             "errors" => v.is_error(),
             "numbers" => v.is_number(),
@@ -920,7 +930,7 @@ fn slide_together(wb: &gridcraft_model::Workbook, sheet: usize, areas: &[RangeRe
         for c in cells {
             let Some(to) = c.offset(dr, dc) else { continue };
             let style = src.cell(c).map(|x| x.style).unwrap_or_default();
-            dst.set_cell(to, Cell { value: src.value(c), formula: None, style });
+            dst.set_cell(to, Cell { value: src.value(c), formula: None, style, py: None });
             if let Some(picture) = src.cell_pictures.get(&c) {
                 dst.cell_pictures.insert(to, picture.clone());
             }
@@ -1183,7 +1193,11 @@ fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
                         };
                         let src_val = src_sheet.value(sc);
                         let src_picture = if cut_move { moved_pictures.get(&sc) } else { src_sheet.cell_pictures.get(&sc) }.cloned();
-                        if skip_blanks && src_picture.is_none() && src_val.is_empty() && src_cell.as_ref().is_none_or(|x| x.formula.is_none()) {
+                        if skip_blanks
+                            && src_picture.is_none()
+                            && src_val.is_empty()
+                            && src_cell.as_ref().is_none_or(|x| x.formula.is_none() && x.py.is_none())
+                        {
                             continue;
                         }
                         let old = cx.wb.sheet(dest_sheet).and_then(|sh| sh.cell(dest)).cloned().unwrap_or_default();
@@ -1218,6 +1232,30 @@ fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
                                 gridcraft_formula::adjust::shift_relative(e, dest.row as i64 - sc.row as i64, dest.col as i64 - sc.col as i64);
                             Some(std::sync::Arc::new(Formula { dynamic: f.dynamic, ..Formula::from_expr(moved) }))
                         };
+                        // A Python cell's code travels with it. Cut to another sheet, it keeps
+                        // reading the cells its `xl()` references named on its original sheet, as
+                        // a moved formula does: they are qualified with that sheet before the
+                        // workbook-wide move adjustment below.
+                        let moved_py = |cell: &Cell| -> Option<std::sync::Arc<gridcraft_model::PyCode>> {
+                            let py = cell.py.clone()?;
+                            if !cut_move || dest_sheet == clip.sheet {
+                                return Some(py);
+                            }
+                            let qualified = gridcraft_model::python::rewrite_xl(&py.code, |reference| {
+                                let e = gridcraft_formula::parse(reference).ok()?.map(&mut |x| match x {
+                                    gridcraft_formula::Expr::Ref(mut r) if r.sheet == gridcraft_formula::SheetSel::Current => {
+                                        r.sheet = gridcraft_formula::SheetSel::Named(src_sheet_name.clone());
+                                        gridcraft_formula::Expr::Ref(r)
+                                    }
+                                    other => other,
+                                });
+                                Some(gridcraft_formula::print(&e))
+                            });
+                            Some(match qualified {
+                                Some(code) => std::sync::Arc::new(gridcraft_model::PyCode { code, ..(*py).clone() }),
+                                None => py,
+                            })
+                        };
                         if link {
                             let sheet_prefix = if dest_sheet == clip.sheet && same_doc {
                                 String::new()
@@ -1226,6 +1264,7 @@ fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
                             };
                             new.formula = Some(std::sync::Arc::new(Formula::new(&format!("={sheet_prefix}{}", sc.a1()))));
                             new.value = Value::Empty;
+                            new.py = None;
                             new_picture = None;
                         } else {
                             let sc_cell = src_cell.clone().unwrap_or_default();
@@ -1234,6 +1273,7 @@ fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
                                     new_picture = src_picture.clone();
                                     new.formula = shift(&sc_cell);
                                     new.value = if new.formula.is_some() { Value::Empty } else { sc_cell.value.clone() };
+                                    new.py = moved_py(&sc_cell);
                                     let st = map_style(sc_cell.style, &mut cx.wb);
                                     new.style = if what == What::AllExceptBorders {
                                         let borders = cx.wb.styles.get(old.style).borders;
@@ -1246,6 +1286,7 @@ fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
                                     new_picture = src_picture.clone();
                                     new.formula = shift(&sc_cell);
                                     new.value = if new.formula.is_some() { Value::Empty } else { sc_cell.value.clone() };
+                                    new.py = moved_py(&sc_cell);
                                     if what == What::FormulasAndNumberFormats {
                                         let nf = src_wb.styles.get(sc_cell.style).num_fmt.clone();
                                         new.style = cx.wb.styles.derive(old.style, |s| s.num_fmt = nf);
@@ -1254,6 +1295,7 @@ fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
                                 What::Values | What::ValuesAndNumberFormats => {
                                     new_picture = src_picture.clone();
                                     new.formula = None;
+                                    new.py = None;
                                     new.value = src_val.clone();
                                     if what == What::ValuesAndNumberFormats {
                                         let nf = src_wb.styles.get(sc_cell.style).num_fmt.clone();
@@ -1267,6 +1309,7 @@ fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
                             if op != "none"
                                 && matches!(what, What::All | What::Values | What::ValuesAndNumberFormats | What::Formulas)
                                 && new.formula.is_none()
+                                && new.py.is_none()
                             {
                                 if old_picture.is_some() || new_picture.is_some() {
                                     new_picture = None;
@@ -1443,6 +1486,42 @@ pub(crate) fn rewrite_all_formulas(wb: &mut gridcraft_model::Workbook, target: &
             n.formula = gridcraft_formula::print(&new);
         }
     }
+    rewrite_python_refs(wb, &|host, expr| gridcraft_formula::adjust::adjust(expr, host, target, e));
+}
+
+/// Rewrites the `xl("…")` literals in every Python cell with `f`, which maps a reference held on
+/// sheet `host` to its new form. Every reference-moving edit (insert and delete of lines or cells,
+/// cut-move, sheet rename and delete) runs it, as it adjusts formulas. A literal is only replaced
+/// when the reference it names changed, and text that doesn't parse is kept.
+pub(crate) fn rewrite_python_refs(wb: &mut gridcraft_model::Workbook, f: &impl Fn(&str, gridcraft_formula::Expr) -> gridcraft_formula::Expr) {
+    for si in 0..wb.sheets.len() {
+        let Some(sh) = wb.sheets.get(si) else { continue };
+        let host = sh.name.clone();
+        let mut new_code: Vec<(CellRef, String)> = Vec::new();
+        for (c, cell) in sh.cells.iter() {
+            let Some(py) = &cell.py else { continue };
+            let changed = gridcraft_model::python::rewrite_xl(&py.code, |reference| {
+                let expr = gridcraft_formula::parse(reference).ok()?;
+                let before = gridcraft_formula::print(&expr);
+                let after = gridcraft_formula::print(&f(&host, expr));
+                (after != before).then_some(after)
+            });
+            if let Some(code) = changed {
+                new_code.push((c, code));
+            }
+        }
+        if new_code.is_empty() {
+            continue;
+        }
+        let Some(sh) = wb.sheet_mut(si) else { continue };
+        for (c, code) in new_code {
+            if let Some(cell) = sh.cells.get_mut(c)
+                && let Some(py) = cell.py.as_mut()
+            {
+                std::sync::Arc::make_mut(py).code = code;
+            }
+        }
+    }
 }
 
 // ---------------------------------------------------------------- clear
@@ -1481,6 +1560,7 @@ fn clear(s: &mut Session, p: &Json, what: &str) -> Result<Json> {
                 for (_, cell) in cells.iter_mut() {
                     let checkbox = cx.wb.styles.get(cell.style).num_fmt.as_str() == "checkbox";
                     cell.formula = None;
+                    cell.py = None;
                     if checkbox && uncheck_only {
                         cell.value = Value::Bool(false);
                     } else {
diff --git a/crates/engine/src/cmd/extra.rs b/crates/engine/src/cmd/extra.rs
index 60ffa102b..364b81ed7 100644
--- a/crates/engine/src/cmd/extra.rs
+++ b/crates/engine/src/cmd/extra.rs
@@ -1211,6 +1211,7 @@ fn toggle_checkbox(s: &mut Session, p: &Json) -> Result<Json> {
             let sh = cx.sheet_mut(si)?;
             if let Some(cell) = sh.cells.get_mut(c)
                 && cell.formula.is_none()
+                && cell.py.is_none()
             {
                 // An empty checkbox cell counts as FALSE.
                 let next = match cell.value {
diff --git a/crates/engine/src/cmd/forecast.rs b/crates/engine/src/cmd/forecast.rs
index b7472fd22..c45c1179f 100644
--- a/crates/engine/src/cmd/forecast.rs
+++ b/crates/engine/src/cmd/forecast.rs
@@ -315,7 +315,7 @@ fn forecast_sheet(s: &mut Session, p: &Json) -> Result<Json> {
         let vstyle = cx.wb.styles.derive(StyleId::DEFAULT, |st| st.num_fmt = vfmt.clone());
         let mut sheet = Sheet::new(sheet_name.clone());
         let put = |sheet: &mut Sheet, row: u32, col: u32, v: Value, style: StyleId| {
-            sheet.set_cell(CellRef::new(row, col), Cell { value: v, formula: None, style });
+            sheet.set_cell(CellRef::new(row, col), Cell { value: v, formula: None, style, py: None });
         };
         let formula = |sheet: &mut Sheet, row: u32, col: u32, text: String, style: StyleId| {
             let mut cell = Cell::formula(Formula::new(&text));
diff --git a/crates/engine/src/cmd/format.rs b/crates/engine/src/cmd/format.rs
index 10dd2989d..30efbf5a6 100644
--- a/crates/engine/src/cmd/format.rs
+++ b/crates/engine/src/cmd/format.rs
@@ -665,8 +665,7 @@ fn merge(s: &mut Session, p: &Json, how: &str) -> Result<Json> {
                         let others: Vec<CellRef> = sh.cells.iter_range(*r).map(|(c, _)| c).filter(|c| *c != r.start).collect();
                         for c in others {
                             if let Some(mut cell) = sh.cells.get(c).cloned() {
-                                cell.value = gridcraft_core::Value::Empty;
-                                cell.formula = None;
+                                cell.clear_content();
                                 sh.set_cell(c, cell);
                             }
                             touched.push((sheet, c));
diff --git a/crates/engine/src/cmd/formulas.rs b/crates/engine/src/cmd/formulas.rs
index 88c4cc76c..edeefb196 100644
--- a/crates/engine/src/cmd/formulas.rs
+++ b/crates/engine/src/cmd/formulas.rs
@@ -623,7 +623,7 @@ fn paste_name(s: &mut Session, p: &Json) -> Result<Json> {
                 let sh = cx.sheet_mut(sheet)?;
                 let style = sh.style_id(c);
                 // The second column holds the refers-to text as a text value, with no formula.
-                sh.set_cell(c, Cell { value: Value::text(text.as_str()), formula: None, style });
+                sh.set_cell(c, Cell { value: Value::text(text.as_str()), formula: None, style, py: None });
                 cx.touch(sheet, c);
             }
         }
diff --git a/crates/engine/src/cmd/insert.rs b/crates/engine/src/cmd/insert.rs
index 8274dfeed..a37084523 100644
--- a/crates/engine/src/cmd/insert.rs
+++ b/crates/engine/src/cmd/insert.rs
@@ -445,7 +445,10 @@ fn write_totals(sh: &mut Sheet, ti: usize) {
         let c = CellRef::new(row, t.range.start.col + i as u32);
         if let Some(code) = col.totals.subtotal_code() {
             let f = format!("=SUBTOTAL({code},{}[{}])", t.name, col.name);
-            sh.set_cell(c, Cell { formula: Some(std::sync::Arc::new(Formula::new(&f))), value: gridcraft_core::Value::Empty, style: sh.style_id(c) });
+            sh.set_cell(
+                c,
+                Cell { formula: Some(std::sync::Arc::new(Formula::new(&f))), value: gridcraft_core::Value::Empty, style: sh.style_id(c), py: None },
+            );
         } else if let Some(l) = &col.totals_label {
             sh.set_value(c, gridcraft_core::Value::text(l.as_str()));
         } else {
@@ -1260,7 +1263,7 @@ fn insert_link(s: &mut Session, p: &Json) -> Result<Json> {
         });
         let sh = cx.sheet_mut(sheet)?;
         if let Some(t) = text.clone().or_else(|| sh.value(at).is_empty().then(|| target.clone())) {
-            sh.set_cell(at, Cell { value: gridcraft_core::Value::text(t.as_str()), formula: None, style: link_style });
+            sh.set_cell(at, Cell { value: gridcraft_core::Value::text(t.as_str()), formula: None, style: link_style, py: None });
         } else {
             sh.set_style(at, link_style);
         }
diff --git a/crates/engine/src/cmd/inspect.rs b/crates/engine/src/cmd/inspect.rs
index f9d5f9dc3..06a2c08b0 100644
--- a/crates/engine/src/cmd/inspect.rs
+++ b/crates/engine/src/cmd/inspect.rs
@@ -9,7 +9,7 @@ pub fn specs() -> Vec<CommandSpec> {
     vec![
         cmd!(query "document.inspect", "Inspect Workbook", [], None, "{} → sheets, selection, names, tables, charts, dirty, trust (local|fromFile), history", has_doc, inspect),
         cmd!(query "sheet.read", "Read Range", [], None, "{range?: \"A1:D10\" (default: used range), sheet?, formulas?: bool, formatted?: bool} → rows of values", has_doc, read),
-        cmd!(query "cell.get", "Get Cell", [], None, "{cell?, sheet?} → value, formula, display text, style, comment, link", has_doc, cell_get),
+        cmd!(query "cell.get", "Get Cell", [], None, "{cell?, sheet?} → value, formula, display text, style, comment, link, python {code, output, typeName, preview, stale}", has_doc, cell_get),
         cmd!(query "selection.stats", "Selection Statistics", [], None, "{} → count, sum, average, min, max", has_doc, sel_stats),
         cmd!(query "history.list", "Undo History", [], None, "{} → undo/redo labels, grouping (an undo group is open)", has_doc, history),
         cmd!(query "app.commands", "List Commands", [], None, "{search?} → ids, labels, params", always, list_commands),
@@ -137,6 +137,13 @@ fn cell_get(s: &mut Session, p: &Json) -> Result<Json> {
         "merge": sh.merge_at(c).map(|m| m.a1()),
         "comment": sh.comments.get(&c),
         "hyperlink": sh.hyperlinks.get(&c),
+        "python": cell.and_then(|x| x.py.as_deref()).map(|py| json!({
+            "code": py.code,
+            "output": if py.object { "object" } else { "value" },
+            "typeName": py.output.as_ref().map(|o| o.type_name.as_str()),
+            "preview": py.output.as_ref().map(|o| o.preview.as_str()),
+            "stale": py.stale,
+        })),
     }))
 }
 
diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index ef6714eea..2f1becd23 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -476,13 +476,18 @@ fn check_arrays(old: &Workbook, new: &Workbook) -> Result<()> {
     Ok(())
 }
 
-/// Two cells hold the same value or formula (formats aside).
+/// Two cells hold the same value, formula or Python code (formats aside; a Python cell's result
+/// is not something the person edits).
 fn same_content(a: Option<&gridcraft_model::Cell>, b: Option<&gridcraft_model::Cell>) -> bool {
-    let empty = |c: Option<&gridcraft_model::Cell>| c.is_none_or(|c| c.formula.is_none() && c.value.is_empty());
+    let empty = |c: Option<&gridcraft_model::Cell>| c.is_none_or(|c| !c.has_content());
     match (a, b) {
         (Some(a), Some(b)) => match (&a.formula, &b.formula) {
             (Some(x), Some(y)) => x.text == y.text && x.array == y.array,
-            (None, None) => a.value == b.value,
+            (None, None) => match (&a.py, &b.py) {
+                (Some(x), Some(y)) => x.code == y.code && x.object == y.object,
+                (None, None) => a.value == b.value,
+                _ => false,
+            },
             _ => false,
         },
         _ => empty(a) && empty(b),
diff --git a/crates/engine/src/cmd/pivot.rs b/crates/engine/src/cmd/pivot.rs
index 164ae4449..2cf76a6ae 100644
--- a/crates/engine/src/cmd/pivot.rs
+++ b/crates/engine/src/cmd/pivot.rs
@@ -812,7 +812,10 @@ fn show_details(s: &mut Session, p: &Json) -> Result<Json> {
             }
         }
         for (c, h) in src.headers.iter().enumerate() {
-            sh.set_cell(CellRef::new(0, c as u32), Cell { value: gridcraft_core::Value::text(h.as_str()), formula: None, style: StyleId::default() });
+            sh.set_cell(
+                CellRef::new(0, c as u32),
+                Cell { value: gridcraft_core::Value::text(h.as_str()), formula: None, style: StyleId::default(), py: None },
+            );
         }
         for (r, i) in records.iter().enumerate() {
             let Some(rec) = src.rows.get(*i) else { continue };
@@ -821,7 +824,7 @@ fn show_details(s: &mut Session, p: &Json) -> Result<Json> {
                 if v.is_empty() && style == StyleId::default() {
                     continue;
                 }
-                sh.set_cell(CellRef::new(r as u32 + 1, c as u32), Cell { value: v.clone(), formula: None, style });
+                sh.set_cell(CellRef::new(r as u32 + 1, c as u32), Cell { value: v.clone(), formula: None, style, py: None });
             }
         }
         let name = sh.name.clone();
diff --git a/crates/engine/src/cmd/sheet.rs b/crates/engine/src/cmd/sheet.rs
index ea615cb83..44a3c9d60 100644
--- a/crates/engine/src/cmd/sheet.rs
+++ b/crates/engine/src/cmd/sheet.rs
@@ -790,6 +790,7 @@ fn delete_sheet(s: &mut Session, p: &Json) -> Result<Json> {
                 }
             }
         }
+        super::edit::rewrite_python_refs(&mut cx.wb, &|_, e| gridcraft_formula::adjust::delete_sheet(e, &name, &order));
         cx.wb.names.retain(|n| n.scope != Some(i));
         for n in cx.wb.names.iter_mut() {
             if let Some(sc) = n.scope.as_mut()
@@ -867,6 +868,7 @@ fn rename_sheet(s: &mut Session, p: &Json) -> Result<Json> {
                 n.formula = gridcraft_formula::print(&gridcraft_formula::adjust::rename_sheet(e, &old, &name));
             }
         }
+        super::edit::rewrite_python_refs(&mut cx.wb, &|_, e| gridcraft_formula::adjust::rename_sheet(e, &old, &name));
         cx.structural = true;
         Ok(Json::Null)
     })
diff --git a/crates/engine/src/cmd/solver.rs b/crates/engine/src/cmd/solver.rs
index 21dbc1926..a8337ed13 100644
--- a/crates/engine/src/cmd/solver.rs
+++ b/crates/engine/src/cmd/solver.rs
@@ -331,7 +331,8 @@ fn parse_model(s: &Session, p: &Json) -> Result<Model> {
     }
     let mut seen = std::collections::HashSet::new();
     vars.retain(|c| seen.insert(*c));
-    if vars.iter().any(|c| sh.cell(*c).is_some_and(|c| c.formula.is_some())) {
+    // Python cells count as formulas: a solution written over one would lose its code.
+    if vars.iter().any(|c| sh.cell(*c).is_some_and(|c| c.formula.is_some() || c.py.is_some())) {
         return Err(EngineError::Other("Variable cells must hold constants, not formulas.".into()));
     }
     let mut cons = Vec::new();
@@ -1899,7 +1900,7 @@ fn write_reports(cx: &mut Ctx, at: usize, built: Vec<(String, Lines)>) -> Vec<St
         let mut sheet = Sheet::new(name);
         for (r, c, v, b) in lines {
             let style = if b { bold } else { gridcraft_model::StyleId::DEFAULT };
-            sheet.set_cell(CellRef::new(r, c), Cell { value: v, formula: None, style });
+            sheet.set_cell(CellRef::new(r, c), Cell { value: v, formula: None, style, py: None });
         }
         for (c, w) in [(0u32, 14.0f32), (1, 110.0), (2, 140.0), (3, 120.0), (4, 120.0), (5, 120.0), (6, 120.0), (7, 120.0)] {
             sheet.cols.insert(c, gridcraft_model::LineInfo { size: Some(w), ..Default::default() });
@@ -2101,7 +2102,7 @@ fn run(s: &mut Session, p: &Json) -> Result<Json> {
                 let sh = cx.sheet_mut(sheet)?;
                 for (c, v) in model.vars.iter().zip(x) {
                     let style = sh.style_id(*c);
-                    sh.set_cell(*c, Cell { value: Value::number(*v), formula: None, style });
+                    sh.set_cell(*c, Cell { value: Value::number(*v), formula: None, style, py: None });
                 }
                 for c in &model.vars {
                     cx.touch(sheet + count, *c);
diff --git a/crates/engine/src/cmd/whatif.rs b/crates/engine/src/cmd/whatif.rs
index 53b0dc3cc..2cc9c88bb 100644
--- a/crates/engine/src/cmd/whatif.rs
+++ b/crates/engine/src/cmd/whatif.rs
@@ -201,7 +201,7 @@ impl Trial {
         for (si, c, v) in sets {
             if let Some(sh) = wb.sheet_mut(*si) {
                 let style = sh.style_id(*c);
-                sh.set_cell(*c, Cell { value: v.clone(), formula: None, style });
+                sh.set_cell(*c, Cell { value: v.clone(), formula: None, style, py: None });
                 keys.push((*si, *c));
             }
         }
@@ -317,7 +317,8 @@ fn goal_seek(s: &mut Session, p: &Json) -> Result<Json> {
     if !has_formula(ssi, set) {
         return Err(EngineError::Other("Cell must contain a formula.".into()));
     }
-    if has_formula(csi, chg) {
+    // A Python cell is a formula to Excel (`=PY(…)`): writing a number over it would lose its code.
+    if has_formula(csi, chg) || d.wb.sheet(csi).and_then(|sh| sh.cell(chg)).is_some_and(|c| c.py.is_some()) {
         return Err(EngineError::Other("Cell must contain a value.".into()));
     }
     let x0 = d.wb.sheet(csi).map(|sh| sh.value(chg)).and_then(|v| v.as_f64()).unwrap_or(0.0);
@@ -330,7 +331,7 @@ fn goal_seek(s: &mut Session, p: &Json) -> Result<Json> {
     edit(s, |cx| {
         let sh = cx.sheet_mut(csi)?;
         let style = sh.style_id(chg);
-        sh.set_cell(chg, Cell { value: Value::number(r.x), formula: None, style });
+        sh.set_cell(chg, Cell { value: Value::number(r.x), formula: None, style, py: None });
         cx.touch(csi, chg);
         Ok(())
     })?;
@@ -493,7 +494,7 @@ fn scenario_show(s: &mut Session, p: &Json) -> Result<Json> {
             let cell = match v.as_f64() {
                 Some(n) => {
                     let style = cx.wb.sheet(si).map(|sh| sh.style_id(*c)).unwrap_or_default();
-                    Some(Cell { value: Value::Number(n), formula: None, style })
+                    Some(Cell { value: Value::Number(n), formula: None, style, py: None })
                 }
                 None => super::edit::input_to_cell(&super::edit::json_to_input(v), si, *c, &mut cx.wb)?,
             };
@@ -578,7 +579,7 @@ fn scenario_summary(s: &mut Session, p: &Json) -> Result<Json> {
         let bold = cx.wb.styles.derive(StyleId::DEFAULT, |st| st.font.bold = true);
         let mut sheet = Sheet::new(name.clone());
         let put = |sheet: &mut Sheet, row: u32, col: u32, v: Value, style: StyleId| {
-            sheet.set_cell(CellRef::new(row, col), Cell { value: v, formula: None, style });
+            sheet.set_cell(CellRef::new(row, col), Cell { value: v, formula: None, style, py: None });
         };
         put(&mut sheet, 1, 1, Value::text("Scenario Summary"), bold);
         put(&mut sheet, 2, 2, Value::text("Current Values:"), bold);
@@ -701,7 +702,7 @@ fn data_table(s: &mut Session, p: &Json) -> Result<Json> {
         for (c, v) in out {
             let sh = cx.sheet_mut(si)?;
             let style = sh.style_id(c);
-            sh.set_cell(c, Cell { value: v, formula: None, style });
+            sh.set_cell(c, Cell { value: v, formula: None, style, py: None });
             cx.touch(si, c);
         }
         Ok(())
@@ -895,7 +896,7 @@ fn advanced_filter(s: &mut Session, p: &Json) -> Result<Json> {
                     // The full output footprint was checked above.
                     let to = CellRef::new(dest.row + i as u32, dest.col + c - list.start.col);
                     let style = sh.style_id(src);
-                    (to, Cell { value: sh.value(src), formula: None, style })
+                    (to, Cell { value: sh.value(src), formula: None, style, py: None })
                 })
             })
             .collect();
@@ -1122,7 +1123,7 @@ fn consolidate(s: &mut Session, p: &Json) -> Result<Json> {
             if v.is_empty() && style == StyleId::DEFAULT {
                 sh.remove_cell(c);
             } else {
-                sh.set_cell(c, Cell { value: v, formula: None, style });
+                sh.set_cell(c, Cell { value: v, formula: None, style, py: None });
             }
             cx.touch(dsi, c);
         }
diff --git a/crates/engine/src/fill.rs b/crates/engine/src/fill.rs
index b12700e4f..644a17860 100644
--- a/crates/engine/src/fill.rs
+++ b/crates/engine/src/fill.rs
@@ -171,10 +171,12 @@ pub fn fill(cx: &mut Ctx, sheet: usize, src: RangeRef, target: RangeRef, mode: F
                             cell.formula = Some(Arc::new(Formula::from_expr(shifted)));
                             cell.value = Value::Empty;
                         }
-                    } else if let Some(v) = match per_cell.get(src_i) {
-                        Some(p) => p.value(k as i64 / src_cells.len() as i64 + 1, forward, 1),
-                        None => pattern.value(step, forward, src_cells.len()),
-                    } {
+                    } else if cell.py.is_none()
+                        && let Some(v) = match per_cell.get(src_i) {
+                            Some(p) => p.value(k as i64 / src_cells.len() as i64 + 1, forward, 1),
+                            None => pattern.value(step, forward, src_cells.len()),
+                        }
+                    {
                         cell.value = v;
                     }
                     cell.style = style;
@@ -296,7 +298,8 @@ impl Pattern {
 
     fn detect(cells: &[(CellRef, Option<Cell>)], custom: &[Vec<String>], sys: gridcraft_core::DateSystem, fmt: &str) -> Pattern {
         let vals: Vec<Value> = cells.iter().map(|(_, c)| c.as_ref().map(|c| c.value.clone()).unwrap_or_default()).collect();
-        if cells.iter().any(|(_, c)| c.as_ref().is_some_and(|c| c.formula.is_some())) {
+        // Formulas and Python cells copy.
+        if cells.iter().any(|(_, c)| c.as_ref().is_some_and(|c| c.formula.is_some() || c.py.is_some())) {
             return Pattern::Copy;
         }
         // Numbers.
@@ -587,7 +590,7 @@ pub fn series(cx: &mut Ctx, sheet: usize, r: RangeRef, rows: bool, kind: &str, s
                 break;
             }
             let c = if rows { CellRef::new(lane, r.start.col + i) } else { CellRef::new(r.start.row + i, lane) };
-            writes.push((c, Cell { value: Value::number(round15(v)), formula: None, style }));
+            writes.push((c, Cell { value: Value::number(round15(v)), formula: None, style, py: None }));
         }
     }
     let sh = cx.sheet_mut(sheet)?;
@@ -646,7 +649,7 @@ pub fn flash_fill(cx: &mut Ctx, sheet: usize, at: CellRef) -> Result<usize> {
     }
     let sh = cx.sheet_mut(sheet)?;
     for (c, out) in &writes {
-        sh.set_cell(*c, Cell { value: Value::text(out.as_str()), formula: None, style });
+        sh.set_cell(*c, Cell { value: Value::text(out.as_str()), formula: None, style, py: None });
     }
     for (c, _) in writes {
         cx.touch(sheet, c);
diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs
index 77467b210..4ad9f3d83 100644
--- a/crates/engine/src/io.rs
+++ b/crates/engine/src/io.rs
@@ -1196,17 +1196,17 @@ mod tests {
             (styled("yyyy-mm-dd"), styled("$#,##0.00"), styled("0.0%"), styled("# ?/?"), styled("@"), styled("0.00"), styled("#,##0"));
         let sh = wb.sheet_mut(0).unwrap();
         let cells = [
-            ("A1", Cell { value: Value::Number(46023.0), formula: None, style: date }),
-            ("B1", Cell { value: Value::Number(1234.5), formula: None, style: money }),
-            ("C1", Cell { value: Value::Number(0.125), formula: None, style: pct }),
-            ("D1", Cell { value: Value::Number(1.5), formula: None, style: frac }),
-            ("E1", Cell { value: Value::text("007"), formula: None, style: text }),
-            ("F1", Cell { value: Value::Error(CellError::NA), formula: None, style: money }),
-            ("G1", Cell { value: Value::Bool(true), formula: None, style: StyleId::DEFAULT }),
+            ("A1", Cell { value: Value::Number(46023.0), formula: None, style: date, py: None }),
+            ("B1", Cell { value: Value::Number(1234.5), formula: None, style: money, py: None }),
+            ("C1", Cell { value: Value::Number(0.125), formula: None, style: pct, py: None }),
+            ("D1", Cell { value: Value::Number(1.5), formula: None, style: frac, py: None }),
+            ("E1", Cell { value: Value::text("007"), formula: None, style: text, py: None }),
+            ("F1", Cell { value: Value::Error(CellError::NA), formula: None, style: money, py: None }),
+            ("G1", Cell { value: Value::Bool(true), formula: None, style: StyleId::DEFAULT, py: None }),
             ("A2", Cell { value: Value::Number(46024.0), style: date, ..Cell::formula(Formula::new("A1+1")) }),
-            ("B2", Cell { value: Value::Number(12345678.9), formula: None, style: fixed }),
-            ("C2", Cell { value: Value::Number(-0.25), formula: None, style: StyleId::DEFAULT }),
-            ("D2", Cell { value: Value::Number(1234567.0), formula: None, style: thousands }),
+            ("B2", Cell { value: Value::Number(12345678.9), formula: None, style: fixed, py: None }),
+            ("C2", Cell { value: Value::Number(-0.25), formula: None, style: StyleId::DEFAULT, py: None }),
+            ("D2", Cell { value: Value::Number(1234567.0), formula: None, style: thousands, py: None }),
         ];
         for (a, c) in cells {
             sh.set_cell(CellRef::parse(a).unwrap(), c);
diff --git a/crates/engine/src/pivot.rs b/crates/engine/src/pivot.rs
index a074f5729..e541199d9 100644
--- a/crates/engine/src/pivot.rs
+++ b/crates/engine/src/pivot.rs
@@ -1518,7 +1518,10 @@ pub fn refresh(wb: &mut Workbook, sheet: usize, idx: usize, replace: bool) -> Re
             if oc.value.is_empty() && id == StyleId::default() {
                 continue;
             }
-            cells.push((CellRef::new(origin.row + ri as u32, origin.col + ci as u32), Cell { value: oc.value.clone(), formula: None, style: id }));
+            cells.push((
+                CellRef::new(origin.row + ri as u32, origin.col + ci as u32),
+                Cell { value: oc.value.clone(), formula: None, style: id, py: None },
+            ));
         }
     }
     // Column widths that fit the labels.
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 13fbb9b3a..c9d10e36e 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -5093,6 +5093,7 @@ fn a_script_cannot_switch_windows() {
     assert_eq!(v(&s, "A1"), Value::number(2.0));
 }
 
+mod python_cells;
 mod seams;
 
 #[test]
diff --git a/crates/engine/src/tests/python_cells.rs b/crates/engine/src/tests/python_cells.rs
new file mode 100644
index 000000000..91a1fed77
--- /dev/null
+++ b/crates/engine/src/tests/python_cells.rs
@@ -0,0 +1,229 @@
+//! Python cells under edits: what keeps, moves, rewrites or removes their code.
+
+use std::sync::Arc;
+
+use gridcraft_core::{CellRef, Value};
+use gridcraft_model::{Cell, PyCode};
+use serde_json::json;
+
+use super::s;
+use crate::Session;
+
+/// Makes `cell` on sheet `sheet` a Python cell with `code` and a cached value.
+fn plant(s: &mut Session, sheet: usize, cell: &str, code: &str) {
+    let d = s.doc_mut().unwrap();
+    let mut wb = (*d.wb).clone();
+    let sh = wb.sheet_mut(sheet).unwrap();
+    let at = CellRef::parse(cell).unwrap();
+    let style = sh.style_id(at);
+    sh.set_cell(at, Cell { value: Value::Number(1.0), formula: None, style, py: Some(Arc::new(PyCode::new(code))) });
+    d.wb = Arc::new(wb);
+}
+
+fn code(s: &Session, sheet: usize, cell: &str) -> Option<String> {
+    let d = s.doc().unwrap();
+    d.wb.sheet(sheet).unwrap().cell(CellRef::parse(cell).unwrap()).and_then(|c| c.py.as_ref()).map(|p| p.code.clone())
+}
+
+#[test]
+fn typing_py_formulas_points_to_python_set() {
+    let mut s = s();
+    let e = s.execute("cell.set", json!({"cell": "A1", "input": "=PY(\"1+1\",0)"})).unwrap_err();
+    assert!(e.to_string().contains("python.set"), "{e}");
+    assert!(s.execute("cell.set", json!({"cell": "A1", "input": "=py"})).is_err());
+    // Other functions starting with PY are not affected.
+    s.execute("cell.set", json!({"cell": "A2", "input": "=PI()"})).unwrap();
+}
+
+#[test]
+fn entering_or_clearing_a_python_cell_removes_its_code() {
+    let mut s = s();
+    plant(&mut s, 0, "A1", "1 + 1");
+    plant(&mut s, 0, "A2", "2 + 2");
+    plant(&mut s, 0, "A3", "3 + 3");
+    let got = s.execute("cell.get", json!({"cell": "A1"})).unwrap();
+    assert_eq!(got["input"], "1 + 1");
+    assert_eq!(got["python"]["code"], "1 + 1");
+    assert_eq!(got["python"]["output"], "value");
+    s.execute("cell.set", json!({"cell": "A1", "input": "hello"})).unwrap();
+    assert_eq!(code(&s, 0, "A1"), None);
+    s.execute("edit.clearFormats", json!({"range": "A2"})).unwrap();
+    assert_eq!(code(&s, 0, "A2").as_deref(), Some("2 + 2"), "clearing formats keeps the code");
+    s.execute("edit.clearContents", json!({"range": "A2"})).unwrap();
+    assert_eq!(code(&s, 0, "A2"), None);
+    s.execute("edit.clearAll", json!({"range": "A3"})).unwrap();
+    assert_eq!(code(&s, 0, "A3"), None);
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(code(&s, 0, "A3").as_deref(), Some("3 + 3"), "undo brings the code back");
+}
+
+#[test]
+fn copy_fill_and_sort_carry_the_code_and_paste_values_drops_it() {
+    let mut s = s();
+    plant(&mut s, 0, "A1", "xl('B1') * 2");
+    s.execute("edit.copy", json!({"range": "A1"})).unwrap();
+    s.execute("edit.paste", json!({"at": "C1"})).unwrap();
+    assert_eq!(code(&s, 0, "C1").as_deref(), Some("xl('B1') * 2"), "the code is copied as it is");
+    s.execute("edit.pasteSpecial", json!({"at": "D1", "what": "values"})).unwrap();
+    assert_eq!(code(&s, 0, "D1"), None);
+    assert_eq!(super::v(&s, "D1"), Value::Number(1.0), "the cached value is pasted");
+    s.execute("edit.fillDown", json!({"range": "A1:A3"})).unwrap();
+    assert_eq!(code(&s, 0, "A3").as_deref(), Some("xl('B1') * 2"));
+    // Sorting moves Python cells with their rows.
+    s.execute("range.setValues", json!({"range": "E1", "values": [[3], [1], [2]]})).unwrap();
+    plant(&mut s, 0, "F1", "'three'");
+    plant(&mut s, 0, "F2", "'one'");
+    s.execute("data.sort", json!({"range": "E1:F3", "keys": [{"column": "E"}]})).unwrap();
+    assert_eq!(code(&s, 0, "F1").as_deref(), Some("'one'"));
+    assert_eq!(code(&s, 0, "F3").as_deref(), Some("'three'"));
+}
+
+#[test]
+fn xl_references_follow_inserts_moves_and_renames() {
+    let mut s = s();
+    s.execute("home.insertSheet", json!({})).unwrap();
+    s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
+    let other = s.doc().unwrap().wb.sheet(1).unwrap().name.clone();
+    plant(&mut s, 0, "C5", &format!("a = xl(\"A1:A3\")\nb = xl('{other}!B2', headers=True)\nc = xl(dynamic)\n# xl(\"A1\") stays in comments"));
+    s.execute("home.insertRows", json!({"rows": "2:2"})).unwrap();
+    let c = code(&s, 0, "C6").unwrap();
+    assert!(c.starts_with("a = xl(\"A1:A4\")\n"), "{c}");
+    assert!(c.contains(&format!("xl('{other}!B2', headers=True)")), "{c}");
+    assert!(c.contains("# xl(\"A1\") stays"), "{c}");
+    s.execute("sheet.rename", json!({"sheet": 1, "name": "Data"})).unwrap();
+    assert!(code(&s, 0, "C6").unwrap().contains("xl('Data!B2', headers=True)"));
+    // Cutting the cells a reference names moves the reference with them.
+    s.execute("edit.cut", json!({"range": "A1:A4"})).unwrap();
+    s.execute("edit.paste", json!({"at": "H1"})).unwrap();
+    assert!(code(&s, 0, "C6").unwrap().starts_with("a = xl(\"H1:H4\")"), "{:?}", code(&s, 0, "C6"));
+    // Deleting the referenced cells leaves #REF!, which fails when the code runs.
+    // The selection is elsewhere, so only the named column goes.
+    s.execute("selection.set", json!({"range": "A1"})).unwrap();
+    s.execute("home.deleteColumns", json!({"cols": "H:H"})).unwrap();
+    assert!(code(&s, 0, "C6").unwrap().starts_with("a = xl(\"#REF!\")"), "{:?}", code(&s, 0, "C6"));
+}
+
+#[test]
+fn a_rename_to_a_name_that_needs_quotes_rewrites_single_quoted_references() {
+    let mut s = s();
+    s.execute("home.insertSheet", json!({})).unwrap();
+    s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
+    let other = s.doc().unwrap().wb.sheet(1).unwrap().name.clone();
+    plant(&mut s, 0, "A1", &format!("a = xl('{other}!B2')\nb = xl(\"{other}!C3\")"));
+    s.execute("sheet.rename", json!({"sheet": 1, "name": "Q4 2026"})).unwrap();
+    assert_eq!(code(&s, 0, "A1").unwrap(), "a = xl(\"'Q4 2026'!B2\")\nb = xl(\"'Q4 2026'!C3\")");
+    // A name with both quotes in it: the literal's own quote is escaped.
+    s.execute("sheet.rename", json!({"sheet": 1, "name": "Bob's \"Q4\""})).unwrap();
+    let c = code(&s, 0, "A1").unwrap();
+    assert_eq!(c, "a = xl(\"'Bob''s \\\"Q4\\\"'!B2\")\nb = xl(\"'Bob''s \\\"Q4\\\"'!C3\")");
+    let refs: Vec<Option<String>> = gridcraft_model::python::xl_calls(&c).into_iter().map(|x| x.reference).collect();
+    assert_eq!(refs, [Some("'Bob''s \"Q4\"'!B2".to_string()), Some("'Bob''s \"Q4\"'!C3".to_string())]);
+    // And back to a plain name.
+    s.execute("sheet.rename", json!({"sheet": 1, "name": "Data"})).unwrap();
+    assert_eq!(code(&s, 0, "A1").unwrap(), "a = xl(\"Data!B2\")\nb = xl(\"Data!C3\")");
+}
+
+#[test]
+fn a_cut_to_another_sheet_keeps_references_on_the_source_sheet() {
+    let mut s = s();
+    s.execute("home.insertSheet", json!({})).unwrap();
+    s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
+    let (src, dest) = {
+        let wb = &s.doc().unwrap().wb;
+        (wb.sheet(0).unwrap().name.clone(), wb.sheet(1).unwrap().name.clone())
+    };
+    plant(&mut s, 0, "A1", "a = xl(\"B5\")\nb = xl('A2')");
+    plant(&mut s, 0, "A2", "1");
+    s.execute("edit.cut", json!({"range": "A1:A2"})).unwrap();
+    s.execute("sheet.activate", json!({"sheet": 1})).unwrap();
+    s.execute("edit.paste", json!({"at": "C1"})).unwrap();
+    // B5 stays on the source sheet; A2 moved with the cut, so it follows to the destination.
+    assert_eq!(code(&s, 1, "C1").unwrap(), format!("a = xl(\"{src}!B5\")\nb = xl('{dest}!C2')"));
+    assert_eq!(code(&s, 0, "A1"), None);
+    // Within one sheet nothing is qualified.
+    s.execute("edit.cut", json!({"range": "C1"})).unwrap();
+    s.execute("edit.paste", json!({"at": "E1"})).unwrap();
+    assert_eq!(code(&s, 1, "E1").unwrap(), format!("a = xl(\"{src}!B5\")\nb = xl('{dest}!C2')"));
+    // A copy to another sheet still carries the code as it is.
+    plant(&mut s, 0, "A9", "xl(\"B5\")");
+    s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
+    s.execute("edit.copy", json!({"range": "A9"})).unwrap();
+    s.execute("sheet.activate", json!({"sheet": 1})).unwrap();
+    s.execute("edit.paste", json!({"at": "A9"})).unwrap();
+    assert_eq!(code(&s, 1, "A9").as_deref(), Some("xl(\"B5\")"));
+}
+
+#[test]
+fn goal_seek_and_solver_refuse_to_change_a_python_cell() {
+    let mut s = s();
+    plant(&mut s, 0, "A1", "2");
+    s.execute("cell.set", json!({"cell": "B1", "input": "=A1*2"})).unwrap();
+    let e = s.execute("data.goalSeek", json!({"set": "B1", "to": 10, "changing": "A1"})).unwrap_err();
+    assert!(e.to_string().contains("must contain a value"), "{e}");
+    assert_eq!(code(&s, 0, "A1").as_deref(), Some("2"), "the code is kept");
+    // The set cell must be a formula: a Python cell isn't one this build can recalculate.
+    s.execute("cell.set", json!({"cell": "C1", "input": "3"})).unwrap();
+    assert!(s.execute("data.goalSeek", json!({"set": "A1", "to": 10, "changing": "C1"})).is_err());
+    let e = s.execute("data.solver", json!({"objective": "B1", "goal": "max", "variables": "A1"})).unwrap_err();
+    assert!(e.to_string().contains("constants"), "{e}");
+    assert_eq!(code(&s, 0, "A1").as_deref(), Some("2"));
+}
+
+#[test]
+fn text_to_columns_keeps_a_py_piece_as_text() {
+    let mut s = s();
+    s.execute("cell.set", json!({"cell": "A1", "input": "'=PY(\"x\");7"})).unwrap();
+    assert_eq!(super::v(&s, "A1"), Value::text("=PY(\"x\");7"));
+    s.execute("data.textToColumns", json!({"range": "A1", "delimiters": [";"]})).unwrap();
+    // The default text qualifier takes the quotes away, as in Excel.
+    assert_eq!(super::v(&s, "A1"), Value::text("=PY(x)"), "the piece is kept, not cleared");
+    assert_eq!(code(&s, 0, "A1"), None, "and it is not a Python cell");
+    assert_eq!(super::v(&s, "B1"), Value::Number(7.0));
+}
+
+#[test]
+fn python_cells_survive_native_json() {
+    let mut s = s();
+    plant(&mut s, 0, "B2", "x = 1\nx");
+    let wb = s.doc().unwrap().wb.clone();
+    let json = serde_json::to_string(&*wb).unwrap();
+    let back: gridcraft_model::Workbook = serde_json::from_str(&json).unwrap();
+    let cell = back.sheet(0).unwrap().cell(CellRef::parse("B2").unwrap()).unwrap();
+    assert_eq!(cell.py.as_ref().unwrap().code, "x = 1\nx");
+    // Cells written before Python existed have no `py` field.
+    let plain: Cell = serde_json::from_value(json!({"value": {"t": "Number", "v": 2.0}, "formula": null, "style": 0})).unwrap();
+    assert!(plain.py.is_none());
+    assert!(!serde_json::to_string(&plain).unwrap().contains("py"), "no field is written for ordinary cells");
+}
+
+#[test]
+fn new_errors_parse_and_have_error_type_numbers() {
+    use gridcraft_core::CellError;
+    for (text, e) in
+        [("#PYTHON!", CellError::Python), ("#BUSY!", CellError::Busy), ("#TIMEOUT!", CellError::Timeout), ("#BLOCKED!", CellError::Blocked)]
+    {
+        assert_eq!(CellError::parse(text), Some(e));
+        assert_eq!(e.as_str(), text);
+    }
+    let mut s = s();
+    s.execute("cell.set", json!({"cell": "A1", "input": "=ERROR.TYPE(#BLOCKED!)"})).unwrap();
+    assert_eq!(super::v(&s, "A1"), Value::Number(11.0));
+    s.execute("cell.set", json!({"cell": "A2", "input": "=ISERROR(#PYTHON!)"})).unwrap();
+    assert_eq!(super::v(&s, "A2"), Value::Bool(true));
+}
+
+#[test]
+fn go_to_special_counts_a_python_cell_as_a_formula_not_a_constant() {
+    let mut s = s();
+    plant(&mut s, 0, "A1", "1 + 1");
+    s.execute("cell.set", json!({"cell": "A2", "input": "=1+1"})).unwrap();
+    s.execute("cell.set", json!({"cell": "A3", "input": "7"})).unwrap();
+    s.execute("selection.set", json!({"range": "A1"})).unwrap();
+    let r = s.execute("edit.goToSpecial", json!({"kind": "formulas"})).unwrap();
+    assert_eq!(r["count"], 2, "{r}");
+    assert_eq!(r["selection"], "A1:A2", "{r}");
+    s.execute("selection.set", json!({"range": "A1"})).unwrap();
+    let r = s.execute("edit.goToSpecial", json!({"kind": "constants"})).unwrap();
+    assert_eq!(r["count"], 1, "{r}");
+    assert_eq!(r["selection"], "A3", "{r}");
+}
diff --git a/crates/model/src/cell.rs b/crates/model/src/cell.rs
index d4466365f..58df4ebeb 100644
--- a/crates/model/src/cell.rs
+++ b/crates/model/src/cell.rs
@@ -6,6 +6,7 @@ use gridcraft_core::{RangeRef, Value};
 use gridcraft_formula::Expr;
 use serde::{Deserialize, Serialize};
 
+use crate::python::PyCode;
 use crate::style::StyleId;
 
 /// A parsed formula. `text` is the canonical formula text without the leading `=`.
@@ -60,25 +61,45 @@ pub struct CellPicture {
 
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 pub struct Cell {
-    /// Constant value, or the cached result of the formula.
+    /// Constant value, or the cached result of the formula or Python code.
     pub value: Value,
     pub formula: Option<Arc<Formula>>,
     pub style: StyleId,
+    /// Python code, for a Python cell (which has no formula).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub py: Option<Arc<PyCode>>,
 }
 
 impl Cell {
     pub fn value(v: Value) -> Cell {
-        Cell { value: v, formula: None, style: StyleId::DEFAULT }
+        Cell { value: v, formula: None, style: StyleId::DEFAULT, py: None }
     }
     pub fn formula(f: Formula) -> Cell {
-        Cell { value: Value::Empty, formula: Some(Arc::new(f)), style: StyleId::DEFAULT }
+        Cell { value: Value::Empty, formula: Some(Arc::new(f)), style: StyleId::DEFAULT, py: None }
     }
-    /// No value, no formula and the default style: storing it is pointless.
+    /// A value cell with this style.
+    pub fn styled(v: Value, style: StyleId) -> Cell {
+        Cell { value: v, formula: None, style, py: None }
+    }
+    /// No value, no formula, no Python code and the default style: storing it is pointless.
     pub fn is_blank(&self) -> bool {
-        self.value.is_empty() && self.formula.is_none() && self.style == StyleId::DEFAULT
+        self.value.is_empty() && self.formula.is_none() && self.style == StyleId::DEFAULT && self.py.is_none()
     }
-    /// What the formula bar shows.
+    /// Whether the cell holds content (a value, a formula or Python code), formats aside.
+    pub fn has_content(&self) -> bool {
+        !self.value.is_empty() || self.formula.is_some() || self.py.is_some()
+    }
+    /// Removes the content (value, formula and Python code), keeping the style.
+    pub fn clear_content(&mut self) {
+        self.value = Value::Empty;
+        self.formula = None;
+        self.py = None;
+    }
+    /// What the formula bar shows: a formula, a Python cell's code, or the value.
     pub fn input_text(&self) -> String {
+        if let Some(py) = &self.py {
+            return py.code.clone();
+        }
         if let Some(f) = &self.formula {
             return format!("={}", f.text);
         }
diff --git a/crates/model/src/lib.rs b/crates/model/src/lib.rs
index 071de683c..300fdc66a 100644
--- a/crates/model/src/lib.rs
+++ b/crates/model/src/lib.rs
@@ -10,6 +10,7 @@ mod cellmap;
 pub mod features;
 pub mod password;
 pub mod preserved;
+pub mod python;
 pub mod sheet;
 pub mod store;
 pub mod style;
@@ -19,6 +20,7 @@ pub use cell::{Cell, CellPicture, Formula};
 pub use features::*;
 pub use password::PasswordHash;
 pub use preserved::{Preserved, PreservedPart, PreservedRel, PreservedSheet, PreservedXml};
+pub use python::{PyCode, PyOutput};
 pub use sheet::{DEFAULT_COL_WIDTH, DEFAULT_ROW_HEIGHT, LineIndex, Sheet, SheetViewMode, Visibility, points_to_chars};
 pub use store::CellStore;
 pub use style::{
diff --git a/crates/model/src/python.rs b/crates/model/src/python.rs
new file mode 100644
index 000000000..abd4c9414
--- /dev/null
+++ b/crates/model/src/python.rs
@@ -0,0 +1,437 @@
+//! Python cells: the code a cell holds, its last result, and the text forms around it (the
+//! `PY(…)` formula files store it as, and the `xl("…")` references inside it).
+
+use gridcraft_core::{CellError, Value};
+use serde::{Deserialize, Serialize};
+
+/// Excel's limit on the characters of one formula. A Python cell's code must fit in it once it is
+/// encoded as a file formula ([`PyCode::to_file_formula`]): quotes are doubled and every 255
+/// characters add `"&"`, so the limit on the code itself depends on what the code holds.
+pub const MAX_FORMULA_CHARS: usize = 8_192;
+
+/// The prefix files put before `PY(`, as Excel writes it ([MS-XLSX]: `_xlfn._xlws.PY`).
+pub const FILE_PREFIX: &str = "_xlfn._xlws.";
+
+/// Characters in one string literal of a `PY(…)` formula (Excel's limit for a literal).
+const CHUNK_CHARS: usize = 255;
+
+/// A Python cell.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct PyCode {
+    pub code: String,
+    /// Show the result as a Python object (true) or convert it to cell values (false).
+    pub object: bool,
+    /// The last result, when the code ran without an error.
+    pub output: Option<PyOutput>,
+    /// The cell's inputs changed while calculation was manual: its value is out of date until
+    /// the workbook is calculated.
+    pub stale: bool,
+}
+
+/// A Python result kept on the cell.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct PyOutput {
+    /// The result as cells (an array spills), or its preview as text when it has no cell form.
+    pub value: Value,
+    /// Python's name for the result's type.
+    pub type_name: String,
+    /// The result's `repr`, shortened.
+    pub preview: String,
+    /// Whether `value` is the result converted to cells.
+    pub convertible: bool,
+}
+
+impl PyCode {
+    pub fn new(code: &str) -> PyCode {
+        PyCode { code: normalize_code(code), ..PyCode::default() }
+    }
+
+    /// What the cell shows for its result: cell values (an array spills from the cell), or, for a
+    /// Python object, its type name. `None` before the code has run.
+    pub fn result_value(&self) -> Option<Value> {
+        let out = self.output.as_ref()?;
+        let scalar = !matches!(out.value, Value::Array(_)) && out.convertible;
+        Some(if self.object && !scalar { Value::text(out.type_name.as_str()) } else { out.value.clone() })
+    }
+
+    /// The cell as a formula (without `=`): `PY("…"&"…",0)`, with the code in string literals of
+    /// at most 255 characters and the return type Excel documents: 0 for an Excel value, 1 for a
+    /// Python object.
+    pub fn to_formula(&self) -> String {
+        let chunks = chunk(&self.code, CHUNK_CHARS);
+        let lits: Vec<String> = chunks.iter().map(|c| format!("\"{}\"", c.replace('"', "\"\""))).collect();
+        let lits = if lits.is_empty() { "\"\"".to_string() } else { lits.join("&") };
+        format!("PY({lits},{})", u8::from(self.object))
+    }
+
+    /// The formula a file stores the cell as: [`PyCode::to_formula`] with Excel's
+    /// `_xlfn._xlws.` prefix, so Excel reads it as its own Python function.
+    pub fn to_file_formula(&self) -> String {
+        format!("{FILE_PREFIX}{}", self.to_formula())
+    }
+
+    /// Whether the code fits in a file formula of at most [`MAX_FORMULA_CHARS`] characters.
+    pub fn fits(&self) -> bool {
+        // Code longer than the limit can't fit; this also bounds the work for hostile input.
+        self.code.chars().nth(MAX_FORMULA_CHARS).is_none() && self.to_file_formula().chars().nth(MAX_FORMULA_CHARS).is_none()
+    }
+
+    /// Reads a `PY(…)` formula (with or without `=`, and with or without the `_xlfn.` and
+    /// `_xlws.` prefixes): string literals joined by `&`, optionally followed by `,0` or `,1`.
+    /// `None` for anything else.
+    pub fn from_formula(text: &str) -> Option<PyCode> {
+        let body = py_body(text);
+        let rest = body.get(..3).filter(|h| h.eq_ignore_ascii_case("PY(")).and_then(|_| body.get(3..))?;
+        let mut chars = rest.chars().peekable();
+        let mut code = String::new();
+        loop {
+            skip_space(&mut chars);
+            if chars.next()? != '"' {
+                return None;
+            }
+            loop {
+                match chars.next()? {
+                    '"' if chars.peek() == Some(&'"') => {
+                        chars.next();
+                        code.push('"');
+                    }
+                    '"' => break,
+                    c => code.push(c),
+                }
+            }
+            skip_space(&mut chars);
+            match chars.next()? {
+                '&' => continue,
+                ',' => {
+                    skip_space(&mut chars);
+                    let object = match chars.next()? {
+                        '0' => false,
+                        '1' => true,
+                        _ => return None,
+                    };
+                    skip_space(&mut chars);
+                    return (chars.next()? == ')' && chars.all(char::is_whitespace)).then(|| PyCode { object, ..PyCode::new(&code) });
+                }
+                ')' => return chars.all(char::is_whitespace).then(|| PyCode::new(&code)),
+                _ => return None,
+            }
+        }
+    }
+}
+
+/// `text` without a leading `=`, spaces and the `_xlfn.` and `_xlws.` prefixes files put before
+/// newer functions (in any letter case).
+fn py_body(text: &str) -> &str {
+    let mut body = text.trim().trim_start_matches('=').trim_start();
+    for prefix in ["_xlfn.", "_xlws."] {
+        if body.get(..prefix.len()).is_some_and(|h| h.eq_ignore_ascii_case(prefix)) {
+            body = body.get(prefix.len()..).unwrap_or_default();
+        }
+    }
+    body
+}
+
+fn skip_space(chars: &mut std::iter::Peekable<std::str::Chars<'_>>) {
+    while chars.peek().is_some_and(|c| c.is_whitespace()) {
+        chars.next();
+    }
+}
+
+/// Line breaks as `\n`.
+pub fn normalize_code(code: &str) -> String {
+    code.replace("\r\n", "\n").replace('\r', "\n")
+}
+
+/// `s` in pieces of at most `n` characters.
+fn chunk(s: &str, n: usize) -> Vec<String> {
+    let chars: Vec<char> = s.chars().collect();
+    chars.chunks(n.max(1)).map(|c| c.iter().collect()).collect()
+}
+
+/// Whether `text` (a formula, with or without `=`) is a `PY(` call: such formulas are Python cells,
+/// set with `python.set`.
+pub fn is_py_formula(text: &str) -> bool {
+    let body = py_body(text);
+    body.get(..3).is_some_and(|h| h.eq_ignore_ascii_case("PY(")) || body.eq_ignore_ascii_case("PY")
+}
+
+/// An `xl()` call in Python code.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct XlCall {
+    /// The reference text, when the first argument is a plain string literal.
+    pub reference: Option<String>,
+    /// Byte range of the literal's contents (between the quotes) in the code.
+    pub span: Option<std::ops::Range<usize>>,
+}
+
+/// The `xl(…)` calls in `code`, skipping comments and other string literals. A call whose first
+/// argument isn't a plain string literal has no reference: the cells it reads are only known when
+/// it runs.
+pub fn xl_calls(code: &str) -> Vec<XlCall> {
+    let bytes = code.as_bytes();
+    let mut out = Vec::new();
+    let mut i = 0usize;
+    while let Some(&b) = bytes.get(i) {
+        match b {
+            b'#' => {
+                // A comment runs to the end of the line.
+                while bytes.get(i).is_some_and(|c| *c != b'\n') {
+                    i += 1;
+                }
+            }
+            b'"' | b'\'' => i = skip_string(bytes, i),
+            b'x' if bytes.get(i + 1) == Some(&b'l') && (i == 0 || bytes.get(i - 1).is_some_and(|p| !is_ident(*p) && *p != b'.')) => {
+                let mut j = i + 2;
+                if bytes.get(j).is_some_and(|c| is_ident(*c)) {
+                    i = j;
+                    continue;
+                }
+                while bytes.get(j).is_some_and(|c| *c == b' ' || *c == b'\t') {
+                    j += 1;
+                }
+                if bytes.get(j) != Some(&b'(') {
+                    i = j;
+                    continue;
+                }
+                j += 1;
+                while bytes.get(j).is_some_and(|c| c.is_ascii_whitespace()) {
+                    j += 1;
+                }
+                let call = match bytes.get(j) {
+                    Some(&q @ (b'"' | b'\'')) => {
+                        let start = j + 1;
+                        let end = skip_string(bytes, j);
+                        // A plain literal: closed on its own line, not part of an expression
+                        // (`xl("A" + n)`), not a triple-quoted string, and escaping nothing but a
+                        // quote or a backslash (`\'`, `\"`, `\\`), which a sheet name may need.
+                        let close = end.saturating_sub(1);
+                        let mut k = end;
+                        while bytes.get(k).is_some_and(|c| *c == b' ' || *c == b'\t') {
+                            k += 1;
+                        }
+                        let plain = close > start
+                            && bytes.get(close) == Some(&q)
+                            && bytes.get(start) != Some(&q)
+                            && matches!(bytes.get(k), Some(b')' | b','));
+                        i = end;
+                        match code.get(start..close).filter(|_| plain).and_then(unescape) {
+                            Some(t) => XlCall { reference: Some(t), span: Some(start..close) },
+                            None => XlCall { reference: None, span: None },
+                        }
+                    }
+                    _ => {
+                        i = j;
+                        XlCall { reference: None, span: None }
+                    }
+                };
+                out.push(call);
+            }
+            _ => i += 1,
+        }
+    }
+    out
+}
+
+fn is_ident(b: u8) -> bool {
+    b.is_ascii_alphanumeric() || b == b'_' || b >= 0x80
+}
+
+/// The index just past the string literal starting at `at` (single, double or triple quoted).
+fn skip_string(bytes: &[u8], at: usize) -> usize {
+    let Some(&q) = bytes.get(at) else { return at.saturating_add(1) };
+    let triple = bytes.get(at + 1) == Some(&q) && bytes.get(at + 2) == Some(&q);
+    let mut i = if triple { at + 3 } else { at + 1 };
+    while let Some(&c) = bytes.get(i) {
+        if c == b'\\' {
+            i += 2;
+            continue;
+        }
+        if c == q {
+            if !triple {
+                return i + 1;
+            }
+            if bytes.get(i + 1) == Some(&q) && bytes.get(i + 2) == Some(&q) {
+                return i + 3;
+            }
+        } else if c == b'\n' && !triple {
+            return i;
+        }
+        i += 1;
+    }
+    i
+}
+
+/// The text of a plain literal's contents: `\'`, `\"` and `\\` stand for the character after the
+/// backslash. `None` for any other escape or a line break, which make the literal not plain.
+fn unescape(raw: &str) -> Option<String> {
+    let mut out = String::with_capacity(raw.len());
+    let mut chars = raw.chars();
+    while let Some(c) = chars.next() {
+        match c {
+            '\n' => return None,
+            '\\' => match chars.next()? {
+                e @ ('\\' | '\'' | '"') => out.push(e),
+                _ => return None,
+            },
+            c => out.push(c),
+        }
+    }
+    Some(out)
+}
+
+/// `text` as a plain literal that was delimited by `quote`: its delimiter (`quote`, or the other
+/// quote when `text` holds `quote` but not the other one, so `xl('Sheet2!B2')` becomes
+/// `xl("'Q4 2026'!B2")` on a rename) and its contents, with backslashes escaped, and the
+/// delimiter too when `text` holds both quotes. `None` for a line break, which no literal on
+/// one line holds.
+fn literal(text: &str, quote: char) -> Option<(char, String)> {
+    if text.contains('\n') {
+        return None;
+    }
+    let other = if quote == '\'' { '"' } else { '\'' };
+    let delim = if text.contains(quote) && !text.contains(other) { other } else { quote };
+    let mut body = String::with_capacity(text.len());
+    for c in text.chars() {
+        if c == '\\' || c == delim {
+            body.push('\\');
+        }
+        body.push(c);
+    }
+    Some((delim, body))
+}
+
+/// Rewrites the reference of every `xl("…")` literal in `code` with `f`; `None` from `f` leaves
+/// it. Returns the new code when anything changed. A new reference holding the literal's quote
+/// (a sheet name that needs quotes, `'Q4 2026'!B2`) gets the other quote as its delimiter, or an
+/// escaped quote when it holds both, so it never ends the string early.
+pub fn rewrite_xl(code: &str, mut f: impl FnMut(&str) -> Option<String>) -> Option<String> {
+    let mut out = String::with_capacity(code.len());
+    let mut last = 0usize;
+    let mut changed = false;
+    for call in xl_calls(code) {
+        let (Some(reference), Some(span)) = (call.reference, call.span) else { continue };
+        let Some(new) = f(&reference).filter(|n| *n != reference) else { continue };
+        let open = span.start.saturating_sub(1);
+        let Some(quote) = code.get(open..span.start).and_then(|q| q.chars().next()) else { continue };
+        let Some((delim, body)) = literal(&new, quote) else { continue };
+        // The literal with its quotes: the delimiter may change.
+        out.push_str(code.get(last..open).unwrap_or_default());
+        out.push(delim);
+        out.push_str(&body);
+        out.push(delim);
+        last = span.end.saturating_add(1);
+        changed = true;
+    }
+    if !changed {
+        return None;
+    }
+    out.push_str(code.get(last..).unwrap_or_default());
+    Some(out)
+}
+
+/// The value a Python cell shows when it can't run: `#BLOCKED!`.
+pub const BLOCKED: Value = Value::Error(CellError::Blocked);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn formula_round_trip_with_chunks_and_quotes() {
+        let code = format!("s = \"quoted\"\n{}\nlen(s)", "x".repeat(600));
+        let py = PyCode { object: true, ..PyCode::new(&code) };
+        let f = py.to_formula();
+        assert!(f.starts_with("PY(\"s = \"\"quoted\"\"\n"));
+        assert!(f.ends_with(",1)"));
+        assert_eq!(f.matches("\"&\"").count(), 2, "{f}");
+        let back = PyCode::from_formula(&format!("={f}")).unwrap();
+        assert_eq!(back.code, code);
+        assert!(back.object);
+        assert_eq!(PyCode::from_formula("_xlfn.PY(\"1+1\")").unwrap().code, "1+1");
+        // Excel writes `_xlfn._xlws.PY`; the reader takes it in any letter case.
+        assert_eq!(PyCode::from_formula("=_xlfn._xlws.PY(\"1+1\",1)").unwrap().code, "1+1");
+        assert_eq!(PyCode::from_formula("_XLFN._XLWS.py(\"2\",0)").unwrap().code, "2");
+        assert_eq!(PyCode::from_formula("_xlws.PY(\"3\",0)").unwrap().code, "3");
+        assert!(is_py_formula("=_xlfn._xlws.PY(\"1\",0)"));
+        assert_eq!(py.to_file_formula(), format!("_xlfn._xlws.{f}"));
+        assert_eq!(PyCode::from_formula(&py.to_file_formula()).unwrap(), PyCode::from_formula(&f).unwrap());
+        assert_eq!(PyCode::from_formula(" py( \"a\" & \"b\" , 0 ) ").unwrap().code, "ab");
+        assert_eq!(PyCode::new("a\r\nb").code, "a\nb");
+        for bad in ["PY(A1)", "PY(\"a\",2)", "PY(\"a\"", "PY(\"a\")+1", "SUM(1)", "PY(\"a\"&B1)", "PY(", ""] {
+            assert!(PyCode::from_formula(bad).is_none(), "{bad}");
+        }
+        assert!(is_py_formula("=PY(\"1\")") && is_py_formula("=py") && !is_py_formula("=PYTHON(1)"));
+    }
+
+    #[test]
+    fn the_size_limit_counts_the_encoded_formula() {
+        // Plain code: the limit is the formula's, so it is a little under 8,192 characters of code.
+        // `_xlfn._xlws.PY(` + 31 literals of 255 + 30 `&` + `&"…"` + `,0)`: 8,079 characters of
+        // code give a formula of exactly 8,192.
+        let at = PyCode::new(&"y".repeat(8_079));
+        assert_eq!(at.to_file_formula().chars().count(), MAX_FORMULA_CHARS);
+        assert!(at.fits());
+        assert!(!PyCode::new(&"y".repeat(8_080)).fits());
+        assert_eq!(PyCode::from_formula(&at.to_file_formula()).unwrap().code, at.code);
+        // Quotes are doubled in the file, so 7,000 characters with 1,200 of them don't fit.
+        let quoted = format!("{}{}", "\"".repeat(1_200), "y".repeat(5_800));
+        assert!(PyCode::new(&quoted).to_file_formula().chars().count() > MAX_FORMULA_CHARS);
+        assert!(!PyCode::new(&quoted).fits());
+        // Hostile sizes are refused without encoding them.
+        assert!(!PyCode::new(&"y".repeat(4_000_000)).fits());
+        assert!(PyCode::new("").fits());
+    }
+
+    #[test]
+    fn result_values() {
+        let arr = gridcraft_core::Array::new(2, 1, vec![1.0.into(), 2.0.into()]).map(Value::from).unwrap();
+        let out = PyOutput { value: arr.clone(), type_name: "list".into(), preview: "[1, 2]".into(), convertible: true };
+        let mut py = PyCode { output: Some(out), ..PyCode::new("[1, 2]") };
+        assert_eq!(py.result_value(), Some(arr));
+        py.object = true;
+        assert_eq!(py.result_value(), Some(Value::text("list")));
+        py.output = Some(PyOutput { value: Value::Number(3.0), type_name: "int".into(), preview: "3".into(), convertible: true });
+        assert_eq!(py.result_value(), Some(Value::Number(3.0)), "scalars show as values in object mode too");
+        py.output = None;
+        assert_eq!(py.result_value(), None);
+    }
+
+    #[test]
+    fn finds_xl_literals() {
+        let code = "a = xl(\"A1:B2\", headers=True)\n# xl('C1') in a comment\ns = \"xl('D1')\"\nb = xl( 'Sheet2!E5' )\nc = xl(name)\nd = df.xl('F1')\nxlx('G1')\ne = xl(\"A\" + \"1\")";
+        let calls = xl_calls(code);
+        let refs: Vec<Option<&str>> = calls.iter().map(|c| c.reference.as_deref()).collect();
+        assert_eq!(refs, vec![Some("A1:B2"), Some("Sheet2!E5"), None, None]);
+        let new = rewrite_xl(code, |r| (r == "A1:B2").then(|| "A2:B3".to_string())).unwrap();
+        assert!(new.starts_with("a = xl(\"A2:B3\", headers=True)"));
+        assert_eq!(new.len(), code.len());
+        assert_eq!(rewrite_xl(code, |_| None), None);
+        // A replacement can't break out of its string: a quote in it changes the delimiter, or is
+        // escaped when it holds both quotes, and the result reads back as the same reference.
+        assert_eq!(rewrite_xl("xl(\"A1\")", |_| Some("'Q'!A1".into())), Some("xl(\"'Q'!A1\")".into()));
+        assert_eq!(rewrite_xl("xl('Sheet2!B2', headers=True)", |_| Some("'Q4 2026'!B2".into())), Some("xl(\"'Q4 2026'!B2\", headers=True)".into()));
+        assert_eq!(rewrite_xl("xl(\"A1\")", |_| Some("'Q\"4'!A1".into())), Some("xl(\"'Q\\\"4'!A1\")".into()));
+        assert_eq!(rewrite_xl("xl('A1')", |_| Some("'Q\"4'!A1".into())), Some("xl('\\'Q\"4\\'!A1')".into()));
+        for (delim, new) in [("'", "'Q4 2026'!B2"), ("'", "'Q\"4'!A1"), ("\"", "'Q\"4'!A1"), ("\"", "'a\\b'!A1"), ("'", "B2")] {
+            let code = format!("x = xl({delim}A1{delim}) + 1");
+            let out = rewrite_xl(&code, |_| Some(new.to_string())).unwrap();
+            assert_eq!(xl_calls(&out)[0].reference.as_deref(), Some(new), "{out}");
+            assert!(out.ends_with(") + 1"), "{out}");
+        }
+        assert_eq!(rewrite_xl("xl('A1')", |_| Some("A\n1".into())), None, "a line break can't go in a literal");
+        // Escaped quotes and backslashes read as the characters; any other escape is not plain.
+        assert_eq!(xl_calls("xl('Bob\\'s!A1')")[0].reference.as_deref(), Some("Bob's!A1"));
+        assert_eq!(xl_calls("xl(\"A\\\\1\")")[0].reference.as_deref(), Some("A\\1"));
+        assert_eq!(xl_calls("xl(\"A\\n1\")")[0].reference, None);
+        assert_eq!(xl_calls("xl(\"A1\\\")")[0].reference, None, "an escaped closing quote leaves the literal open");
+        // Unclosed and odd input doesn't loop or panic.
+        for odd in ["xl(", "xl(\"", "xl('''A1''')", "x", "xl", "\"unterminated", "xl  (  \"A1\"  )", "é xl('A1')"] {
+            let _ = xl_calls(odd);
+            let _ = rewrite_xl(odd, |_| Some("B2".into()));
+        }
+        assert_eq!(xl_calls("xl  (  \"A1\"  )")[0].reference.as_deref(), Some("A1"));
+        assert_eq!(xl_calls("xl('''A1''')")[0].reference, None);
+    }
+}
diff --git a/crates/model/src/sheet.rs b/crates/model/src/sheet.rs
index abc4731dc..6bbb331f4 100644
--- a/crates/model/src/sheet.rs
+++ b/crates/model/src/sheet.rs
@@ -259,7 +259,7 @@ impl Sheet {
     }
     pub fn set_value(&mut self, c: CellRef, v: Value) {
         let style = self.style_id(c);
-        self.set_cell(c, Cell { value: v, formula: None, style });
+        self.set_cell(c, Cell { value: v, formula: None, style, py: None });
     }
     /// Replaces content, removing any picture at this address. Style-only edits use set_style.
     pub fn set_cell(&mut self, c: CellRef, cell: Cell) {
@@ -278,7 +278,7 @@ impl Sheet {
     /// Pictures retain a scalar fallback for calculation and unsupported consumers.
     pub fn set_picture(&mut self, c: CellRef, picture: Arc<CellPicture>) {
         let style = self.style_id(c);
-        self.cells.set(c, Cell { value: Value::Error(gridcraft_core::CellError::Value), formula: None, style });
+        self.cells.set(c, Cell { value: Value::Error(gridcraft_core::CellError::Value), formula: None, style, py: None });
         self.cell_pictures.insert(c, picture);
     }
     pub fn input_text(&self, c: CellRef) -> String {
diff --git a/crates/model/src/store.rs b/crates/model/src/store.rs
index 531273ce9..001b7cf60 100644
--- a/crates/model/src/store.rs
+++ b/crates/model/src/store.rs
@@ -14,7 +14,7 @@ use crate::cell::Cell;
 const BAND: u32 = 64;
 
 fn has_value(cell: &Cell) -> bool {
-    !cell.value.is_empty() || cell.formula.is_some()
+    cell.has_content()
 }
 
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
diff --git a/crates/xlsx/src/csv.rs b/crates/xlsx/src/csv.rs
index dfc694ea6..65ef1d17b 100644
--- a/crates/xlsx/src/csv.rs
+++ b/crates/xlsx/src/csv.rs
@@ -288,7 +288,7 @@ pub fn read_csv(bytes: &[u8], opts: &CsvOptions) -> Result<Workbook, IoError> {
                     },
                     None => StyleId::DEFAULT,
                 };
-                Cell { value: p.value, formula: None, style }
+                Cell { value: p.value, formula: None, style, py: None }
             } else {
                 Cell::value(Value::Text(Arc::from(f)))
             };
diff --git a/crates/xlsx/src/sheet_read.rs b/crates/xlsx/src/sheet_read.rs
index aadd1141e..bec67bd1a 100644
--- a/crates/xlsx/src/sheet_read.rs
+++ b/crates/xlsx/src/sheet_read.rs
@@ -516,7 +516,7 @@ fn read_cell(cx: &mut Ctx<'_>, sheet: &mut Sheet, st: &mut RowState, c: &El, pos
     let dynamic = c.attr("cm").is_some();
     let formula = c.child("f").and_then(|f| read_formula(cx, st, f, pos, dynamic));
     let value = if formula.is_none() && in_dynamic(st, pos) { Value::Empty } else { value };
-    sheet.cells.set(pos, Cell { value, formula: formula.map(Arc::new), style });
+    sheet.cells.set(pos, Cell { value, formula: formula.map(Arc::new), style, py: None });
 }
 
 fn read_formula(cx: &mut Ctx<'_>, st: &mut RowState, f: &El, pos: CellRef, dynamic: bool) -> Option<Formula> {
diff --git a/crates/xlsx/src/sheet_write.rs b/crates/xlsx/src/sheet_write.rs
index 52dc979e6..9251edaa4 100644
--- a/crates/xlsx/src/sheet_write.rs
+++ b/crates/xlsx/src/sheet_write.rs
@@ -698,8 +698,10 @@ fn write_cell(
     let value = match value {
         Value::Error(CellError::Circ) => Value::Number(0.0),
         // #SPILL! and #CALC! are not error codes of the file format (Excel refuses a file that
-        // caches them); Excel itself caches them as #VALUE!.
-        Value::Error(CellError::Spill | CellError::Calc) => Value::Error(CellError::Value),
+        // caches them); Excel itself caches them as #VALUE!. The Python errors are the same kind.
+        Value::Error(CellError::Spill | CellError::Calc | CellError::Python | CellError::Busy | CellError::Timeout | CellError::Blocked) => {
+            Value::Error(CellError::Value)
+        }
         v => v,
     };
     // A formula read with dynamic-array metadata keeps it, even where the shape analysis would
diff --git a/crates/xlsx/src/tests/locale_numfmt.rs b/crates/xlsx/src/tests/locale_numfmt.rs
index 3259a3657..749d832ad 100644
--- a/crates/xlsx/src/tests/locale_numfmt.rs
+++ b/crates/xlsx/src/tests/locale_numfmt.rs
@@ -25,7 +25,7 @@ fn round_trip(code: &str) -> (u32, String, String) {
     let mut wb = Workbook::new();
     let style = wb.styles.derive(StyleId::DEFAULT, |s| s.num_fmt = NumFmt::new(code));
     let mut sheet = Sheet::new("Sheet1");
-    sheet.cells.set(CellRef::new(0, 0), Cell { value: Value::Number(-0.14), formula: None, style });
+    sheet.cells.set(CellRef::new(0, 0), Cell { value: Value::Number(-0.14), formula: None, style, py: None });
     wb.sheets = vec![Arc::new(sheet)];
     let bytes = write_xlsx(&wb).unwrap();
     let xml = styles_xml(&bytes);
diff --git a/crates/xlsx/src/tests/phonetic_tests.rs b/crates/xlsx/src/tests/phonetic_tests.rs
index 37f37ed2b..43b30b6ba 100644
--- a/crates/xlsx/src/tests/phonetic_tests.rs
+++ b/crates/xlsx/src/tests/phonetic_tests.rs
@@ -33,7 +33,7 @@ fn part(bytes: &[u8], name: &str) -> String {
 }
 
 fn text_cell(sheet: &mut gridcraft_model::Sheet, a: &str, text: &str) {
-    sheet.cells.set(at(a), Cell { value: Value::text(text), formula: None, style: StyleId::DEFAULT });
+    sheet.cells.set(at(a), Cell { value: Value::text(text), formula: None, style: StyleId::DEFAULT, py: None });
 }
 
 #[test]
diff --git a/crates/xlsx/src/tests/pivot_tests.rs b/crates/xlsx/src/tests/pivot_tests.rs
index b9123e432..4f2c89dbd 100644
--- a/crates/xlsx/src/tests/pivot_tests.rs
+++ b/crates/xlsx/src/tests/pivot_tests.rs
@@ -52,7 +52,7 @@ fn workbook() -> Workbook {
         let r = r as u32 + 1;
         data.cells.set(CellRef::new(r, 0), Cell::value(Value::text(*a)));
         data.cells.set(CellRef::new(r, 1), Cell::value(Value::text(*b)));
-        data.cells.set(CellRef::new(r, 2), Cell { value: Value::number(*d), formula: None, style: date_style });
+        data.cells.set(CellRef::new(r, 2), Cell { value: Value::number(*d), formula: None, style: date_style, py: None });
         data.cells.set(CellRef::new(r, 3), Cell::value(Value::number(*u)));
         data.cells.set(CellRef::new(r, 4), Cell::value(Value::number(*s)));
         data.cells.set(CellRef::new(r, 5), Cell::value(Value::text(*ch)));
diff --git a/crates/xlsx/src/tests/roundtrip.rs b/crates/xlsx/src/tests/roundtrip.rs
index 14fc784f9..fe01f284e 100644
--- a/crates/xlsx/src/tests/roundtrip.rs
+++ b/crates/xlsx/src/tests/roundtrip.rs
@@ -64,7 +64,7 @@ fn sample() -> Workbook {
     };
 
     let mut s = Sheet::new("Data & Stuff");
-    let set = |s: &mut Sheet, a: &str, v: Value, style: StyleId| s.cells.set(at(a), Cell { value: v, formula: None, style });
+    let set = |s: &mut Sheet, a: &str, v: Value, style: StyleId| s.cells.set(at(a), Cell { value: v, formula: None, style, py: None });
     set(&mut s, "A1", Value::text("Region"), bold);
     set(&mut s, "B1", Value::text("Amount"), bold);
     set(&mut s, "C1", Value::text("  spaced\nline _x0041_ \u{1} "), StyleId::DEFAULT);
@@ -839,7 +839,7 @@ fn writing_repairs_invalid_models() {
         table_type: None,
         connection_id: None,
     });
-    s.cells.set(at("B2"), Cell { value: Value::Number(1.0), formula: None, style: StyleId(9999) });
+    s.cells.set(at("B2"), Cell { value: Value::Number(1.0), formula: None, style: StyleId(9999), py: None });
     let (back, _) = read_xlsx(&write_xlsx(&wb).unwrap()).unwrap();
     let s = back.sheet(0).unwrap();
     assert_eq!(s.visibility, Visibility::Visible, "at least one sheet stays visible");
diff --git a/crates/xlsx/src/xls/mod.rs b/crates/xlsx/src/xls/mod.rs
index ca3ec9eb3..90ecf629d 100644
--- a/crates/xlsx/src/xls/mod.rs
+++ b/crates/xlsx/src/xls/mod.rs
@@ -454,7 +454,7 @@ impl SheetState<'_> {
             return Ok(Some(pos));
         }
         budget.cell()?;
-        self.sheet.cells.set(pos, Cell { value, formula: None, style });
+        self.sheet.cells.set(pos, Cell { value, formula: None, style, py: None });
         Ok(Some(pos))
     }
 
@@ -472,7 +472,7 @@ impl SheetState<'_> {
                 if let Some(cell) = self.sheet.cells.get_mut(pos) {
                     cell.formula = Some(Arc::new(f));
                 } else {
-                    self.sheet.cells.set(pos, Cell { value: Value::Empty, formula: Some(Arc::new(f)), style: StyleId::DEFAULT });
+                    self.sheet.cells.set(pos, Cell { value: Value::Empty, formula: Some(Arc::new(f)), style: StyleId::DEFAULT, py: None });
                 }
             }
             Err(Unsupported(why)) => self.unsupported(why),
@@ -531,7 +531,7 @@ fn blank_array_followers(st: &mut SheetState<'_>, pending: &[Pending]) {
         let filled = st.sheet.cell(p.anchor).and_then(|c| c.formula.as_ref()).and_then(|f| f.array).is_some_and(|r| r.contains(p.pos));
         if p.pos != p.anchor && filled {
             let style = st.sheet.style_id(p.pos);
-            st.sheet.cells.set(p.pos, Cell { value: Value::Empty, formula: None, style });
+            st.sheet.cells.set(p.pos, Cell { value: Value::Empty, formula: None, style, py: None });
         }
     }
 }
@@ -677,7 +677,7 @@ fn sheet_record(rec: &Record<'_>, st: &mut SheetState<'_>, budget: &mut Budget,
                 if let Some(cell) = st.sheet.cells.get_mut(pos) {
                     cell.value = Value::from(s);
                 } else {
-                    st.sheet.cells.set(pos, Cell { value: Value::from(s), formula: None, style });
+                    st.sheet.cells.set(pos, Cell { value: Value::from(s), formula: None, style, py: None });
                 }
             }
         }
@@ -832,7 +832,7 @@ fn formula_cell(c: &mut Cursor<'_, '_>, st: &mut SheetState<'_>, budget: &mut Bu
     let Some(pos) = st.pos(r, col) else { return Ok(()) };
     budget.cell()?;
     let style = st.style(x);
-    st.sheet.cells.set(pos, Cell { value, formula: None, style });
+    st.sheet.cells.set(pos, Cell { value, formula: None, style, py: None });
     st.last_formula = Some(pos);
     if string_result {
         st.pending_string = Some((pos, style));