diff --git a/libs/@hashintel/petrinaut/src/expression/expression-ir.ts b/libs/@hashintel/petrinaut/src/expression/expression-ir.ts
new file mode 100644
index 00000000000..e5cc5d14cd5
--- /dev/null
+++ b/libs/@hashintel/petrinaut/src/expression/expression-ir.ts
@@ -0,0 +1,169 @@
+/**
+ * JSON-based intermediate representation for mathematical expressions.
+ *
+ * This IR captures the semantic structure of expressions parsed from
+ * TypeScript source code — bindings, expressions, and probability
+ * distributions — providing a JSON-serializable format that can be
+ * translated to various backends (e.g., SymPy).
+ */
+
+export type ExpressionIR =
+  | NumberNode
+  | BooleanNode
+  | InfinityNode
+  | SymbolNode
+  | ParameterNode
+  | TokenAccessNode
+  | BinaryNode
+  | UnaryNode
+  | CallNode
+  | DistributionNode
+  | DerivedDistributionNode
+  | PiecewiseNode
+  | ArrayNode
+  | ObjectNode
+  | ListComprehensionNode
+  | LetNode
+  | PropertyAccessNode
+  | ElementAccessNode;
+
+export type NumberNode = {
+  type: "number";
+  /** Exact string representation from source, e.g. "3.14" */
+  value: string;
+};
+
+export type BooleanNode = {
+  type: "boolean";
+  value: boolean;
+};
+
+export type InfinityNode = {
+  type: "infinity";
+};
+
+/** A generic symbol (local binding, iterator variable, etc.) */
+export type SymbolNode = {
+  type: "symbol";
+  name: string;
+};
+
+/** A model parameter reference (from `parameters.<name>`) */
+export type ParameterNode = {
+  type: "parameter";
+  name: string;
+};
+
+/** Token field access: `tokens.<place>[<index>].<field>` */
+export type TokenAccessNode = {
+  type: "tokenAccess";
+  place: string;
+  index: ExpressionIR;
+  field: string;
+};
+
+export type BinaryOp =
+  | "+"
+  | "-"
+  | "*"
+  | "/"
+  | "**"
+  | "%"
+  | "<"
+  | "<="
+  | ">"
+  | ">="
+  | "=="
+  | "!="
+  | "&&"
+  | "||";
+
+export type BinaryNode = {
+  type: "binary";
+  op: BinaryOp;
+  left: ExpressionIR;
+  right: ExpressionIR;
+};
+
+export type UnaryOp = "-" | "!" | "+";
+
+export type UnaryNode = {
+  type: "unary";
+  op: UnaryOp;
+  operand: ExpressionIR;
+};
+
+/** A math function call (e.g. cos, sin, sqrt, hypot, pow, min, max) */
+export type CallNode = {
+  type: "call";
+  fn: string;
+  args: ExpressionIR[];
+};
+
+/** A probability distribution (e.g. Gaussian, Uniform, Lognormal) */
+export type DistributionNode = {
+  type: "distribution";
+  distribution: string;
+  args: ExpressionIR[];
+};
+
+/**
+ * A distribution transformed by a function: `dist.map(fn)`.
+ *
+ * Example: `Distribution.Gaussian(0, 10).map(Math.cos)` produces a
+ * derived distribution where samples are drawn from the base and then
+ * transformed through the body expression.
+ */
+export type DerivedDistributionNode = {
+  type: "derivedDistribution";
+  distribution: ExpressionIR;
+  variable: string;
+  body: ExpressionIR;
+};
+
+/** Conditional expression (ternary) */
+export type PiecewiseNode = {
+  type: "piecewise";
+  condition: ExpressionIR;
+  whenTrue: ExpressionIR;
+  whenFalse: ExpressionIR;
+};
+
+export type ArrayNode = {
+  type: "array";
+  elements: ExpressionIR[];
+};
+
+export type ObjectNode = {
+  type: "object";
+  entries: { key: string; value: ExpressionIR }[];
+};
+
+/** List comprehension from `.map()` calls */
+export type ListComprehensionNode = {
+  type: "listComprehension";
+  body: ExpressionIR;
+  variable: string;
+  collection: ExpressionIR;
+};
+
+/** Scoped const bindings wrapping a body expression */
+export type LetNode = {
+  type: "let";
+  bindings: { name: string; value: ExpressionIR }[];
+  body: ExpressionIR;
+};
+
+/** Fallback property access: `<object>.<property>` */
+export type PropertyAccessNode = {
+  type: "propertyAccess";
+  object: ExpressionIR;
+  property: string;
+};
+
+/** Fallback element access: `<object>[<index>]` */
+export type ElementAccessNode = {
+  type: "elementAccess";
+  object: ExpressionIR;
+  index: ExpressionIR;
+};
diff --git a/libs/@hashintel/petrinaut/src/expression/expression-output-panel.tsx b/libs/@hashintel/petrinaut/src/expression/expression-output-panel.tsx
new file mode 100644
index 00000000000..4e68645a84d
--- /dev/null
+++ b/libs/@hashintel/petrinaut/src/expression/expression-output-panel.tsx
@@ -0,0 +1,80 @@
+import { css } from "@hashintel/ds-helpers/css";
+import { useState } from "react";
+
+import { Select } from "../components/select";
+import { CodeEditor } from "../monaco/code-editor";
+import type {
+  ExpressionOutput,
+  ExpressionOutputFormat,
+} from "./use-expression-ir-output";
+
+const FORMAT_LANGUAGE: Record<ExpressionOutputFormat, string> = {
+  ir: "json",
+  sympy: "python",
+  ocaml: "fsharp",
+  lean: "fsharp",
+};
+
+const containerStyle = css({
+  position: "relative",
+  height: "full",
+});
+
+const selectContainerStyle = css({
+  display: "flex",
+  alignItems: "center",
+  gap: "1",
+  position: "absolute",
+  bottom: "[1px]",
+  right: "[1px]",
+  zIndex: "[10]",
+  backdropFilter: "[blur(20px)]",
+  p: "1",
+  pl: "2",
+  borderTopLeftRadius: "sm",
+  borderBottomRightRadius: "sm",
+});
+
+const selectLabelStyle = css({
+  fontSize: "xs",
+  fontWeight: "medium",
+  color: "neutral.s80",
+});
+
+const selectStyle = css({
+  width: "[90px]",
+});
+
+export const ExpressionOutputPanel: React.FC<{
+  output: ExpressionOutput;
+}> = ({ output }) => {
+  const [format, setFormat] = useState<ExpressionOutputFormat>("ir");
+
+  return (
+    <div className={containerStyle}>
+      <div className={selectContainerStyle}>
+        <span className={selectLabelStyle}>Target</span>
+        <Select
+          value={format}
+          className={selectStyle}
+          onValueChange={(value) => setFormat(value as ExpressionOutputFormat)}
+          options={[
+            { value: "ir", label: "IR" },
+            { value: "sympy", label: "SymPy" },
+            { value: "ocaml", label: "OCaml" },
+            { value: "lean", label: "Lean" },
+          ]}
+          size="xs"
+          portal={false}
+        />
+      </div>
+      <CodeEditor
+        key={format}
+        value={output[format]}
+        defaultLanguage={FORMAT_LANGUAGE[format]}
+        height="100%"
+        options={{ readOnly: true, lineNumbers: "off" }}
+      />
+    </div>
+  );
+};
diff --git a/libs/@hashintel/petrinaut/src/expression/ir-to-lean/ir-to-lean.ts b/libs/@hashintel/petrinaut/src/expression/ir-to-lean/ir-to-lean.ts
new file mode 100644
index 00000000000..627ef2aed14
--- /dev/null
+++ b/libs/@hashintel/petrinaut/src/expression/ir-to-lean/ir-to-lean.ts
@@ -0,0 +1,322 @@
+import type { ExpressionIR } from "../expression-ir";
+
+const INDENT = "  ";
+function pad(level: number): string {
+  return INDENT.repeat(level);
+}
+
+const MATH_FN_MAP: Record<string, string> = {
+  cos: "Real.cos",
+  sin: "Real.sin",
+  tan: "Real.tan",
+  acos: "Real.arccos",
+  asin: "Real.arcsin",
+  atan: "Real.arctan",
+  atan2: "Real.arctan2",
+  sqrt: "Real.sqrt",
+  log: "Real.log",
+  exp: "Real.exp",
+  abs: "abs",
+  floor: "⌊·⌋",
+  ceil: "⌈·⌉",
+  min: "min",
+  max: "max",
+};
+
+const MATH_CONSTANT_MAP: Record<string, string> = {
+  PI: "Real.pi",
+  E: "Real.exp 1",
+};
+
+const DISTRIBUTION_MAP: Record<string, { fn: string; import: string }> = {
+  Gaussian: {
+    fn: "gaussianReal",
+    import: "Mathlib.Probability.Distributions.Gaussian",
+  },
+  Uniform: {
+    fn: "uniformOn (Set.Icc",
+    import: "Mathlib.Probability.Distributions.Uniform",
+  },
+  Lognormal: {
+    fn: "lognormalReal",
+    import: "Mathlib.Probability.Distributions.Gaussian",
+  },
+};
+
+/**
+ * Accumulates imports and let-bindings for clean Lean 4 output.
+ */
+class LeanEmitter {
+  readonly imports = new Set<string>();
+  readonly statements: string[] = [];
+  private readonly env: Map<string, string>;
+
+  constructor(env?: Map<string, string>) {
+    this.env = new Map(env);
+  }
+
+  private addImport(module: string): void {
+    this.imports.add(module);
+  }
+
+  setEnv(name: string, value: string): void {
+    this.env.set(name, value);
+  }
+
+  emit(node: ExpressionIR, indent = 0): string {
+    switch (node.type) {
+      case "number":
+        return node.value;
+
+      case "boolean":
+        return node.value ? "True" : "False";
+
+      case "infinity": {
+        this.addImport("Mathlib.Order.BoundedOrder");
+        return "⊤";
+      }
+
+      case "symbol": {
+        const constant = MATH_CONSTANT_MAP[node.name];
+        if (constant) {
+          this.addImport(
+            "Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic",
+          );
+          return constant;
+        }
+        return this.env.get(node.name) ?? node.name;
+      }
+
+      case "parameter":
+        return node.name;
+
+      case "tokenAccess": {
+        const index = this.emit(node.index);
+        return `${node.place}_${index}_${node.field}`;
+      }
+
+      case "binary": {
+        const left = this.emit(node.left, indent);
+        const right = this.emit(node.right, indent);
+        return this.emitBinaryOp(node.op, left, right);
+      }
+
+      case "unary": {
+        const operand = this.emit(node.operand, indent);
+        switch (node.op) {
+          case "-":
+            return `-(${operand})`;
+          case "!":
+            return `¬(${operand})`;
+          case "+":
+            return operand;
+        }
+        break;
+      }
+
+      case "call":
+        return this.emitCall(node.fn, node.args, indent);
+
+      case "distribution": {
+        const dist = DISTRIBUTION_MAP[node.distribution];
+        if (!dist) return `${node.distribution}(?)`;
+        this.addImport(dist.import);
+        const args = node.args.map((a) => this.emit(a, indent));
+        if (node.distribution === "Uniform") {
+          return `uniformOn (Set.Icc ${args[0]!} ${args[1]!})`;
+        }
+        return `${dist.fn} ${args.join(" ")}`;
+      }
+
+      case "derivedDistribution": {
+        const dist = this.emit(node.distribution, indent);
+        this.setEnv(node.variable, dist);
+        return this.emit(node.body, indent);
+      }
+
+      case "piecewise": {
+        const condition = this.emit(node.condition, indent);
+        const whenTrue = this.emit(node.whenTrue, indent);
+        const whenFalse = this.emit(node.whenFalse, indent);
+        return `if ${condition} then ${whenTrue} else ${whenFalse}`;
+      }
+
+      case "array": {
+        const elements = node.elements.map((e) => this.emit(e, indent));
+        const flat = `[${elements.join(", ")}]`;
+        if (flat.length <= 80 || elements.length <= 1) return flat;
+        const inner = pad(indent + 1);
+        const outer = pad(indent);
+        return `[\n${inner}${elements.join(`,\n${inner}`)}\n${outer}]`;
+      }
+
+      case "object": {
+        const entries = node.entries.map(
+          (e) => `${e.key} := ${this.emit(e.value, indent + 1)}`,
+        );
+        const flat = `{ ${entries.join(", ")} }`;
+        if (flat.length <= 80 || entries.length <= 1) return flat;
+        const inner = pad(indent + 1);
+        const outer = pad(indent);
+        return `{\n${inner}${entries.join(`,\n${inner}`)}\n${outer}}`;
+      }
+
+      case "listComprehension": {
+        const body = this.emit(node.body, indent);
+        const collection = this.emit(node.collection, indent);
+        return `${collection}.map (fun ${node.variable} => ${body})`;
+      }
+
+      case "let": {
+        for (const binding of node.bindings) {
+          if (binding.value.type === "distribution") {
+            this.emitNamedDistribution(binding.value, binding.name);
+          } else {
+            const value = this.emit(binding.value, indent);
+            this.statements.push(`let ${binding.name} : ℝ := ${value}`);
+          }
+          this.env.set(binding.name, binding.name);
+        }
+        return this.emit(node.body, indent);
+      }
+
+      case "propertyAccess": {
+        const obj = this.emit(node.object, indent);
+        return `${obj}.${node.property}`;
+      }
+
+      case "elementAccess": {
+        const obj = this.emit(node.object, indent);
+        const index = this.emit(node.index, indent);
+        return `${obj}[${index}]!`;
+      }
+    }
+  }
+
+  emitNamedDistribution(
+    node: ExpressionIR & { type: "distribution" },
+    name: string,
+  ): void {
+    const dist = DISTRIBUTION_MAP[node.distribution];
+    if (!dist) return;
+    this.addImport(dist.import);
+    const args = node.args.map((a) => this.emit(a));
+    if (node.distribution === "Uniform") {
+      this.statements.push(
+        `let ${name} := uniformOn (Set.Icc ${args[0]!} ${args[1]!})`,
+      );
+    } else {
+      this.statements.push(`let ${name} := ${dist.fn} ${args.join(" ")}`);
+    }
+  }
+
+  private emitCall(fn: string, args: ExpressionIR[], indent: number): string {
+    const compiledArgs = args.map((a) => this.emit(a, indent));
+
+    if (fn === "hypot") {
+      this.addImport("Mathlib.Analysis.SpecialFunctions.Pow.Real");
+      const sumOfSquares = compiledArgs.map((a) => `(${a}) ^ 2`).join(" + ");
+      return `Real.sqrt (${sumOfSquares})`;
+    }
+
+    if (fn === "pow" && compiledArgs.length === 2) {
+      return `(${compiledArgs[0]!}) ^ (${compiledArgs[1]!})`;
+    }
+
+    if (fn === "floor") {
+      return `⌊${compiledArgs[0]!}⌋`;
+    }
+
+    if (fn === "ceil") {
+      return `⌈${compiledArgs[0]!}⌉`;
+    }
+
+    const leanFn = MATH_FN_MAP[fn];
+    if (leanFn) {
+      if (fn === "cos" || fn === "sin" || fn === "tan") {
+        this.addImport("Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic");
+      } else if (fn === "acos" || fn === "asin" || fn === "atan") {
+        this.addImport(
+          "Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse",
+        );
+      } else if (fn === "sqrt" || fn === "log" || fn === "exp") {
+        this.addImport("Mathlib.Analysis.SpecialFunctions.Pow.Real");
+      }
+      return `${leanFn} ${compiledArgs.map((a) => `(${a})`).join(" ")}`;
+    }
+
+    return `${fn} ${compiledArgs.map((a) => `(${a})`).join(" ")}`;
+  }
+
+  private emitBinaryOp(op: string, left: string, right: string): string {
+    switch (op) {
+      case "+":
+        return `${left} + ${right}`;
+      case "-":
+        return `${left} - ${right}`;
+      case "*":
+        return `${left} * ${right}`;
+      case "/":
+        return `${left} / ${right}`;
+      case "**":
+        return `${left} ^ ${right}`;
+      case "%":
+        return `${left} % ${right}`;
+      case "<":
+        return `${left} < ${right}`;
+      case "<=":
+        return `${left} ≤ ${right}`;
+      case ">":
+        return `${left} > ${right}`;
+      case ">=":
+        return `${left} ≥ ${right}`;
+      case "==":
+        return `${left} = ${right}`;
+      case "!=":
+        return `${left} ≠ ${right}`;
+      case "&&":
+        return `${left} ∧ ${right}`;
+      case "||":
+        return `${left} ∨ ${right}`;
+      default:
+        return `${left} ${op} ${right}`;
+    }
+  }
+
+  renderImports(): string[] {
+    const sorted = [...this.imports].sort();
+    return sorted.map((m) => `import ${m}`);
+  }
+}
+
+/**
+ * Converts an expression IR node to Lean 4 code with Mathlib.
+ *
+ * Produces clean Lean with explicit imports, hoisted distributions,
+ * and let-bindings as variable assignments.
+ */
+export function irToLean(
+  node: ExpressionIR,
+  env: Map<string, string> = new Map(),
+): string {
+  const emitter = new LeanEmitter(env);
+  const expr = emitter.emit(node);
+
+  const imports = emitter.renderImports();
+  const parts: string[] = [];
+
+  if (imports.length > 0) {
+    parts.push(imports.join("\n"));
+  }
+
+  // Always open Real and ProbabilityTheory for cleaner code
+  parts.push("open Real ProbabilityTheory");
+
+  if (emitter.statements.length > 0) {
+    parts.push(emitter.statements.join("\n"));
+  }
+
+  parts.push(`return ${expr}`);
+
+  return parts.join("\n\n");
+}
diff --git a/libs/@hashintel/petrinaut/src/expression/ir-to-ocaml/ir-to-ocaml.ts b/libs/@hashintel/petrinaut/src/expression/ir-to-ocaml/ir-to-ocaml.ts
new file mode 100644
index 00000000000..dd50db15540
--- /dev/null
+++ b/libs/@hashintel/petrinaut/src/expression/ir-to-ocaml/ir-to-ocaml.ts
@@ -0,0 +1,228 @@
+import type { ExpressionIR } from "../expression-ir";
+
+const INDENT = "  ";
+function pad(level: number): string {
+  return INDENT.repeat(level);
+}
+
+const MATH_FN_MAP: Record<string, string> = {
+  cos: "Float.cos",
+  sin: "Float.sin",
+  tan: "Float.tan",
+  acos: "Float.acos",
+  asin: "Float.asin",
+  atan: "Float.atan",
+  atan2: "Float.atan2",
+  sqrt: "Float.sqrt",
+  log: "Float.log",
+  exp: "Float.exp",
+  abs: "Float.abs",
+  floor: "Float.round ~dir:`Down",
+  ceil: "Float.round ~dir:`Up",
+  min: "Float.min",
+  max: "Float.max",
+};
+
+const MATH_CONSTANT_MAP: Record<string, string> = {
+  PI: "Float.pi",
+  E: "Float.(exp 1.0)",
+};
+
+const DISTRIBUTION_MAP: Record<string, string> = {
+  Gaussian: "Distribution.gaussian",
+  Uniform: "Distribution.uniform",
+  Lognormal: "Distribution.lognormal",
+};
+
+/**
+ * Converts an expression IR node to OCaml code.
+ *
+ * Let-bindings are emitted as OCaml `let ... in` expressions.
+ */
+export function irToOCaml(
+  node: ExpressionIR,
+  env: Map<string, string> = new Map(),
+  indent = 0,
+): string {
+  switch (node.type) {
+    case "number": {
+      const val = node.value;
+      // OCaml float literals require a dot
+      return val.includes(".") ? val : `${val}.`;
+    }
+
+    case "boolean":
+      return node.value ? "true" : "false";
+
+    case "infinity":
+      return "Float.infinity";
+
+    case "symbol": {
+      const constant = MATH_CONSTANT_MAP[node.name];
+      if (constant) return constant;
+      return env.get(node.name) ?? node.name;
+    }
+
+    case "parameter":
+      return node.name;
+
+    case "tokenAccess": {
+      const index = irToOCaml(node.index, env);
+      return `${node.place}_${index}_${node.field}`;
+    }
+
+    case "binary": {
+      const left = irToOCaml(node.left, env);
+      const right = irToOCaml(node.right, env);
+      return emitBinaryOp(node.op, left, right);
+    }
+
+    case "unary": {
+      const operand = irToOCaml(node.operand, env);
+      switch (node.op) {
+        case "-":
+          return `Float.neg (${operand})`;
+        case "!":
+          return `not (${operand})`;
+        case "+":
+          return operand;
+      }
+      break;
+    }
+
+    case "call":
+      return emitCall(node.fn, node.args, env);
+
+    case "distribution": {
+      const distFn = DISTRIBUTION_MAP[node.distribution];
+      const args = node.args.map((a) => irToOCaml(a, env));
+      return `${distFn} ${args.map((a) => `(${a})`).join(" ")}`;
+    }
+
+    case "derivedDistribution": {
+      const dist = irToOCaml(node.distribution, env, indent);
+      const localEnv = new Map(env);
+      localEnv.set(node.variable, dist);
+      return irToOCaml(node.body, localEnv, indent);
+    }
+
+    case "piecewise": {
+      const condition = irToOCaml(node.condition, env);
+      const whenTrue = irToOCaml(node.whenTrue, env);
+      const whenFalse = irToOCaml(node.whenFalse, env);
+      return `if ${condition} then ${whenTrue} else ${whenFalse}`;
+    }
+
+    case "array": {
+      const elements = node.elements.map((e) => irToOCaml(e, env, indent));
+      const flat = `[${elements.join("; ")}]`;
+      if (flat.length <= 80 || elements.length <= 1) return flat;
+      const inner = pad(indent + 1);
+      const outer = pad(indent);
+      return `[\n${inner}${elements.join(`;\n${inner}`)}\n${outer}]`;
+    }
+
+    case "object": {
+      const entries = node.entries.map(
+        (e) => `${e.key} = ${irToOCaml(e.value, env, indent + 1)}`,
+      );
+      const flat = `{ ${entries.join("; ")} }`;
+      if (flat.length <= 80 || entries.length <= 1) return flat;
+      const inner = pad(indent + 1);
+      const outer = pad(indent);
+      return `{\n${inner}${entries.join(`;\n${inner}`)}\n${outer}}`;
+    }
+
+    case "listComprehension": {
+      const body = irToOCaml(node.body, env);
+      const collection = irToOCaml(node.collection, env);
+      return `List.map (fun ${node.variable} -> ${body}) ${collection}`;
+    }
+
+    case "let": {
+      let result = "";
+      const localEnv = new Map(env);
+      for (const binding of node.bindings) {
+        const value = irToOCaml(binding.value, localEnv);
+        result += `let ${binding.name} = ${value} in\n`;
+        localEnv.set(binding.name, binding.name);
+      }
+      result += irToOCaml(node.body, localEnv);
+      return result;
+    }
+
+    case "propertyAccess": {
+      const obj = irToOCaml(node.object, env);
+      return `(${obj}).${node.property}`;
+    }
+
+    case "elementAccess": {
+      const obj = irToOCaml(node.object, env);
+      const index = irToOCaml(node.index, env);
+      return `List.nth (${obj}) (${index})`;
+    }
+  }
+}
+
+function emitBinaryOp(op: string, left: string, right: string): string {
+  switch (op) {
+    case "+":
+      return `(${left}) +. (${right})`;
+    case "-":
+      return `(${left}) -. (${right})`;
+    case "*":
+      return `(${left}) *. (${right})`;
+    case "/":
+      return `(${left}) /. (${right})`;
+    case "**":
+      return `(${left}) ** (${right})`;
+    case "%":
+      return `Float.mod_float (${left}) (${right})`;
+    case "<":
+      return `Float.( < ) (${left}) (${right})`;
+    case "<=":
+      return `Float.( <= ) (${left}) (${right})`;
+    case ">":
+      return `Float.( > ) (${left}) (${right})`;
+    case ">=":
+      return `Float.( >= ) (${left}) (${right})`;
+    case "==":
+      return `Float.( = ) (${left}) (${right})`;
+    case "!=":
+      return `Float.( <> ) (${left}) (${right})`;
+    case "&&":
+      return `(${left}) && (${right})`;
+    case "||":
+      return `(${left}) || (${right})`;
+    default:
+      return `(${left}) ${op} (${right})`;
+  }
+}
+
+function emitCall(
+  fn: string,
+  args: ExpressionIR[],
+  env: Map<string, string>,
+): string {
+  const compiledArgs = args.map((a) => irToOCaml(a, env));
+
+  // Math.hypot(a, b) → Float.sqrt (a *. a +. b *. b)
+  if (fn === "hypot") {
+    const sumOfSquares = compiledArgs
+      .map((a) => `(${a}) *. (${a})`)
+      .join(" +. ");
+    return `Float.sqrt (${sumOfSquares})`;
+  }
+
+  // Math.pow(a, b) → a ** b
+  if (fn === "pow" && compiledArgs.length === 2) {
+    return `(${compiledArgs[0]!}) ** (${compiledArgs[1]!})`;
+  }
+
+  const ocamlFn = MATH_FN_MAP[fn];
+  if (ocamlFn) {
+    return `${ocamlFn} (${compiledArgs.join(") (")})`;
+  }
+
+  return `${fn} (${compiledArgs.join(") (")})`;
+}
diff --git a/libs/@hashintel/petrinaut/src/expression/ir-to-sympy/ir-to-sympy.test.ts b/libs/@hashintel/petrinaut/src/expression/ir-to-sympy/ir-to-sympy.test.ts
new file mode 100644
index 00000000000..ef89d8ad325
--- /dev/null
+++ b/libs/@hashintel/petrinaut/src/expression/ir-to-sympy/ir-to-sympy.test.ts
@@ -0,0 +1,382 @@
+import { describe, expect, it } from "vitest";
+
+import type { ExpressionIR } from "../expression-ir";
+import { irToSymPy } from "./ir-to-sympy";
+
+describe("irToSymPy", () => {
+  describe("literals", () => {
+    it("should emit number", () => {
+      expect(irToSymPy({ type: "number", value: "42" })).toBe("return 42");
+    });
+
+    it("should emit boolean true as True", () => {
+      expect(irToSymPy({ type: "boolean", value: true })).toBe("return True");
+    });
+
+    it("should emit boolean false as False", () => {
+      expect(irToSymPy({ type: "boolean", value: false })).toBe("return False");
+    });
+
+    it("should emit infinity with import", () => {
+      expect(irToSymPy({ type: "infinity" })).toBe(
+        "from sympy import oo\n\nreturn oo",
+      );
+    });
+  });
+
+  describe("symbols and parameters", () => {
+    it("should emit symbol name", () => {
+      expect(irToSymPy({ type: "symbol", name: "x" })).toBe("return x");
+    });
+
+    it("should emit parameter name", () => {
+      expect(irToSymPy({ type: "parameter", name: "infection_rate" })).toBe(
+        "return infection_rate",
+      );
+    });
+
+    it("should emit Math constants with import", () => {
+      expect(irToSymPy({ type: "symbol", name: "PI" })).toBe(
+        "from sympy import pi\n\nreturn pi",
+      );
+      expect(irToSymPy({ type: "symbol", name: "E" })).toBe(
+        "from sympy import E\n\nreturn E",
+      );
+    });
+  });
+
+  describe("token access", () => {
+    it("should emit Place_index_field format", () => {
+      expect(
+        irToSymPy({
+          type: "tokenAccess",
+          place: "Space",
+          index: { type: "number", value: "0" },
+          field: "x",
+        }),
+      ).toBe("return Space_0_x");
+    });
+  });
+
+  describe("binary operations", () => {
+    const left: ExpressionIR = { type: "number", value: "1" };
+    const right: ExpressionIR = { type: "number", value: "2" };
+
+    it("should emit arithmetic operators", () => {
+      expect(irToSymPy({ type: "binary", op: "+", left, right })).toBe(
+        "return 1 + 2",
+      );
+      expect(irToSymPy({ type: "binary", op: "*", left, right })).toBe(
+        "return 1 * 2",
+      );
+      expect(irToSymPy({ type: "binary", op: "**", left, right })).toBe(
+        "return 1**2",
+      );
+    });
+
+    it("should emit modulo as Mod with import", () => {
+      expect(irToSymPy({ type: "binary", op: "%", left, right })).toBe(
+        "from sympy import Mod\n\nreturn Mod(1, 2)",
+      );
+    });
+
+    it("should emit equality as Eq with import", () => {
+      expect(irToSymPy({ type: "binary", op: "==", left, right })).toBe(
+        "from sympy import Eq\n\nreturn Eq(1, 2)",
+      );
+    });
+
+    it("should emit inequality as Ne with import", () => {
+      expect(irToSymPy({ type: "binary", op: "!=", left, right })).toBe(
+        "from sympy import Ne\n\nreturn Ne(1, 2)",
+      );
+    });
+
+    it("should emit logical operators with imports", () => {
+      expect(irToSymPy({ type: "binary", op: "&&", left, right })).toBe(
+        "from sympy import And\n\nreturn And(1, 2)",
+      );
+      expect(irToSymPy({ type: "binary", op: "||", left, right })).toBe(
+        "from sympy import Or\n\nreturn Or(1, 2)",
+      );
+    });
+  });
+
+  describe("unary operations", () => {
+    it("should emit negation", () => {
+      expect(
+        irToSymPy({
+          type: "unary",
+          op: "-",
+          operand: { type: "symbol", name: "x" },
+        }),
+      ).toBe("return -(x)");
+    });
+
+    it("should emit logical not with import", () => {
+      expect(
+        irToSymPy({
+          type: "unary",
+          op: "!",
+          operand: { type: "boolean", value: true },
+        }),
+      ).toBe("from sympy import Not\n\nreturn Not(True)");
+    });
+  });
+
+  describe("function calls", () => {
+    it("should emit math functions with import", () => {
+      expect(
+        irToSymPy({
+          type: "call",
+          fn: "cos",
+          args: [{ type: "symbol", name: "x" }],
+        }),
+      ).toBe("from sympy import cos\n\nreturn cos(x)");
+    });
+
+    it("should emit hypot as sqrt of sum of squares", () => {
+      expect(
+        irToSymPy({
+          type: "call",
+          fn: "hypot",
+          args: [
+            { type: "symbol", name: "a" },
+            { type: "symbol", name: "b" },
+          ],
+        }),
+      ).toBe("from sympy import sqrt\n\nreturn sqrt((a)**2 + (b)**2)");
+    });
+
+    it("should emit pow as exponentiation", () => {
+      expect(
+        irToSymPy({
+          type: "call",
+          fn: "pow",
+          args: [
+            { type: "symbol", name: "a" },
+            { type: "number", value: "2" },
+          ],
+        }),
+      ).toBe("return (a)**(2)");
+    });
+  });
+
+  describe("distributions", () => {
+    it("should emit inline Gaussian as Normal", () => {
+      expect(
+        irToSymPy({
+          type: "distribution",
+          distribution: "Gaussian",
+          args: [
+            { type: "number", value: "0" },
+            { type: "number", value: "1" },
+          ],
+        }),
+      ).toBe("from sympy.stats import Normal\n\nreturn Normal(0, 1)");
+    });
+
+    it("should emit inline Lognormal as LogNormal", () => {
+      expect(
+        irToSymPy({
+          type: "distribution",
+          distribution: "Lognormal",
+          args: [
+            { type: "number", value: "0" },
+            { type: "number", value: "1" },
+          ],
+        }),
+      ).toBe("from sympy.stats import LogNormal\n\nreturn LogNormal(0, 1)");
+    });
+
+    it("should emit named distribution from let-binding with symbol name", () => {
+      expect(
+        irToSymPy({
+          type: "let",
+          bindings: [
+            {
+              name: "angle",
+              value: {
+                type: "distribution",
+                distribution: "Uniform",
+                args: [
+                  { type: "number", value: "0" },
+                  { type: "number", value: "1" },
+                ],
+              },
+            },
+          ],
+          body: { type: "symbol", name: "angle" },
+        }),
+      ).toBe(
+        [
+          "from sympy.stats import Uniform",
+          "",
+          "angle = Uniform('angle', 0, 1)",
+          "",
+          "return angle",
+        ].join("\n"),
+      );
+    });
+  });
+
+  describe("derived distributions", () => {
+    it("should substitute inline distribution into body", () => {
+      expect(
+        irToSymPy({
+          type: "derivedDistribution",
+          distribution: {
+            type: "distribution",
+            distribution: "Gaussian",
+            args: [
+              { type: "number", value: "0" },
+              { type: "number", value: "10" },
+            ],
+          },
+          variable: "_x",
+          body: {
+            type: "call",
+            fn: "cos",
+            args: [{ type: "symbol", name: "_x" }],
+          },
+        }),
+      ).toBe(
+        [
+          "from sympy import cos",
+          "from sympy.stats import Normal",
+          "",
+          "return cos(Normal(0, 10))",
+        ].join("\n"),
+      );
+    });
+  });
+
+  describe("piecewise", () => {
+    it("should emit Piecewise with import", () => {
+      expect(
+        irToSymPy({
+          type: "piecewise",
+          condition: {
+            type: "binary",
+            op: ">",
+            left: { type: "symbol", name: "x" },
+            right: { type: "number", value: "0" },
+          },
+          whenTrue: { type: "symbol", name: "x" },
+          whenFalse: { type: "number", value: "0" },
+        }),
+      ).toBe(
+        "from sympy import Piecewise\n\nreturn Piecewise((x, x > 0), (0, True))",
+      );
+    });
+  });
+
+  describe("collections", () => {
+    it("should emit array as Python list", () => {
+      expect(
+        irToSymPy({
+          type: "array",
+          elements: [
+            { type: "number", value: "1" },
+            { type: "number", value: "2" },
+          ],
+        }),
+      ).toBe("return [1, 2]");
+    });
+
+    it("should emit object as Python dict", () => {
+      expect(
+        irToSymPy({
+          type: "object",
+          entries: [
+            { key: "x", value: { type: "number", value: "1" } },
+            { key: "y", value: { type: "number", value: "2" } },
+          ],
+        }),
+      ).toBe("return {'x': 1, 'y': 2}");
+    });
+  });
+
+  describe("list comprehension", () => {
+    it("should emit Python list comprehension", () => {
+      expect(
+        irToSymPy({
+          type: "listComprehension",
+          variable: "_iter",
+          collection: { type: "symbol", name: "tokens" },
+          body: {
+            type: "binary",
+            op: "+",
+            left: { type: "symbol", name: "_iter" },
+            right: { type: "number", value: "1" },
+          },
+        }),
+      ).toBe("return [_iter + 1 for _iter in tokens]");
+    });
+  });
+
+  describe("let bindings", () => {
+    it("should emit single binding as assignment", () => {
+      expect(
+        irToSymPy({
+          type: "let",
+          bindings: [
+            {
+              name: "mu",
+              value: { type: "parameter", name: "gravitational_constant" },
+            },
+          ],
+          body: {
+            type: "binary",
+            op: "*",
+            left: { type: "symbol", name: "mu" },
+            right: { type: "number", value: "2" },
+          },
+        }),
+      ).toBe("mu = gravitational_constant\n\nreturn mu * 2");
+    });
+
+    it("should emit chained bindings as assignments", () => {
+      expect(
+        irToSymPy({
+          type: "let",
+          bindings: [
+            { name: "a", value: { type: "parameter", name: "infection_rate" } },
+            {
+              name: "b",
+              value: { type: "parameter", name: "recovery_rate" },
+            },
+          ],
+          body: {
+            type: "binary",
+            op: "+",
+            left: { type: "symbol", name: "a" },
+            right: { type: "symbol", name: "b" },
+          },
+        }),
+      ).toBe("a = infection_rate\nb = recovery_rate\n\nreturn a + b");
+    });
+  });
+
+  describe("property and element access fallbacks", () => {
+    it("should emit property access with underscore", () => {
+      expect(
+        irToSymPy({
+          type: "propertyAccess",
+          object: { type: "symbol", name: "obj" },
+          property: "field",
+        }),
+      ).toBe("return obj_field");
+    });
+
+    it("should emit element access with underscore", () => {
+      expect(
+        irToSymPy({
+          type: "elementAccess",
+          object: { type: "symbol", name: "arr" },
+          index: { type: "number", value: "0" },
+        }),
+      ).toBe("return arr_0");
+    });
+  });
+});
diff --git a/libs/@hashintel/petrinaut/src/expression/ir-to-sympy/ir-to-sympy.ts b/libs/@hashintel/petrinaut/src/expression/ir-to-sympy/ir-to-sympy.ts
new file mode 100644
index 00000000000..16aab28199b
--- /dev/null
+++ b/libs/@hashintel/petrinaut/src/expression/ir-to-sympy/ir-to-sympy.ts
@@ -0,0 +1,329 @@
+import type { ExpressionIR } from "../expression-ir";
+
+/** Maps IR function names to SymPy names and their `sympy` module path. */
+const MATH_FN_MAP: Record<string, { name: string; module: "sympy" }> = {
+  cos: { name: "cos", module: "sympy" },
+  sin: { name: "sin", module: "sympy" },
+  tan: { name: "tan", module: "sympy" },
+  acos: { name: "acos", module: "sympy" },
+  asin: { name: "asin", module: "sympy" },
+  atan: { name: "atan", module: "sympy" },
+  atan2: { name: "atan2", module: "sympy" },
+  sqrt: { name: "sqrt", module: "sympy" },
+  log: { name: "log", module: "sympy" },
+  exp: { name: "exp", module: "sympy" },
+  abs: { name: "Abs", module: "sympy" },
+  floor: { name: "floor", module: "sympy" },
+  ceil: { name: "ceiling", module: "sympy" },
+  min: { name: "Min", module: "sympy" },
+  max: { name: "Max", module: "sympy" },
+};
+
+const MATH_CONSTANT_MAP: Record<string, { name: string; module: "sympy" }> = {
+  PI: { name: "pi", module: "sympy" },
+  E: { name: "E", module: "sympy" },
+};
+
+const DISTRIBUTION_MAP: Record<
+  string,
+  { name: string; module: "sympy.stats" }
+> = {
+  Gaussian: { name: "Normal", module: "sympy.stats" },
+  Uniform: { name: "Uniform", module: "sympy.stats" },
+  Lognormal: { name: "LogNormal", module: "sympy.stats" },
+};
+
+/** Symbols that need `from sympy import ...` */
+const SYMPY_SYMBOLS: Record<string, { name: string; module: "sympy" }> = {
+  Piecewise: { name: "Piecewise", module: "sympy" },
+  Mod: { name: "Mod", module: "sympy" },
+  Eq: { name: "Eq", module: "sympy" },
+  Ne: { name: "Ne", module: "sympy" },
+  And: { name: "And", module: "sympy" },
+  Or: { name: "Or", module: "sympy" },
+  Not: { name: "Not", module: "sympy" },
+  oo: { name: "oo", module: "sympy" },
+};
+
+const INDENT = "    ";
+function pad(level: number): string {
+  return INDENT.repeat(level);
+}
+
+/**
+ * Accumulates top-level variable assignments and import tracking so that
+ * distributions and let-bindings are hoisted out of the final expression.
+ */
+class SymPyEmitter {
+  /** Ordered list of `name = value` assignment lines */
+  readonly statements: string[] = [];
+  /** Tracks imports: module → set of names */
+  readonly imports = new Map<string, Set<string>>();
+  private readonly env: Map<string, string>;
+
+  constructor(env?: Map<string, string>) {
+    this.env = new Map(env);
+  }
+
+  /** Create a child scope that shares the same statements list and imports. */
+  child(): SymPyEmitter {
+    const child = new SymPyEmitter(this.env);
+    (child as { statements: string[] }).statements = this.statements;
+    (child as { imports: Map<string, Set<string>> }).imports = this.imports;
+    return child;
+  }
+
+  private addImport(module: string, name: string): void {
+    let names = this.imports.get(module);
+    if (!names) {
+      names = new Set();
+      this.imports.set(module, names);
+    }
+    names.add(name);
+  }
+
+  /** Use a sympy function/constant, registering its import. */
+  private use(entry: { name: string; module: string }): string {
+    this.addImport(entry.module, entry.name);
+    return entry.name;
+  }
+
+  setEnv(name: string, value: string): void {
+    this.env.set(name, value);
+  }
+
+  emit(node: ExpressionIR, indent = 0): string {
+    switch (node.type) {
+      case "number":
+        return node.value;
+
+      case "boolean":
+        return node.value ? "True" : "False";
+
+      case "infinity":
+        return this.use(SYMPY_SYMBOLS["oo"]!);
+
+      case "symbol": {
+        const constant = MATH_CONSTANT_MAP[node.name];
+        if (constant) return this.use(constant);
+        return this.env.get(node.name) ?? node.name;
+      }
+
+      case "parameter":
+        return node.name;
+
+      case "tokenAccess": {
+        const index = this.emit(node.index);
+        return `${node.place}_${index}_${node.field}`;
+      }
+
+      case "binary": {
+        const left = this.emit(node.left);
+        const right = this.emit(node.right);
+        return this.emitBinaryOp(node.op, left, right);
+      }
+
+      case "unary": {
+        const operand = this.emit(node.operand);
+        switch (node.op) {
+          case "-":
+            return `-(${operand})`;
+          case "!":
+            return `${this.use(SYMPY_SYMBOLS["Not"]!)}(${operand})`;
+          case "+":
+            return operand;
+        }
+        break;
+      }
+
+      case "call":
+        return this.emitCall(node.fn, node.args);
+
+      case "distribution": {
+        // Inline: just emit the call directly (no hoisting, no symbol name)
+        const dist = DISTRIBUTION_MAP[node.distribution];
+        const distFn = dist ? this.use(dist) : node.distribution;
+        const args = node.args.map((a) => this.emit(a));
+        return `${distFn}(${args.join(", ")})`;
+      }
+
+      case "derivedDistribution": {
+        const dist = this.emit(node.distribution);
+        this.setEnv(node.variable, dist);
+        return this.emit(node.body);
+      }
+
+      case "piecewise": {
+        const pw = this.use(SYMPY_SYMBOLS["Piecewise"]!);
+        const condition = this.emit(node.condition);
+        const whenTrue = this.emit(node.whenTrue);
+        const whenFalse = this.emit(node.whenFalse);
+        return `${pw}((${whenTrue}, ${condition}), (${whenFalse}, True))`;
+      }
+
+      case "array": {
+        const elements = node.elements.map((e) => this.emit(e, indent));
+        const flat = `[${elements.join(", ")}]`;
+        if (flat.length <= 80 || elements.length <= 1) return flat;
+        const inner = pad(indent + 1);
+        const outer = pad(indent);
+        return `[\n${inner}${elements.join(`,\n${inner}`)},\n${outer}]`;
+      }
+
+      case "object": {
+        const entries = node.entries.map(
+          (e) => `'${e.key}': ${this.emit(e.value, indent + 1)}`,
+        );
+        const flat = `{${entries.join(", ")}}`;
+        if (flat.length <= 80 || entries.length <= 1) return flat;
+        const inner = pad(indent + 1);
+        const outer = pad(indent);
+        return `{\n${inner}${entries.join(`,\n${inner}`)},\n${outer}}`;
+      }
+
+      case "listComprehension": {
+        const collection = this.emit(node.collection);
+        const childEmitter = this.child();
+        childEmitter.setEnv(node.variable, node.variable);
+        const body = childEmitter.emit(node.body);
+        return `[${body} for ${node.variable} in ${collection}]`;
+      }
+
+      case "let": {
+        for (const binding of node.bindings) {
+          if (binding.value.type === "distribution") {
+            this.emitNamedDistribution(binding.value, binding.name);
+          } else {
+            const value = this.emit(binding.value);
+            this.statements.push(`${binding.name} = ${value}`);
+          }
+          this.env.set(binding.name, binding.name);
+        }
+        return this.emit(node.body);
+      }
+
+      case "propertyAccess": {
+        const obj = this.emit(node.object);
+        return `${obj}_${node.property}`;
+      }
+
+      case "elementAccess": {
+        const obj = this.emit(node.object);
+        const index = this.emit(node.index);
+        return `${obj}_${index}`;
+      }
+    }
+  }
+
+  /**
+   * Emits a named distribution as a hoisted assignment.
+   * Called from `let` bindings where the user gave a name.
+   */
+  emitNamedDistribution(
+    node: ExpressionIR & { type: "distribution" },
+    name: string,
+  ): void {
+    const dist = DISTRIBUTION_MAP[node.distribution];
+    const distFn = dist ? this.use(dist) : node.distribution;
+    const args = node.args.map((a) => this.emit(a));
+    this.statements.push(`${name} = ${distFn}('${name}', ${args.join(", ")})`);
+  }
+
+  private emitCall(fn: string, args: ExpressionIR[]): string {
+    const compiledArgs = args.map((a) => this.emit(a));
+
+    if (fn === "hypot") {
+      const sqrtFn = this.use(MATH_FN_MAP["sqrt"]!);
+      const sumOfSquares = compiledArgs.map((a) => `(${a})**2`).join(" + ");
+      return `${sqrtFn}(${sumOfSquares})`;
+    }
+
+    if (fn === "pow" && compiledArgs.length === 2) {
+      return `(${compiledArgs[0]!})**(${compiledArgs[1]!})`;
+    }
+
+    const entry = MATH_FN_MAP[fn];
+    if (entry) {
+      const sympyFn = this.use(entry);
+      return `${sympyFn}(${compiledArgs.join(", ")})`;
+    }
+
+    return `${fn}(${compiledArgs.join(", ")})`;
+  }
+
+  private emitBinaryOp(op: string, left: string, right: string): string {
+    switch (op) {
+      case "+":
+        return `${left} + ${right}`;
+      case "-":
+        return `${left} - ${right}`;
+      case "*":
+        return `${left} * ${right}`;
+      case "/":
+        return `${left} / ${right}`;
+      case "**":
+        return `${left}**${right}`;
+      case "%":
+        return `${this.use(SYMPY_SYMBOLS["Mod"]!)}(${left}, ${right})`;
+      case "<":
+        return `${left} < ${right}`;
+      case "<=":
+        return `${left} <= ${right}`;
+      case ">":
+        return `${left} > ${right}`;
+      case ">=":
+        return `${left} >= ${right}`;
+      case "==":
+        return `${this.use(SYMPY_SYMBOLS["Eq"]!)}(${left}, ${right})`;
+      case "!=":
+        return `${this.use(SYMPY_SYMBOLS["Ne"]!)}(${left}, ${right})`;
+      case "&&":
+        return `${this.use(SYMPY_SYMBOLS["And"]!)}(${left}, ${right})`;
+      case "||":
+        return `${this.use(SYMPY_SYMBOLS["Or"]!)}(${left}, ${right})`;
+      default:
+        return `${left} ${op} ${right}`;
+    }
+  }
+
+  /** Renders collected imports as `from <module> import ...` lines. */
+  renderImports(): string[] {
+    const lines: string[] = [];
+    // Sort modules for deterministic output
+    const modules = [...this.imports.keys()].sort();
+    for (const module of modules) {
+      const names = [...this.imports.get(module)!].sort();
+      lines.push(`from ${module} import ${names.join(", ")}`);
+    }
+    return lines;
+  }
+}
+
+/**
+ * Converts an expression IR node to SymPy Python code.
+ *
+ * Produces clean Python with explicit imports, hoisted distributions,
+ * and let-bindings as variable assignments.
+ */
+export function irToSymPy(
+  node: ExpressionIR,
+  env: Map<string, string> = new Map(),
+): string {
+  const emitter = new SymPyEmitter(env);
+  const expr = emitter.emit(node);
+
+  const imports = emitter.renderImports();
+  const parts: string[] = [];
+
+  if (imports.length > 0) {
+    parts.push(imports.join("\n"));
+  }
+
+  if (emitter.statements.length > 0) {
+    parts.push(emitter.statements.join("\n"));
+  }
+
+  parts.push(`return ${expr}`);
+
+  return parts.join("\n\n");
+}
diff --git a/libs/@hashintel/petrinaut/src/expression/ts-to-ir/compile-to-ir.stories.tsx b/libs/@hashintel/petrinaut/src/expression/ts-to-ir/compile-to-ir.stories.tsx
new file mode 100644
index 00000000000..90119c042e1
--- /dev/null
+++ b/libs/@hashintel/petrinaut/src/expression/ts-to-ir/compile-to-ir.stories.tsx
@@ -0,0 +1,150 @@
+import type { Meta, StoryObj } from "@storybook/react-vite";
+import Editor, { loader, type Monaco } from "@monaco-editor/react";
+import * as monaco from "monaco-editor";
+import { useCallback, useRef, useState } from "react";
+
+import type { CompilationContext } from "./compile-to-ir";
+import { compileToIR } from "./compile-to-ir";
+
+type IRResult = ReturnType<typeof compileToIR>;
+
+// Use bundled Monaco directly, no workers needed for basic editing
+loader.config({ monaco });
+
+const DEFAULT_CODE = `export default Lambda((tokens, parameters) => {
+  const rate = parameters.infection_rate;
+  return rate * tokens.Space[0].x;
+})`;
+
+const DEFAULT_CONTEXT: CompilationContext = {
+  parameterNames: new Set([
+    "infection_rate",
+    "recovery_rate",
+    "gravitational_constant",
+  ]),
+  placeTokenFields: new Map([["Space", ["x", "y", "direction", "velocity"]]]),
+  constructorFnName: "Lambda",
+};
+
+function formatResult(result: IRResult): string {
+  if (result.ok) {
+    return JSON.stringify(result.ir, null, 2);
+  }
+  return JSON.stringify(
+    { error: result.error, start: result.start, length: result.length },
+    null,
+    2,
+  );
+}
+
+function compile(code: string): string {
+  return formatResult(compileToIR(code, DEFAULT_CONTEXT));
+}
+
+function IRPlayground() {
+  const [output, setOutput] = useState(() => compile(DEFAULT_CODE));
+  const timerRef = useRef<ReturnType<typeof setTimeout>>(undefined);
+
+  const onChange = useCallback((value: string | undefined) => {
+    clearTimeout(timerRef.current);
+    timerRef.current = setTimeout(() => {
+      setOutput(compile(value ?? ""));
+    }, 300);
+  }, []);
+
+  /** Disable all TypeScript diagnostics in the editor */
+  const onMount = useCallback((_editor: unknown, instance: Monaco) => {
+    instance.languages.typescript.typescriptDefaults.setDiagnosticsOptions({
+      noSemanticValidation: true,
+      noSyntaxValidation: true,
+    });
+  }, []);
+
+  return (
+    <div style={{ display: "flex", gap: 16, height: "100%" }}>
+      <div style={{ flex: 1, display: "flex", flexDirection: "column" }}>
+        <div
+          style={{
+            padding: "8px 0",
+            fontWeight: 600,
+            fontSize: 13,
+            fontFamily: "sans-serif",
+            color: "#ccc",
+          }}
+        >
+          TypeScript
+        </div>
+        <div style={{ flex: 1, border: "1px solid #333", borderRadius: 4 }}>
+          <Editor
+            defaultLanguage="typescript"
+            defaultValue={DEFAULT_CODE}
+            onChange={onChange}
+            onMount={onMount}
+            theme="vs-dark"
+            options={{
+              minimap: { enabled: false },
+              fontSize: 13,
+              lineNumbers: "on",
+              scrollBeyondLastLine: false,
+              automaticLayout: true,
+            }}
+          />
+        </div>
+      </div>
+      <div style={{ flex: 1, display: "flex", flexDirection: "column" }}>
+        <div
+          style={{
+            padding: "8px 0",
+            fontWeight: 600,
+            fontSize: 13,
+            fontFamily: "sans-serif",
+            color: "#ccc",
+          }}
+        >
+          Expression IR (JSON)
+        </div>
+        <div style={{ flex: 1, border: "1px solid #333", borderRadius: 4 }}>
+          <Editor
+            language="json"
+            value={output}
+            theme="vs-dark"
+            options={{
+              readOnly: true,
+              minimap: { enabled: false },
+              fontSize: 13,
+              lineNumbers: "off",
+              scrollBeyondLastLine: false,
+              automaticLayout: true,
+            }}
+          />
+        </div>
+      </div>
+    </div>
+  );
+}
+
+const meta = {
+  title: "Compiler / TypeScript to IR",
+  parameters: {
+    layout: "fullscreen",
+  },
+} satisfies Meta;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Playground: Story = {
+  render: () => (
+    <div
+      style={{
+        height: "100vh",
+        padding: 16,
+        boxSizing: "border-box",
+        background: "#1e1e1e",
+      }}
+    >
+      <IRPlayground />
+    </div>
+  ),
+};
diff --git a/libs/@hashintel/petrinaut/src/expression/ts-to-ir/compile-to-ir.test.ts b/libs/@hashintel/petrinaut/src/expression/ts-to-ir/compile-to-ir.test.ts
new file mode 100644
index 00000000000..745fb7a1757
--- /dev/null
+++ b/libs/@hashintel/petrinaut/src/expression/ts-to-ir/compile-to-ir.test.ts
@@ -0,0 +1,549 @@
+import { describe, expect, it } from "vitest";
+
+import type { ExpressionIR } from "../expression-ir";
+import type { CompilationContext } from "./compile-to-ir";
+import { compileToIR } from "./compile-to-ir";
+
+const defaultContext: CompilationContext = {
+  parameterNames: new Set([
+    "infection_rate",
+    "recovery_rate",
+    "gravitational_constant",
+  ]),
+  placeTokenFields: new Map([
+    ["Space", ["x", "y", "direction", "velocity"]],
+    ["Susceptible", []],
+  ]),
+  constructorFnName: "Lambda",
+};
+
+function dynamicsContext(): CompilationContext {
+  return { ...defaultContext, constructorFnName: "Dynamics" };
+}
+
+function expectIR(code: string, expected: ExpressionIR, ctx = defaultContext) {
+  const result = compileToIR(code, ctx);
+  expect(result.ok).toBe(true);
+  if (result.ok) {
+    expect(result.ir).toEqual(expected);
+  }
+}
+
+describe("compileToIR", () => {
+  describe("literals", () => {
+    it("should compile numeric literal", () => {
+      expectIR("export default Lambda(() => 42)", {
+        type: "number",
+        value: "42",
+      });
+    });
+
+    it("should compile decimal literal", () => {
+      expectIR("export default Lambda(() => 3.14)", {
+        type: "number",
+        value: "3.14",
+      });
+    });
+
+    it("should compile boolean true", () => {
+      expectIR("export default Lambda(() => true)", {
+        type: "boolean",
+        value: true,
+      });
+    });
+
+    it("should compile boolean false", () => {
+      expectIR("export default Lambda(() => false)", {
+        type: "boolean",
+        value: false,
+      });
+    });
+
+    it("should compile Infinity", () => {
+      expectIR("export default Lambda(() => Infinity)", {
+        type: "infinity",
+      });
+    });
+  });
+
+  describe("parameters", () => {
+    it("should compile parameter access to parameter node", () => {
+      expectIR(
+        "export default Lambda((tokens, parameters) => parameters.infection_rate)",
+        { type: "parameter", name: "infection_rate" },
+      );
+    });
+  });
+
+  describe("token access", () => {
+    it("should compile tokens.Place[0].field to tokenAccess", () => {
+      expectIR("export default Lambda((tokens) => tokens.Space[0].x)", {
+        type: "tokenAccess",
+        place: "Space",
+        index: { type: "number", value: "0" },
+        field: "x",
+      });
+    });
+  });
+
+  describe("binary operations", () => {
+    it("should compile addition", () => {
+      expectIR("export default Lambda(() => 1 + 2)", {
+        type: "binary",
+        op: "+",
+        left: { type: "number", value: "1" },
+        right: { type: "number", value: "2" },
+      });
+    });
+
+    it("should compile strict equality to ==", () => {
+      expectIR(
+        "export default Lambda((tokens, parameters) => parameters.infection_rate === 3)",
+        {
+          type: "binary",
+          op: "==",
+          left: { type: "parameter", name: "infection_rate" },
+          right: { type: "number", value: "3" },
+        },
+      );
+    });
+
+    it("should compile !== to !=", () => {
+      expectIR(
+        "export default Lambda((tokens, parameters) => parameters.infection_rate !== 0)",
+        {
+          type: "binary",
+          op: "!=",
+          left: { type: "parameter", name: "infection_rate" },
+          right: { type: "number", value: "0" },
+        },
+      );
+    });
+
+    it("should compile && to logical and", () => {
+      expectIR(
+        "export default Lambda((tokens, parameters) => parameters.infection_rate > 0 && parameters.recovery_rate > 0)",
+        {
+          type: "binary",
+          op: "&&",
+          left: {
+            type: "binary",
+            op: ">",
+            left: { type: "parameter", name: "infection_rate" },
+            right: { type: "number", value: "0" },
+          },
+          right: {
+            type: "binary",
+            op: ">",
+            left: { type: "parameter", name: "recovery_rate" },
+            right: { type: "number", value: "0" },
+          },
+        },
+      );
+    });
+  });
+
+  describe("unary operations", () => {
+    it("should compile negation", () => {
+      expectIR(
+        "export default Lambda((tokens, parameters) => -parameters.infection_rate)",
+        {
+          type: "unary",
+          op: "-",
+          operand: { type: "parameter", name: "infection_rate" },
+        },
+      );
+    });
+
+    it("should compile logical not", () => {
+      expectIR("export default Lambda(() => !true)", {
+        type: "unary",
+        op: "!",
+        operand: { type: "boolean", value: true },
+      });
+    });
+
+    it("should unwrap unary plus", () => {
+      expectIR(
+        "export default Lambda((tokens, parameters) => +parameters.infection_rate)",
+        { type: "parameter", name: "infection_rate" },
+      );
+    });
+  });
+
+  describe("math functions", () => {
+    it("should compile Math.cos to call node", () => {
+      expectIR(
+        "export default Lambda((tokens, parameters) => Math.cos(parameters.infection_rate))",
+        {
+          type: "call",
+          fn: "cos",
+          args: [{ type: "parameter", name: "infection_rate" }],
+        },
+      );
+    });
+
+    it("should compile Math.hypot to call node", () => {
+      expectIR(
+        "export default Lambda((tokens, parameters) => Math.hypot(parameters.infection_rate, parameters.recovery_rate))",
+        {
+          type: "call",
+          fn: "hypot",
+          args: [
+            { type: "parameter", name: "infection_rate" },
+            { type: "parameter", name: "recovery_rate" },
+          ],
+        },
+      );
+    });
+
+    it("should compile Math.PI to symbol", () => {
+      expectIR("export default Lambda(() => Math.PI)", {
+        type: "symbol",
+        name: "PI",
+      });
+    });
+
+    it("should compile Math.E to symbol", () => {
+      expectIR("export default Lambda(() => Math.E)", {
+        type: "symbol",
+        name: "E",
+      });
+    });
+  });
+
+  describe("distributions", () => {
+    it("should compile Distribution.Gaussian", () => {
+      expectIR("export default Lambda(() => Distribution.Gaussian(0, 1))", {
+        type: "distribution",
+        distribution: "Gaussian",
+        args: [
+          { type: "number", value: "0" },
+          { type: "number", value: "1" },
+        ],
+      });
+    });
+
+    it("should compile Distribution.Uniform", () => {
+      expectIR("export default Lambda(() => Distribution.Uniform(0, 1))", {
+        type: "distribution",
+        distribution: "Uniform",
+        args: [
+          { type: "number", value: "0" },
+          { type: "number", value: "1" },
+        ],
+      });
+    });
+  });
+
+  describe("conditional", () => {
+    it("should compile ternary to piecewise", () => {
+      expectIR(
+        "export default Lambda((tokens, parameters) => parameters.infection_rate > 1 ? parameters.infection_rate : 0)",
+        {
+          type: "piecewise",
+          condition: {
+            type: "binary",
+            op: ">",
+            left: { type: "parameter", name: "infection_rate" },
+            right: { type: "number", value: "1" },
+          },
+          whenTrue: { type: "parameter", name: "infection_rate" },
+          whenFalse: { type: "number", value: "0" },
+        },
+      );
+    });
+  });
+
+  describe("global functions", () => {
+    it("should compile Boolean(expr) to != 0", () => {
+      expectIR(
+        "export default Lambda((tokens, parameters) => Boolean(parameters.infection_rate))",
+        {
+          type: "binary",
+          op: "!=",
+          left: { type: "parameter", name: "infection_rate" },
+          right: { type: "number", value: "0" },
+        },
+      );
+    });
+
+    it("should compile Number(expr) as identity", () => {
+      expectIR("export default Lambda(() => Number(true))", {
+        type: "boolean",
+        value: true,
+      });
+    });
+  });
+
+  describe("collections", () => {
+    it("should compile array literal", () => {
+      expectIR("export default Lambda(() => [1, 2, 3])", {
+        type: "array",
+        elements: [
+          { type: "number", value: "1" },
+          { type: "number", value: "2" },
+          { type: "number", value: "3" },
+        ],
+      });
+    });
+
+    it("should compile object literal", () => {
+      expectIR("export default Lambda(() => ({ x: 1, y: 2 }))", {
+        type: "object",
+        entries: [
+          { key: "x", value: { type: "number", value: "1" } },
+          { key: "y", value: { type: "number", value: "2" } },
+        ],
+      });
+    });
+  });
+
+  describe("let bindings", () => {
+    it("should compile block body with const to let node", () => {
+      const result = compileToIR(
+        `export default Dynamics((tokens, parameters) => {
+          const mu = parameters.gravitational_constant;
+          return mu;
+        })`,
+        dynamicsContext(),
+      );
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.ir).toEqual({
+          type: "let",
+          bindings: [
+            {
+              name: "mu",
+              value: { type: "parameter", name: "gravitational_constant" },
+            },
+          ],
+          body: { type: "symbol", name: "mu" },
+        });
+      }
+    });
+
+    it("should compile multiple const bindings", () => {
+      const result = compileToIR(
+        `export default Dynamics((tokens, parameters) => {
+          const a = parameters.infection_rate;
+          const b = parameters.recovery_rate;
+          return a;
+        })`,
+        dynamicsContext(),
+      );
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.ir.type).toBe("let");
+        if (result.ir.type === "let") {
+          expect(result.ir.bindings).toHaveLength(2);
+          expect(result.ir.bindings[0]!.name).toBe("a");
+          expect(result.ir.bindings[1]!.name).toBe("b");
+        }
+      }
+    });
+
+    it("should not emit let node for block without bindings", () => {
+      const result = compileToIR(
+        `export default Dynamics((tokens, parameters) => {
+          return parameters.infection_rate;
+        })`,
+        dynamicsContext(),
+      );
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.ir).toEqual({
+          type: "parameter",
+          name: "infection_rate",
+        });
+      }
+    });
+  });
+
+  describe(".map() list comprehension", () => {
+    it("should compile .map with destructured params as propertyAccess", () => {
+      const result = compileToIR(
+        `export default Lambda((tokens, parameters) => tokens.map(({ x }) => x * parameters.infection_rate))`,
+        defaultContext,
+      );
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.ir).toEqual({
+          type: "listComprehension",
+          variable: "token",
+          collection: { type: "symbol", name: "tokens" },
+          body: {
+            type: "binary",
+            op: "*",
+            left: {
+              type: "propertyAccess",
+              object: { type: "symbol", name: "token" },
+              property: "x",
+            },
+            right: { type: "parameter", name: "infection_rate" },
+          },
+        });
+      }
+    });
+
+    it("should compile .map with simple identifier param", () => {
+      const result = compileToIR(
+        `export default Lambda((tokens) => tokens.map((token) => token))`,
+        defaultContext,
+      );
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.ir).toEqual({
+          type: "listComprehension",
+          variable: "token",
+          collection: { type: "symbol", name: "tokens" },
+          body: { type: "symbol", name: "token" },
+        });
+      }
+    });
+  });
+
+  describe("derived distributions", () => {
+    it("should compile dist.map(arrow) to derivedDistribution", () => {
+      const result = compileToIR(
+        `export default Lambda(() => Distribution.Gaussian(0, 10).map((x) => x * 2))`,
+        defaultContext,
+      );
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.ir).toEqual({
+          type: "derivedDistribution",
+          distribution: {
+            type: "distribution",
+            distribution: "Gaussian",
+            args: [
+              { type: "number", value: "0" },
+              { type: "number", value: "10" },
+            ],
+          },
+          variable: "_x",
+          body: {
+            type: "binary",
+            op: "*",
+            left: { type: "symbol", name: "_x" },
+            right: { type: "number", value: "2" },
+          },
+        });
+      }
+    });
+
+    it("should compile dist.map(Math.cos) with function reference", () => {
+      const result = compileToIR(
+        `export default Lambda(() => Distribution.Gaussian(0, 10).map(Math.cos))`,
+        defaultContext,
+      );
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.ir).toEqual({
+          type: "derivedDistribution",
+          distribution: {
+            type: "distribution",
+            distribution: "Gaussian",
+            args: [
+              { type: "number", value: "0" },
+              { type: "number", value: "10" },
+            ],
+          },
+          variable: "_x",
+          body: {
+            type: "call",
+            fn: "cos",
+            args: [{ type: "symbol", name: "_x" }],
+          },
+        });
+      }
+    });
+
+    it("should detect distribution through const binding", () => {
+      const result = compileToIR(
+        `export default Lambda(() => {
+          const angle = Distribution.Gaussian(0, 10);
+          return angle.map(Math.cos);
+        })`,
+        defaultContext,
+      );
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.ir.type).toBe("let");
+        if (result.ir.type === "let") {
+          expect(result.ir.body).toEqual({
+            type: "derivedDistribution",
+            distribution: { type: "symbol", name: "angle" },
+            variable: "_x",
+            body: {
+              type: "call",
+              fn: "cos",
+              args: [{ type: "symbol", name: "_x" }],
+            },
+          });
+        }
+      }
+    });
+
+    it("should chain derived distributions", () => {
+      const result = compileToIR(
+        `export default Lambda((tokens, parameters) => {
+          const angle = Distribution.Gaussian(0, 10);
+          const cosAngle = angle.map(Math.cos);
+          return cosAngle.map((x) => x * parameters.infection_rate);
+        })`,
+        defaultContext,
+      );
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.ir.type).toBe("let");
+        if (result.ir.type === "let") {
+          expect(result.ir.body.type).toBe("derivedDistribution");
+        }
+      }
+    });
+  });
+
+  describe("error handling", () => {
+    it("should reject code without default export", () => {
+      const result = compileToIR("const x = Lambda(() => 1);", defaultContext);
+      expect(result.ok).toBe(false);
+      if (!result.ok) {
+        expect(result.error).toContain("No default export");
+      }
+    });
+
+    it("should reject string literals", () => {
+      const result = compileToIR(
+        `export default Lambda(() => "hello")`,
+        defaultContext,
+      );
+      expect(result.ok).toBe(false);
+      if (!result.ok) {
+        expect(result.error).toContain("String literals");
+      }
+    });
+
+    it("should reject unsupported Math function", () => {
+      const result = compileToIR(
+        "export default Lambda(() => Math.random())",
+        defaultContext,
+      );
+      expect(result.ok).toBe(false);
+      if (!result.ok) {
+        expect(result.error).toContain("Unsupported Math function");
+      }
+    });
+
+    it("should reject let declarations", () => {
+      const result = compileToIR(
+        `export default Lambda(() => { let x = 1; return x; })`,
+        defaultContext,
+      );
+      expect(result.ok).toBe(false);
+      if (!result.ok) {
+        expect(result.error).toContain("let");
+      }
+    });
+  });
+});
diff --git a/libs/@hashintel/petrinaut/src/expression/ts-to-ir/compile-to-ir.ts b/libs/@hashintel/petrinaut/src/expression/ts-to-ir/compile-to-ir.ts
new file mode 100644
index 00000000000..41d6a2da0d3
--- /dev/null
+++ b/libs/@hashintel/petrinaut/src/expression/ts-to-ir/compile-to-ir.ts
@@ -0,0 +1,890 @@
+import ts from "typescript";
+
+import type { SDCPN, Transition } from "../../core/types/sdcpn";
+import type { BinaryOp, ExpressionIR, UnaryOp } from "../expression-ir";
+
+/**
+ * Context for compilation, derived from the SDCPN model.
+ * Tells the compiler which identifiers are parameters vs. token fields.
+ */
+export type CompilationContext = {
+  parameterNames: Set<string>;
+  /** Maps place name to its token field names */
+  placeTokenFields: Map<string, string[]>;
+  constructorFnName: string;
+};
+
+/**
+ * Builds a CompilationContext from an SDCPN model for a given transition.
+ */
+export function buildContextForTransition(
+  sdcpn: SDCPN,
+  transition: Transition,
+  constructorFnName: string,
+): CompilationContext {
+  const parameterNames = new Set(
+    sdcpn.parameters.map((param) => param.variableName),
+  );
+  const placeTokenFields = new Map<string, string[]>();
+
+  const placeById = new Map(sdcpn.places.map((pl) => [pl.id, pl]));
+  const colorById = new Map(sdcpn.types.map((ct) => [ct.id, ct]));
+
+  for (const arc of transition.inputArcs) {
+    const place = placeById.get(arc.placeId);
+    if (!place?.colorId) {
+      continue;
+    }
+    const color = colorById.get(place.colorId);
+    if (!color) {
+      continue;
+    }
+    placeTokenFields.set(
+      place.name,
+      color.elements.map((el) => el.name),
+    );
+  }
+
+  return { parameterNames, placeTokenFields, constructorFnName };
+}
+
+/**
+ * Builds a CompilationContext from an SDCPN model for a differential equation.
+ */
+export function buildContextForDifferentialEquation(
+  sdcpn: SDCPN,
+  colorId: string,
+): CompilationContext {
+  const parameterNames = new Set(
+    sdcpn.parameters.map((param) => param.variableName),
+  );
+  const placeTokenFields = new Map<string, string[]>();
+
+  const color = sdcpn.types.find((ct) => ct.id === colorId);
+  if (color) {
+    placeTokenFields.set(
+      color.name,
+      color.elements.map((el) => el.name),
+    );
+  }
+
+  return { parameterNames, placeTokenFields, constructorFnName: "Dynamics" };
+}
+
+export type IRResult =
+  | { ok: true; ir: ExpressionIR }
+  | { ok: false; error: string; start: number; length: number };
+
+/** Shorthand for building an error result with position from a TS AST node. */
+function err(
+  error: string,
+  node: ts.Node,
+  sourceFile: ts.SourceFile,
+): IRResult & { ok: false } {
+  return {
+    ok: false,
+    error,
+    start: node.getStart(sourceFile),
+    length: node.getWidth(sourceFile),
+  };
+}
+
+/** Error result for cases where no specific node is available. */
+function errNoPos(error: string): IRResult & { ok: false } {
+  return { ok: false, error, start: 0, length: 0 };
+}
+
+/**
+ * Scope tracking for the IR compiler.
+ * Tracks local binding names and symbol overrides (from .map() destructuring).
+ */
+type Scope = {
+  /** Names defined by `const` in the current scope */
+  localBindingNames: Set<string>;
+  /** Rewritten names for .map() destructured parameters (e.g., x → _iter_x) */
+  symbolOverrides: Map<string, string>;
+  /** Names bound to distribution expressions (for .map() detection) */
+  distributionBindings: Set<string>;
+};
+
+function emptyScope(): Scope {
+  return {
+    localBindingNames: new Set(),
+    symbolOverrides: new Map(),
+    distributionBindings: new Set(),
+  };
+}
+
+/**
+ * Compiles a Petrinaut TypeScript expression to the expression IR.
+ *
+ * Expects code following the pattern:
+ *   `export default ConstructorFn((params...) => expression)`
+ *
+ * Only a restricted subset of TypeScript is supported — pure expressions
+ * with arithmetic, Math functions, parameter/token access, and distributions.
+ * Anything outside this subset is rejected with a diagnostic.
+ *
+ * @param code - The TypeScript expression code string
+ * @param context - Compilation context with parameter names and token fields
+ * @returns Either `{ ok: true, ir }` or `{ ok: false, error }`
+ */
+export function compileToIR(
+  code: string,
+  context: CompilationContext,
+): IRResult {
+  const sourceFile = ts.createSourceFile(
+    "input.ts",
+    code,
+    ts.ScriptTarget.ES2015,
+    true,
+  );
+
+  // Find the default export
+  const exportAssignment = sourceFile.statements.find(
+    (stmt): stmt is ts.ExportAssignment =>
+      ts.isExportAssignment(stmt) && !stmt.isExportEquals,
+  );
+
+  if (!exportAssignment) {
+    return errNoPos("No default export found");
+  }
+
+  const exportExpr = exportAssignment.expression;
+
+  // Expect ConstructorFn(...)
+  if (!ts.isCallExpression(exportExpr)) {
+    return err(
+      `Expected ${context.constructorFnName}(...), got ${ts.SyntaxKind[exportExpr.kind]}`,
+      exportExpr,
+      sourceFile,
+    );
+  }
+
+  const callee = exportExpr.expression;
+  if (!ts.isIdentifier(callee) || callee.text !== context.constructorFnName) {
+    return err(
+      `Expected ${context.constructorFnName}(...), got ${callee.getText(sourceFile)}(...)`,
+      callee,
+      sourceFile,
+    );
+  }
+
+  if (exportExpr.arguments.length !== 1) {
+    return err(
+      `${context.constructorFnName} expects exactly one argument`,
+      exportExpr,
+      sourceFile,
+    );
+  }
+
+  const arg = exportExpr.arguments[0]!;
+
+  // The argument should be an arrow function or function expression
+  if (!ts.isArrowFunction(arg) && !ts.isFunctionExpression(arg)) {
+    return err(
+      `Expected a function argument, got ${ts.SyntaxKind[arg.kind]}`,
+      arg,
+      sourceFile,
+    );
+  }
+
+  const scope = emptyScope();
+
+  // Compile the body
+  const body = arg.body;
+
+  if (ts.isBlock(body)) {
+    return compileBlockToIR(body, context, scope, sourceFile);
+  }
+
+  // Expression body — emit directly
+  return emitIR(body, context, scope, sourceFile);
+}
+
+function compileBlockToIR(
+  block: ts.Block,
+  context: CompilationContext,
+  outerScope: Scope,
+  sourceFile: ts.SourceFile,
+): IRResult {
+  const bindings: { name: string; value: ExpressionIR }[] = [];
+  const scope: Scope = {
+    localBindingNames: new Set(outerScope.localBindingNames),
+    symbolOverrides: new Map(outerScope.symbolOverrides),
+    distributionBindings: new Set(outerScope.distributionBindings),
+  };
+  let bodyIR: ExpressionIR | undefined;
+
+  for (const stmt of block.statements) {
+    if (ts.isVariableStatement(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (!decl.initializer) {
+          return err(
+            "Variable declaration without initializer",
+            decl,
+            sourceFile,
+          );
+        }
+        if (!(stmt.declarationList.flags & ts.NodeFlags.Const)) {
+          return err(
+            "'let' and 'var' declarations are not supported, use 'const'",
+            stmt,
+            sourceFile,
+          );
+        }
+        const name = decl.name.getText(sourceFile);
+        const valueResult = emitIR(
+          decl.initializer,
+          context,
+          scope,
+          sourceFile,
+        );
+        if (!valueResult.ok) return valueResult;
+        bindings.push({ name, value: valueResult.ir });
+        scope.localBindingNames.add(name);
+        if (
+          valueResult.ir.type === "distribution" ||
+          valueResult.ir.type === "derivedDistribution"
+        ) {
+          scope.distributionBindings.add(name);
+        }
+      }
+    } else if (ts.isReturnStatement(stmt)) {
+      if (!stmt.expression) {
+        return err("Empty return statement", stmt, sourceFile);
+      }
+      const result = emitIR(stmt.expression, context, scope, sourceFile);
+      if (!result.ok) return result;
+      bodyIR = result.ir;
+    } else if (ts.isExpressionStatement(stmt)) {
+      return err(
+        "Standalone expression has no effect — assign to a const or return it",
+        stmt,
+        sourceFile,
+      );
+    } else {
+      return err(
+        `Unsupported statement: ${ts.SyntaxKind[stmt.kind]}`,
+        stmt,
+        sourceFile,
+      );
+    }
+  }
+
+  if (!bodyIR) {
+    return err("Empty function body", block, sourceFile);
+  }
+
+  if (bindings.length > 0) {
+    return { ok: true, ir: { type: "let", bindings, body: bodyIR } };
+  }
+  return { ok: true, ir: bodyIR };
+}
+
+/**
+ * Compiles `collection.map(callback)` to a list comprehension IR node.
+ */
+/**
+ * Derives a singular iteration variable name from the collection expression.
+ * `tokens` → `token`, `items` → `item`, fallback → `item`.
+ */
+function deriveIterVarName(
+  collection: ts.Expression,
+  sourceFile: ts.SourceFile,
+): string {
+  const text = collection.getText(sourceFile);
+  if (text.endsWith("s") && text.length > 1) {
+    return text.slice(0, -1);
+  }
+  return "item";
+}
+
+function compileMapCallToIR(
+  collection: ts.Expression,
+  callback: ts.ArrowFunction | ts.FunctionExpression,
+  context: CompilationContext,
+  outerScope: Scope,
+  sourceFile: ts.SourceFile,
+): IRResult {
+  const mapScope: Scope = {
+    localBindingNames: new Set(outerScope.localBindingNames),
+    symbolOverrides: new Map(outerScope.symbolOverrides),
+    distributionBindings: new Set(outerScope.distributionBindings),
+  };
+
+  const param = callback.parameters[0];
+  let iterVar: string;
+
+  if (param) {
+    const paramName = param.name;
+    if (ts.isObjectBindingPattern(paramName)) {
+      // Destructured: ({ x, y }) => ...
+      // Use a derived name and map fields to propertyAccess on it
+      iterVar = deriveIterVarName(collection, sourceFile);
+      for (const element of paramName.elements) {
+        const fieldName = element.name.getText(sourceFile);
+        mapScope.symbolOverrides.set(
+          fieldName,
+          `\0propAccess:${iterVar}:${fieldName}`,
+        );
+      }
+    } else {
+      // Simple: (token) => ...
+      iterVar = paramName.getText(sourceFile);
+      mapScope.symbolOverrides.set(iterVar, iterVar);
+    }
+  } else {
+    iterVar = deriveIterVarName(collection, sourceFile);
+  }
+
+  // Compile the body
+  const body = callback.body;
+  let bodyResult: IRResult;
+  if (ts.isBlock(body)) {
+    bodyResult = compileBlockToIR(body, context, mapScope, sourceFile);
+  } else {
+    bodyResult = emitIR(body, context, mapScope, sourceFile);
+  }
+  if (!bodyResult.ok) return bodyResult;
+
+  // Compile the collection expression
+  const collectionResult = emitIR(collection, context, outerScope, sourceFile);
+  if (!collectionResult.ok) return collectionResult;
+
+  return {
+    ok: true,
+    ir: {
+      type: "listComprehension",
+      body: bodyResult.ir,
+      variable: iterVar,
+      collection: collectionResult.ir,
+    },
+  };
+}
+
+/**
+ * Checks whether a TS expression will produce a distribution IR node.
+ *
+ * Handles two cases:
+ * - Direct: `Distribution.Gaussian(...)` call expressions
+ * - Via binding: identifiers bound to a distribution in a const declaration
+ */
+function isDistributionExpression(node: ts.Expression, scope: Scope): boolean {
+  // Direct: Distribution.Fn(...)
+  if (
+    ts.isCallExpression(node) &&
+    ts.isPropertyAccessExpression(node.expression) &&
+    ts.isIdentifier(node.expression.expression) &&
+    node.expression.expression.text === "Distribution"
+  ) {
+    return true;
+  }
+
+  // Via binding: const angle = Distribution.Gaussian(0, 10); angle.map(...)
+  if (ts.isIdentifier(node) && scope.distributionBindings.has(node.text)) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Compiles `distribution.map(transform)` to a derived distribution IR node.
+ *
+ * Handles two callback forms:
+ * - Arrow/function expression: `dist.map((x) => Math.cos(x))`
+ * - Function reference: `dist.map(Math.cos)` — expanded to `(_x) => Math.cos(_x)`
+ */
+function compileDerivedDistribution(
+  collection: ts.Expression,
+  callback: ts.Expression,
+  context: CompilationContext,
+  scope: Scope,
+  sourceFile: ts.SourceFile,
+): IRResult {
+  const variable = "_x";
+
+  // Compile the base distribution
+  const distResult = emitIR(collection, context, scope, sourceFile);
+  if (!distResult.ok) return distResult;
+
+  let bodyIR: ExpressionIR;
+
+  if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) {
+    // Arrow function: (x) => expr
+    // Bind the parameter name to our variable
+    const mapScope: Scope = {
+      localBindingNames: new Set(scope.localBindingNames),
+      symbolOverrides: new Map(scope.symbolOverrides),
+      distributionBindings: new Set(scope.distributionBindings),
+    };
+
+    const param = callback.parameters[0];
+    if (param) {
+      mapScope.symbolOverrides.set(param.name.getText(sourceFile), variable);
+    }
+
+    const body = callback.body;
+    let bodyResult: IRResult;
+    if (ts.isBlock(body)) {
+      bodyResult = compileBlockToIR(body, context, mapScope, sourceFile);
+    } else {
+      bodyResult = emitIR(body, context, mapScope, sourceFile);
+    }
+    if (!bodyResult.ok) return bodyResult;
+    bodyIR = bodyResult.ir;
+  } else {
+    // Function reference: Math.cos, Math.sin, etc.
+    // Expand to: (_x) => fn(_x)
+    const fnResult = emitIR(callback, context, scope, sourceFile);
+    if (!fnResult.ok) return fnResult;
+
+    // The fn should be a call-like reference (e.g. Math.cos).
+    // We synthesize a call node: fn(_x)
+    if (fnResult.ir.type === "symbol" && fnResult.ir.name.startsWith("Math.")) {
+      // Math.cos → { type: "call", fn: "cos", args: [symbol("_x")] }
+      const fnName = fnResult.ir.name.slice("Math.".length);
+      bodyIR = {
+        type: "call",
+        fn: fnName,
+        args: [{ type: "symbol", name: variable }],
+      };
+    } else {
+      return err(
+        "Distribution .map() callback must be a function expression or a Math function reference",
+        callback,
+        sourceFile,
+      );
+    }
+  }
+
+  return {
+    ok: true,
+    ir: {
+      type: "derivedDistribution",
+      distribution: distResult.ir,
+      variable,
+      body: bodyIR,
+    },
+  };
+}
+
+const SUPPORTED_MATH_FUNCTIONS = new Set([
+  "cos",
+  "sin",
+  "tan",
+  "acos",
+  "asin",
+  "atan",
+  "atan2",
+  "sqrt",
+  "log",
+  "exp",
+  "abs",
+  "floor",
+  "ceil",
+  "pow",
+  "min",
+  "max",
+  "hypot",
+]);
+
+const MATH_CONSTANTS: Record<string, ExpressionIR> = {
+  PI: { type: "symbol", name: "PI" },
+  E: { type: "symbol", name: "E" },
+};
+
+const TS_BINARY_OP_MAP: Partial<Record<ts.SyntaxKind, BinaryOp>> = {
+  [ts.SyntaxKind.PlusToken]: "+",
+  [ts.SyntaxKind.MinusToken]: "-",
+  [ts.SyntaxKind.AsteriskToken]: "*",
+  [ts.SyntaxKind.SlashToken]: "/",
+  [ts.SyntaxKind.AsteriskAsteriskToken]: "**",
+  [ts.SyntaxKind.PercentToken]: "%",
+  [ts.SyntaxKind.LessThanToken]: "<",
+  [ts.SyntaxKind.LessThanEqualsToken]: "<=",
+  [ts.SyntaxKind.GreaterThanToken]: ">",
+  [ts.SyntaxKind.GreaterThanEqualsToken]: ">=",
+  [ts.SyntaxKind.EqualsEqualsToken]: "==",
+  [ts.SyntaxKind.EqualsEqualsEqualsToken]: "==",
+  [ts.SyntaxKind.ExclamationEqualsToken]: "!=",
+  [ts.SyntaxKind.ExclamationEqualsEqualsToken]: "!=",
+  [ts.SyntaxKind.AmpersandAmpersandToken]: "&&",
+  [ts.SyntaxKind.BarBarToken]: "||",
+};
+
+const TS_UNARY_OP_MAP: Partial<Record<ts.SyntaxKind, UnaryOp>> = {
+  [ts.SyntaxKind.MinusToken]: "-",
+  [ts.SyntaxKind.ExclamationToken]: "!",
+  [ts.SyntaxKind.PlusToken]: "+",
+};
+
+function emitIR(
+  node: ts.Node,
+  context: CompilationContext,
+  scope: Scope,
+  sourceFile: ts.SourceFile,
+): IRResult {
+  // Numeric literal
+  if (ts.isNumericLiteral(node)) {
+    return { ok: true, ir: { type: "number", value: node.text } };
+  }
+
+  // String literal — not supported in symbolic math
+  if (ts.isStringLiteral(node)) {
+    return err(
+      "String literals are not supported in symbolic expressions",
+      node,
+      sourceFile,
+    );
+  }
+
+  // Boolean literals
+  if (node.kind === ts.SyntaxKind.TrueKeyword) {
+    return { ok: true, ir: { type: "boolean", value: true } };
+  }
+  if (node.kind === ts.SyntaxKind.FalseKeyword) {
+    return { ok: true, ir: { type: "boolean", value: false } };
+  }
+
+  // Identifier
+  if (ts.isIdentifier(node)) {
+    const name = node.text;
+    if (name === "Infinity") {
+      return { ok: true, ir: { type: "infinity" } };
+    }
+    if (scope.symbolOverrides.has(name)) {
+      const override = scope.symbolOverrides.get(name)!;
+      // Destructured .map() fields are encoded as propertyAccess sentinels
+      if (override.startsWith("\0propAccess:")) {
+        const [, objName, property] = override.split(":");
+        return {
+          ok: true,
+          ir: {
+            type: "propertyAccess",
+            object: { type: "symbol", name: objName! },
+            property: property!,
+          },
+        };
+      }
+      return {
+        ok: true,
+        ir: { type: "symbol", name: override },
+      };
+    }
+    if (scope.localBindingNames.has(name)) {
+      return { ok: true, ir: { type: "symbol", name } };
+    }
+    if (context.parameterNames.has(name)) {
+      return { ok: true, ir: { type: "parameter", name } };
+    }
+    // Could be a destructured token field or function param
+    return { ok: true, ir: { type: "symbol", name } };
+  }
+
+  // Parenthesized expression
+  if (ts.isParenthesizedExpression(node)) {
+    return emitIR(node.expression, context, scope, sourceFile);
+  }
+
+  // Prefix unary expression (-x, !x)
+  if (ts.isPrefixUnaryExpression(node)) {
+    const operand = emitIR(node.operand, context, scope, sourceFile);
+    if (!operand.ok) return operand;
+
+    const op = TS_UNARY_OP_MAP[node.operator];
+    if (!op) {
+      return err(
+        `Unsupported prefix operator: ${ts.SyntaxKind[node.operator]}`,
+        node,
+        sourceFile,
+      );
+    }
+
+    if (op === "+") {
+      return operand;
+    }
+
+    return { ok: true, ir: { type: "unary", op, operand: operand.ir } };
+  }
+
+  // Binary expression
+  if (ts.isBinaryExpression(node)) {
+    const left = emitIR(node.left, context, scope, sourceFile);
+    if (!left.ok) return left;
+    const right = emitIR(node.right, context, scope, sourceFile);
+    if (!right.ok) return right;
+
+    const op = TS_BINARY_OP_MAP[node.operatorToken.kind];
+    if (!op) {
+      return err(
+        `Unsupported binary operator: ${node.operatorToken.getText(sourceFile)}`,
+        node.operatorToken,
+        sourceFile,
+      );
+    }
+
+    return {
+      ok: true,
+      ir: { type: "binary", op, left: left.ir, right: right.ir },
+    };
+  }
+
+  // Conditional (ternary) expression
+  if (ts.isConditionalExpression(node)) {
+    const condition = emitIR(node.condition, context, scope, sourceFile);
+    if (!condition.ok) return condition;
+    const whenTrue = emitIR(node.whenTrue, context, scope, sourceFile);
+    if (!whenTrue.ok) return whenTrue;
+    const whenFalse = emitIR(node.whenFalse, context, scope, sourceFile);
+    if (!whenFalse.ok) return whenFalse;
+    return {
+      ok: true,
+      ir: {
+        type: "piecewise",
+        condition: condition.ir,
+        whenTrue: whenTrue.ir,
+        whenFalse: whenFalse.ir,
+      },
+    };
+  }
+
+  // Property access: parameters.x, tokens.Place[0].field, Math.PI
+  if (ts.isPropertyAccessExpression(node)) {
+    const propName = node.name.text;
+
+    // Math constants: Math.PI, Math.E
+    if (ts.isIdentifier(node.expression) && node.expression.text === "Math") {
+      const constant = MATH_CONSTANTS[propName];
+      if (constant) return { ok: true, ir: constant };
+      // Math.method — return a placeholder for the call expression handler
+      return { ok: true, ir: { type: "symbol", name: `Math.${propName}` } };
+    }
+
+    // parameters.x
+    if (
+      ts.isIdentifier(node.expression) &&
+      node.expression.text === "parameters"
+    ) {
+      return { ok: true, ir: { type: "parameter", name: propName } };
+    }
+
+    // tokens.Place[0].field — handle the chain
+    if (ts.isElementAccessExpression(node.expression)) {
+      const elemAccess = node.expression;
+      if (ts.isPropertyAccessExpression(elemAccess.expression)) {
+        const placePropAccess = elemAccess.expression;
+        if (
+          ts.isIdentifier(placePropAccess.expression) &&
+          placePropAccess.expression.text === "tokens"
+        ) {
+          const placeName = placePropAccess.name.text;
+          const indexResult = emitIR(
+            elemAccess.argumentExpression,
+            context,
+            scope,
+            sourceFile,
+          );
+          if (!indexResult.ok) return indexResult;
+          return {
+            ok: true,
+            ir: {
+              type: "tokenAccess",
+              place: placeName,
+              index: indexResult.ir,
+              field: propName,
+            },
+          };
+        }
+      }
+    }
+
+    // Generic property access
+    const obj = emitIR(node.expression, context, scope, sourceFile);
+    if (!obj.ok) return obj;
+    return {
+      ok: true,
+      ir: { type: "propertyAccess", object: obj.ir, property: propName },
+    };
+  }
+
+  // Element access: tokens.Place[0], arr[i]
+  if (ts.isElementAccessExpression(node)) {
+    const obj = emitIR(node.expression, context, scope, sourceFile);
+    if (!obj.ok) return obj;
+    const index = emitIR(node.argumentExpression, context, scope, sourceFile);
+    if (!index.ok) return index;
+    return {
+      ok: true,
+      ir: { type: "elementAccess", object: obj.ir, index: index.ir },
+    };
+  }
+
+  // Call expression
+  if (ts.isCallExpression(node)) {
+    const callee = node.expression;
+
+    // Math.fn(...)
+    if (
+      ts.isPropertyAccessExpression(callee) &&
+      ts.isIdentifier(callee.expression) &&
+      callee.expression.text === "Math"
+    ) {
+      const fnName = callee.name.text;
+
+      if (!SUPPORTED_MATH_FUNCTIONS.has(fnName)) {
+        return err(
+          `Unsupported Math function: Math.${fnName}`,
+          callee,
+          sourceFile,
+        );
+      }
+
+      const args: ExpressionIR[] = [];
+      for (const a of node.arguments) {
+        const r = emitIR(a, context, scope, sourceFile);
+        if (!r.ok) return r;
+        args.push(r.ir);
+      }
+      return { ok: true, ir: { type: "call", fn: fnName, args } };
+    }
+
+    // Distribution.Gaussian(m, s), etc.
+    if (
+      ts.isPropertyAccessExpression(callee) &&
+      ts.isIdentifier(callee.expression) &&
+      callee.expression.text === "Distribution"
+    ) {
+      const distName = callee.name.text;
+      const supportedDistributions = ["Gaussian", "Uniform", "Lognormal"];
+      if (!supportedDistributions.includes(distName)) {
+        return err(
+          `Unsupported distribution: Distribution.${distName}`,
+          callee,
+          sourceFile,
+        );
+      }
+
+      const args: ExpressionIR[] = [];
+      for (const a of node.arguments) {
+        const r = emitIR(a, context, scope, sourceFile);
+        if (!r.ok) return r;
+        args.push(r.ir);
+      }
+      return {
+        ok: true,
+        ir: { type: "distribution", distribution: distName, args },
+      };
+    }
+
+    // Global built-in functions: Boolean(expr), Number(expr)
+    if (ts.isIdentifier(callee)) {
+      if (callee.text === "Boolean" && node.arguments.length === 1) {
+        const argResult = emitIR(
+          node.arguments[0]!,
+          context,
+          scope,
+          sourceFile,
+        );
+        if (!argResult.ok) return argResult;
+        // Boolean(expr) → expr != 0
+        return {
+          ok: true,
+          ir: {
+            type: "binary",
+            op: "!=",
+            left: argResult.ir,
+            right: { type: "number", value: "0" },
+          },
+        };
+      }
+
+      if (callee.text === "Number" && node.arguments.length === 1) {
+        return emitIR(node.arguments[0]!, context, scope, sourceFile);
+      }
+    }
+
+    // .map(callback)
+    if (
+      ts.isPropertyAccessExpression(callee) &&
+      callee.name.text === "map" &&
+      node.arguments.length === 1
+    ) {
+      const callback = node.arguments[0]!;
+
+      // Check if the target is a distribution (for derived distributions)
+      if (isDistributionExpression(callee.expression, scope)) {
+        return compileDerivedDistribution(
+          callee.expression,
+          callback,
+          context,
+          scope,
+          sourceFile,
+        );
+      }
+
+      if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) {
+        return compileMapCallToIR(
+          callee.expression,
+          callback,
+          context,
+          scope,
+          sourceFile,
+        );
+      }
+    }
+
+    return err(
+      `Unsupported function call: ${callee.getText(sourceFile)}`,
+      node,
+      sourceFile,
+    );
+  }
+
+  // Array literal expression [a, b, c]
+  if (ts.isArrayLiteralExpression(node)) {
+    const elements: ExpressionIR[] = [];
+    for (const elem of node.elements) {
+      const result = emitIR(elem, context, scope, sourceFile);
+      if (!result.ok) return result;
+      elements.push(result.ir);
+    }
+    return { ok: true, ir: { type: "array", elements } };
+  }
+
+  // Object literal expression { field: expr, ... }
+  if (ts.isObjectLiteralExpression(node)) {
+    const entries: { key: string; value: ExpressionIR }[] = [];
+    for (const prop of node.properties) {
+      if (!ts.isPropertyAssignment(prop)) {
+        return err(
+          `Unsupported object property kind: ${ts.SyntaxKind[prop.kind]}`,
+          prop,
+          sourceFile,
+        );
+      }
+      const key = prop.name.getText(sourceFile);
+      const val = emitIR(prop.initializer, context, scope, sourceFile);
+      if (!val.ok) return val;
+      entries.push({ key, value: val.ir });
+    }
+    return { ok: true, ir: { type: "object", entries } };
+  }
+
+  // Non-null assertion (x!) — just unwrap
+  if (ts.isNonNullExpression(node)) {
+    return emitIR(node.expression, context, scope, sourceFile);
+  }
+
+  // Type assertion (x as T) — just unwrap
+  if (ts.isAsExpression(node)) {
+    return emitIR(node.expression, context, scope, sourceFile);
+  }
+
+  return err(
+    `Unsupported syntax: ${ts.SyntaxKind[node.kind]}`,
+    node,
+    sourceFile,
+  );
+}
diff --git a/libs/@hashintel/petrinaut/src/expression/use-expression-ir-output.ts b/libs/@hashintel/petrinaut/src/expression/use-expression-ir-output.ts
new file mode 100644
index 00000000000..fdbc5f70938
--- /dev/null
+++ b/libs/@hashintel/petrinaut/src/expression/use-expression-ir-output.ts
@@ -0,0 +1,111 @@
+import { use, useMemo } from "react";
+
+import type { DifferentialEquation, Transition } from "../core/types/sdcpn";
+import { SDCPNContext } from "../state/sdcpn-context";
+import { UserSettingsContext } from "../state/user-settings-context";
+import { irToLean } from "./ir-to-lean/ir-to-lean";
+import { irToOCaml } from "./ir-to-ocaml/ir-to-ocaml";
+import { irToSymPy } from "./ir-to-sympy/ir-to-sympy";
+import type { CompilationContext, IRResult } from "./ts-to-ir/compile-to-ir";
+import {
+  buildContextForDifferentialEquation,
+  buildContextForTransition,
+  compileToIR,
+} from "./ts-to-ir/compile-to-ir";
+
+export type ExpressionOutputFormat = "ir" | "sympy" | "ocaml" | "lean";
+
+export type ExpressionOutput = {
+  ir: string;
+  sympy: string;
+  ocaml: string;
+  lean: string;
+};
+
+function formatIRResult(result: IRResult): ExpressionOutput {
+  if (result.ok) {
+    return {
+      ir: JSON.stringify(result.ir, null, 2),
+      sympy: irToSymPy(result.ir),
+      ocaml: irToOCaml(result.ir),
+      lean: irToLean(result.ir),
+    };
+  }
+  const errorJson = JSON.stringify(
+    { error: result.error, start: result.start, length: result.length },
+    null,
+    2,
+  );
+  return {
+    ir: errorJson,
+    sympy: `# Error: ${result.error}`,
+    ocaml: `(* Error: ${result.error} *)`,
+    lean: `-- Error: ${result.error}`,
+  };
+}
+
+function useCompileToOutput(
+  code: string,
+  ctx: CompilationContext,
+  enabled: boolean,
+): ExpressionOutput | null {
+  return useMemo(() => {
+    if (!enabled) return null;
+    return formatIRResult(compileToIR(code, ctx));
+  }, [enabled, code, ctx]);
+}
+
+/**
+ * Compiles a transition's code to all output formats,
+ * or `null` when the setting is disabled.
+ */
+export function useExpressionOutput(
+  transition: Transition,
+  constructorFnName: "Lambda" | "TransitionKernel",
+): ExpressionOutput | null {
+  const { showExpressionOutput } = use(UserSettingsContext);
+  const { petriNetDefinition } = use(SDCPNContext);
+
+  const code =
+    constructorFnName === "Lambda"
+      ? transition.lambdaCode
+      : transition.transitionKernelCode;
+
+  const ctx = useMemo(
+    () =>
+      buildContextForTransition(
+        petriNetDefinition,
+        transition,
+        constructorFnName,
+      ),
+    [petriNetDefinition, transition, constructorFnName],
+  );
+
+  return useCompileToOutput(code, ctx, showExpressionOutput);
+}
+
+/**
+ * Compiles a differential equation's code to all output formats,
+ * or `null` when the setting is disabled.
+ */
+export function useDiffEqExpressionOutput(
+  differentialEquation: DifferentialEquation,
+): ExpressionOutput | null {
+  const { showExpressionOutput } = use(UserSettingsContext);
+  const { petriNetDefinition } = use(SDCPNContext);
+
+  const ctx = useMemo(
+    () =>
+      buildContextForDifferentialEquation(
+        petriNetDefinition,
+        differentialEquation.colorId,
+      ),
+    [petriNetDefinition, differentialEquation.colorId],
+  );
+
+  return useCompileToOutput(
+    differentialEquation.code,
+    ctx,
+    showExpressionOutput,
+  );
+}
diff --git a/libs/@hashintel/petrinaut/src/lsp/lib/checker.ts b/libs/@hashintel/petrinaut/src/lsp/lib/checker.ts
index 3c5029c5fe3..54ae0a3847e 100644
--- a/libs/@hashintel/petrinaut/src/lsp/lib/checker.ts
+++ b/libs/@hashintel/petrinaut/src/lsp/lib/checker.ts
@@ -1,6 +1,12 @@
 import type ts from "typescript";
 
 import type { SDCPN } from "../../core/types/sdcpn";
+import {
+  buildContextForDifferentialEquation,
+  buildContextForTransition,
+  compileToIR,
+  type IRResult,
+} from "../../expression/ts-to-ir/compile-to-ir";
 import type { SDCPNLanguageServer } from "./create-sdcpn-language-service";
 import { getItemFilePath } from "./file-paths";
 
@@ -21,12 +27,130 @@ export type SDCPNDiagnostic = {
 };
 
 export type SDCPNCheckResult = {
-  /** Whether the SDCPN is valid (no errors) */
+  /** Whether the SDCPN is valid (no TypeScript errors) */
   isValid: boolean;
-  /** All diagnostics grouped by item */
+  /** TypeScript error diagnostics grouped by item */
   itemDiagnostics: SDCPNDiagnostic[];
+  /** Expression IR diagnostics (unsupported math expressions, do not affect validity) */
+  expressionDiagnostics: SDCPNDiagnostic[];
 };
 
+/**
+ * Creates a synthetic ts.Diagnostic from an expression IR compilation error.
+ * Uses category 0 (Warning) since the TypeScript code may still be valid,
+ * just not representable as a pure mathematical expression.
+ */
+function makeExpressionDiagnostic(
+  result: IRResult & { ok: false },
+): ts.Diagnostic {
+  return {
+    category: 0, // Warning
+    code: 99000,
+    messageText: `Invalid expression: ${result.error}`,
+    file: undefined,
+    start: result.start,
+    length: result.length,
+  };
+}
+
+/**
+ * Appends an expression diagnostic to the item diagnostics list, merging with
+ * any existing entry for the same item.
+ */
+function appendExpressionDiagnostic(
+  itemDiagnostics: SDCPNDiagnostic[],
+  itemId: string,
+  itemType: ItemType,
+  filePath: string,
+  result: IRResult & { ok: false },
+): void {
+  const diag = makeExpressionDiagnostic(result);
+  const existing = itemDiagnostics.find(
+    (di) => di.itemId === itemId && di.itemType === itemType,
+  );
+  if (existing) {
+    existing.diagnostics.push(diag);
+  } else {
+    itemDiagnostics.push({ itemId, itemType, filePath, diagnostics: [diag] });
+  }
+}
+
+/**
+ * Validates all SDCPN code expressions as mathematical expressions by
+ * compiling them to the expression IR, appending any errors as warnings.
+ */
+function checkExpressions(sdcpn: SDCPN): SDCPNDiagnostic[] {
+  const itemDiagnostics: SDCPNDiagnostic[] = [];
+  // Check differential equations
+  for (const de of sdcpn.differentialEquations) {
+    const ctx = buildContextForDifferentialEquation(sdcpn, de.colorId);
+    const result = compileToIR(de.code, ctx);
+    if (!result.ok) {
+      const filePath = getItemFilePath("differential-equation-code", {
+        id: de.id,
+      });
+      appendExpressionDiagnostic(
+        itemDiagnostics,
+        de.id,
+        "differential-equation",
+        filePath,
+        result,
+      );
+    }
+  }
+
+  // Check transition lambdas and kernels
+  for (const transition of sdcpn.transitions) {
+    const lambdaCtx = buildContextForTransition(sdcpn, transition, "Lambda");
+    const lambdaResult = compileToIR(transition.lambdaCode, lambdaCtx);
+    if (!lambdaResult.ok) {
+      const filePath = getItemFilePath("transition-lambda-code", {
+        transitionId: transition.id,
+      });
+      appendExpressionDiagnostic(
+        itemDiagnostics,
+        transition.id,
+        "transition-lambda",
+        filePath,
+        lambdaResult,
+      );
+    }
+
+    // Only check TransitionKernel if there are coloured output places,
+    // matching the TypeScript checker's behavior
+    const hasColouredOutputPlaces = transition.outputArcs.some((arc) => {
+      const place = sdcpn.places.find((pl) => pl.id === arc.placeId);
+      return place?.colorId != null;
+    });
+
+    if (hasColouredOutputPlaces) {
+      const kernelCtx = buildContextForTransition(
+        sdcpn,
+        transition,
+        "TransitionKernel",
+      );
+      const kernelResult = compileToIR(
+        transition.transitionKernelCode,
+        kernelCtx,
+      );
+      if (!kernelResult.ok) {
+        const filePath = getItemFilePath("transition-kernel-code", {
+          transitionId: transition.id,
+        });
+        appendExpressionDiagnostic(
+          itemDiagnostics,
+          transition.id,
+          "transition-kernel",
+          filePath,
+          kernelResult,
+        );
+      }
+    }
+  }
+
+  return itemDiagnostics;
+}
+
 /**
  * Checks the validity of an SDCPN by running TypeScript validation
  * on all user-provided code (transitions and differential equations).
@@ -111,8 +235,12 @@ export function checkSDCPN(
     }
   }
 
+  // Validate expressions as mathematical IR
+  const expressionDiagnostics = checkExpressions(sdcpn);
+
   return {
     isValid: itemDiagnostics.length === 0,
     itemDiagnostics,
+    expressionDiagnostics,
   };
 }
diff --git a/libs/@hashintel/petrinaut/src/lsp/worker/language-server.worker.ts b/libs/@hashintel/petrinaut/src/lsp/worker/language-server.worker.ts
index b955e7c45ed..31cf8dd7a84 100644
--- a/libs/@hashintel/petrinaut/src/lsp/worker/language-server.worker.ts
+++ b/libs/@hashintel/petrinaut/src/lsp/worker/language-server.worker.ts
@@ -60,20 +60,22 @@ function publishAllDiagnostics(sdcpn: SDCPN): void {
   }
 
   const result = checkSDCPN(sdcpn, server);
-  const params: PublishDiagnosticsParams[] = result.itemDiagnostics.map(
-    (item) => {
-      const uri = filePathToUri(item.filePath);
-      // Use user content (without prefix) because diagnostic offsets have
-      // already been adjusted to be relative to user content by adjustDiagnostics.
-      const userContent = server!.getUserContent(item.filePath) ?? "";
-      return {
-        uri: uri ?? item.filePath,
-        diagnostics: item.diagnostics.map((diag) =>
-          serializeDiagnostic(diag, userContent),
-        ),
-      };
-    },
-  );
+  const allDiagnostics = [
+    ...result.itemDiagnostics,
+    ...result.expressionDiagnostics,
+  ];
+  const params: PublishDiagnosticsParams[] = allDiagnostics.map((item) => {
+    const uri = filePathToUri(item.filePath);
+    // Use user content (without prefix) because diagnostic offsets have
+    // already been adjusted to be relative to user content by adjustDiagnostics.
+    const userContent = server!.getUserContent(item.filePath) ?? "";
+    return {
+      uri: uri ?? item.filePath,
+      diagnostics: item.diagnostics.map((diag) =>
+        serializeDiagnostic(diag, userContent),
+      ),
+    };
+  });
 
   self.postMessage({
     jsonrpc: "2.0",
diff --git a/libs/@hashintel/petrinaut/src/monaco/provider.tsx b/libs/@hashintel/petrinaut/src/monaco/provider.tsx
index 0eff5ff7995..a76a7be44b4 100644
--- a/libs/@hashintel/petrinaut/src/monaco/provider.tsx
+++ b/libs/@hashintel/petrinaut/src/monaco/provider.tsx
@@ -19,6 +19,12 @@ async function initMonaco(): Promise<MonacoContextValue> {
     import(
       "monaco-editor/esm/vs/basic-languages/typescript/typescript.contribution.js"
     ),
+    import(
+      "monaco-editor/esm/vs/basic-languages/python/python.contribution.js"
+    ),
+    import(
+      "monaco-editor/esm/vs/basic-languages/fsharp/fsharp.contribution.js"
+    ),
   ]);
 
   window.MonacoEnvironment = {
diff --git a/libs/@hashintel/petrinaut/src/state/user-settings-context.ts b/libs/@hashintel/petrinaut/src/state/user-settings-context.ts
index 4b7f0d7cf02..e2766549ffb 100644
--- a/libs/@hashintel/petrinaut/src/state/user-settings-context.ts
+++ b/libs/@hashintel/petrinaut/src/state/user-settings-context.ts
@@ -42,6 +42,7 @@ export type UserSettings = {
   snapToGrid: boolean;
   partialSelection: boolean;
   useEntitiesTreeView: boolean;
+  showExpressionOutput: boolean;
   subViewPanels: SubViewPanelsSettings;
 };
 
@@ -62,6 +63,7 @@ export type UserSettingsActions = {
   setSnapToGrid: (value: boolean) => void;
   setPartialSelection: (value: boolean) => void;
   setUseEntitiesTreeView: (value: boolean) => void;
+  setShowExpressionOutput: (value: boolean) => void;
   updateSubViewSection: (
     containerName: string,
     sectionId: string,
@@ -88,6 +90,7 @@ export const defaultUserSettings: UserSettings = {
   snapToGrid: true,
   partialSelection: true,
   useEntitiesTreeView: false,
+  showExpressionOutput: false,
   subViewPanels: {},
 };
 
@@ -109,6 +112,7 @@ const DEFAULT_CONTEXT_VALUE: UserSettingsContextValue = {
   setSnapToGrid: () => {},
   setPartialSelection: () => {},
   setUseEntitiesTreeView: () => {},
+  setShowExpressionOutput: () => {},
   updateSubViewSection: () => {},
 };
 
diff --git a/libs/@hashintel/petrinaut/src/state/user-settings-provider.tsx b/libs/@hashintel/petrinaut/src/state/user-settings-provider.tsx
index 5ac4b93bc7f..2c35ccce2df 100644
--- a/libs/@hashintel/petrinaut/src/state/user-settings-provider.tsx
+++ b/libs/@hashintel/petrinaut/src/state/user-settings-provider.tsx
@@ -77,6 +77,8 @@ export const UserSettingsProvider: React.FC<React.PropsWithChildren> = ({
       setState((prev) => ({ ...prev, partialSelection: value })),
     setUseEntitiesTreeView: (value: boolean) =>
       setState((prev) => ({ ...prev, useEntitiesTreeView: value })),
+    setShowExpressionOutput: (value: boolean) =>
+      setState((prev) => ({ ...prev, showExpressionOutput: value })),
     updateSubViewSection: (
       containerName: string,
       sectionId: string,
diff --git a/libs/@hashintel/petrinaut/src/views/Editor/editor-view.tsx b/libs/@hashintel/petrinaut/src/views/Editor/editor-view.tsx
index e1c2a62916a..c99f58a3a92 100644
--- a/libs/@hashintel/petrinaut/src/views/Editor/editor-view.tsx
+++ b/libs/@hashintel/petrinaut/src/views/Editor/editor-view.tsx
@@ -27,6 +27,7 @@ import {
 import { BottomBar } from "./components/BottomBar/bottom-bar";
 import { ImportErrorDialog } from "./components/import-error-dialog";
 import { TopBar } from "./components/TopBar/top-bar";
+import { exportWithSymPy } from "./lib/export-sympy";
 import { exportTikZ } from "./lib/export-tikz";
 import { BottomPanel } from "./panels/BottomPanel/panel";
 import { LeftSideBar } from "./panels/LeftSideBar/panel";
@@ -156,6 +157,10 @@ export const EditorView = ({
     exportTikZ({ petriNetDefinition, title });
   }
 
+  function handleExportWithSymPy() {
+    exportWithSymPy({ petriNetDefinition, title });
+  }
+
   async function handleImport() {
     const result = await importSDCPN();
     if (!result) {
@@ -244,6 +249,11 @@ export const EditorView = ({
           label: "TikZ",
           onClick: handleExportTikZ,
         },
+        {
+          id: "export-sympy",
+          label: "JSON with SymPy expressions",
+          onClick: handleExportWithSymPy,
+        },
       ],
     },
     {
diff --git a/libs/@hashintel/petrinaut/src/views/Editor/lib/export-sympy.ts b/libs/@hashintel/petrinaut/src/views/Editor/lib/export-sympy.ts
new file mode 100644
index 00000000000..f5a95468e5c
--- /dev/null
+++ b/libs/@hashintel/petrinaut/src/views/Editor/lib/export-sympy.ts
@@ -0,0 +1,103 @@
+import type { SDCPN } from "../../../core/types/sdcpn";
+import { irToSymPy } from "../../../expression/ir-to-sympy/ir-to-sympy";
+import {
+  buildContextForDifferentialEquation,
+  buildContextForTransition,
+  compileToIR,
+} from "../../../expression/ts-to-ir/compile-to-ir";
+
+type SymPyExpression = {
+  name: string;
+  type: string;
+  sympyCode: string | null;
+  error: string | null;
+};
+
+function compileToSymPy(
+  code: string,
+  ctx: ReturnType<typeof buildContextForTransition>,
+): { ok: true; sympyCode: string } | { ok: false; error: string } {
+  const irResult = compileToIR(code, ctx);
+  if (!irResult.ok) return irResult;
+  return { ok: true, sympyCode: irToSymPy(irResult.ir) };
+}
+
+/**
+ * Converts all expressions in an SDCPN model to SymPy and produces a JSON
+ * export containing both the original model and the SymPy representations.
+ */
+export function exportWithSymPy({
+  petriNetDefinition,
+  title,
+}: {
+  petriNetDefinition: SDCPN;
+  title: string;
+}): void {
+  const expressions: SymPyExpression[] = [];
+
+  // Convert differential equation expressions
+  for (const de of petriNetDefinition.differentialEquations) {
+    const ctx = buildContextForDifferentialEquation(
+      petriNetDefinition,
+      de.colorId,
+    );
+    const result = compileToSymPy(de.code, ctx);
+    expressions.push({
+      name: de.name,
+      type: "differential-equation",
+      sympyCode: result.ok ? result.sympyCode : null,
+      error: result.ok ? null : result.error,
+    });
+  }
+
+  // Convert transition lambda and kernel expressions
+  for (const transition of petriNetDefinition.transitions) {
+    const lambdaCtx = buildContextForTransition(
+      petriNetDefinition,
+      transition,
+      "Lambda",
+    );
+    const lambdaResult = compileToSymPy(transition.lambdaCode, lambdaCtx);
+    expressions.push({
+      name: `${transition.name} (lambda)`,
+      type: "transition-lambda",
+      sympyCode: lambdaResult.ok ? lambdaResult.sympyCode : null,
+      error: lambdaResult.ok ? null : lambdaResult.error,
+    });
+
+    const kernelCtx = buildContextForTransition(
+      petriNetDefinition,
+      transition,
+      "TransitionKernel",
+    );
+    const kernelResult = compileToSymPy(
+      transition.transitionKernelCode,
+      kernelCtx,
+    );
+    expressions.push({
+      name: `${transition.name} (kernel)`,
+      type: "transition-kernel",
+      sympyCode: kernelResult.ok ? kernelResult.sympyCode : null,
+      error: kernelResult.ok ? null : kernelResult.error,
+    });
+  }
+
+  const exportData = {
+    title,
+    sympy_expressions: expressions,
+    ...petriNetDefinition,
+  };
+
+  const jsonString = JSON.stringify(exportData, null, 2);
+  const blob = new Blob([jsonString], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = `${title.replace(/[^a-z0-9]/gi, "_").toLowerCase()}_sympy_${new Date().toISOString().replace(/:/g, "-")}.json`;
+
+  document.body.appendChild(link);
+  link.click();
+
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
diff --git a/libs/@hashintel/petrinaut/src/views/Editor/panels/PropertiesPanel/differential-equation-properties/subviews/main.tsx b/libs/@hashintel/petrinaut/src/views/Editor/panels/PropertiesPanel/differential-equation-properties/subviews/main.tsx
index 7be7e63cecb..0b7ef40a23e 100644
--- a/libs/@hashintel/petrinaut/src/views/Editor/panels/PropertiesPanel/differential-equation-properties/subviews/main.tsx
+++ b/libs/@hashintel/petrinaut/src/views/Editor/panels/PropertiesPanel/differential-equation-properties/subviews/main.tsx
@@ -1,5 +1,6 @@
 import { css } from "@hashintel/ds-helpers/css";
 import { useState } from "react";
+import { Group, Panel, Separator } from "react-resizable-panels";
 import { TbDotsVertical, TbSparkles } from "react-icons/tb";
 
 import { Button } from "../../../../../../components/button";
@@ -16,6 +17,8 @@ import {
   DEFAULT_DIFFERENTIAL_EQUATION_CODE,
   generateDefaultDifferentialEquationCode,
 } from "../../../../../../core/default-codes";
+import { ExpressionOutputPanel } from "../../../../../../expression/expression-output-panel";
+import { useDiffEqExpressionOutput } from "../../../../../../expression/use-expression-ir-output";
 import { CodeEditor } from "../../../../../../monaco/code-editor";
 import { getDocumentUri } from "../../../../../../monaco/editor-paths";
 import { useIsReadOnly } from "../../../../../../state/use-is-read-only";
@@ -90,12 +93,36 @@ const aiIconStyle = css({
   fontSize: "base",
 });
 
+const panelGroupStyle = css({
+  flex: "[1]",
+  minHeight: "[0]",
+});
+
+const panelStyle = css({
+  height: "full",
+});
+
+const resizeHandleStyle = css({
+  borderTopWidth: "thin",
+  borderTopColor: "neutral.a20",
+  cursor: "ns-resize",
+  backgroundColor: "[transparent]",
+  transition: "[background-color 0.15s ease]",
+  "&[data-separator=hover]": {
+    backgroundColor: "neutral.a40",
+  },
+  "&[data-separator=active]": {
+    backgroundColor: "blue.s60",
+  },
+});
+
 const DiffEqMainContent: React.FC = () => {
   const { differentialEquation, types, places, updateDifferentialEquation } =
     useDiffEqPropertiesContext();
   const [showConfirmDialog, setShowConfirmDialog] = useState(false);
   const [pendingTypeId, setPendingTypeId] = useState<string | null>(null);
   const isReadOnly = useIsReadOnly();
+  const expressionOutput = useDiffEqExpressionOutput(differentialEquation);
 
   const placesUsingEquation = places.filter((place) => {
     if (!place.differentialEquationId) {
@@ -258,25 +285,55 @@ const DiffEqMainContent: React.FC = () => {
       )}
 
       <Section title="Code" fillHeight>
-        <CodeEditor
-          path={getDocumentUri(
-            "differential-equation",
-            differentialEquation.id,
-          )}
-          language="typescript"
-          value={differentialEquation.code}
-          height="100%"
-          onChange={(newCode) => {
-            updateDifferentialEquation(
+        {expressionOutput !== null ? (
+          <Group orientation="vertical" className={panelGroupStyle}>
+            <Panel defaultSize={60} minSize={30} className={panelStyle}>
+              <CodeEditor
+                path={getDocumentUri(
+                  "differential-equation",
+                  differentialEquation.id,
+                )}
+                language="typescript"
+                value={differentialEquation.code}
+                height="100%"
+                onChange={(newCode) => {
+                  updateDifferentialEquation(
+                    differentialEquation.id,
+                    (existingEquation) => {
+                      existingEquation.code = newCode ?? "";
+                    },
+                  );
+                }}
+                options={{ readOnly: isReadOnly }}
+                tooltip={isReadOnly ? UI_MESSAGES.READ_ONLY_MODE : undefined}
+              />
+            </Panel>
+            <Separator className={resizeHandleStyle} />
+            <Panel minSize={20} className={panelStyle}>
+              <ExpressionOutputPanel output={expressionOutput} />
+            </Panel>
+          </Group>
+        ) : (
+          <CodeEditor
+            path={getDocumentUri(
+              "differential-equation",
               differentialEquation.id,
-              (existingEquation) => {
-                existingEquation.code = newCode ?? "";
-              },
-            );
-          }}
-          options={{ readOnly: isReadOnly }}
-          tooltip={isReadOnly ? UI_MESSAGES.READ_ONLY_MODE : undefined}
-        />
+            )}
+            language="typescript"
+            value={differentialEquation.code}
+            height="100%"
+            onChange={(newCode) => {
+              updateDifferentialEquation(
+                differentialEquation.id,
+                (existingEquation) => {
+                  existingEquation.code = newCode ?? "";
+                },
+              );
+            }}
+            options={{ readOnly: isReadOnly }}
+            tooltip={isReadOnly ? UI_MESSAGES.READ_ONLY_MODE : undefined}
+          />
+        )}
       </Section>
     </SectionList>
   );
diff --git a/libs/@hashintel/petrinaut/src/views/Editor/panels/PropertiesPanel/transition-properties/subviews/transition-firing-time/subview.tsx b/libs/@hashintel/petrinaut/src/views/Editor/panels/PropertiesPanel/transition-properties/subviews/transition-firing-time/subview.tsx
index a694f285629..9dc973538ab 100644
--- a/libs/@hashintel/petrinaut/src/views/Editor/panels/PropertiesPanel/transition-properties/subviews/transition-firing-time/subview.tsx
+++ b/libs/@hashintel/petrinaut/src/views/Editor/panels/PropertiesPanel/transition-properties/subviews/transition-firing-time/subview.tsx
@@ -1,5 +1,6 @@
 import { css } from "@hashintel/ds-helpers/css";
 import { use } from "react";
+import { Group, Panel, Separator } from "react-resizable-panels";
 import { TbDotsVertical, TbSparkles } from "react-icons/tb";
 
 import { IconButton } from "../../../../../../../components/icon-button";
@@ -9,6 +10,8 @@ import type { SubView } from "../../../../../../../components/sub-view/types";
 import { Tooltip } from "../../../../../../../components/tooltip";
 import { UI_MESSAGES } from "../../../../../../../constants/ui-messages";
 import { generateDefaultLambdaCode } from "../../../../../../../core/default-codes";
+import { ExpressionOutputPanel } from "../../../../../../../expression/expression-output-panel";
+import { useExpressionOutput } from "../../../../../../../expression/use-expression-ir-output";
 import { CodeEditor } from "../../../../../../../monaco/code-editor";
 import { getDocumentUri } from "../../../../../../../monaco/editor-paths";
 import { EditorContext } from "../../../../../../../state/editor-context";
@@ -21,6 +24,29 @@ const contentStyle = css({
   minHeight: "[0]",
 });
 
+const panelGroupStyle = css({
+  flex: "[1]",
+  minHeight: "[0]",
+});
+
+const panelStyle = css({
+  height: "full",
+});
+
+const resizeHandleStyle = css({
+  borderLeftWidth: "thin",
+  borderLeftColor: "neutral.a20",
+  cursor: "ew-resize",
+  backgroundColor: "[transparent]",
+  transition: "[background-color 0.15s ease]",
+  "&[data-separator=hover]": {
+    backgroundColor: "neutral.a40",
+  },
+  "&[data-separator=active]": {
+    backgroundColor: "blue.s60",
+  },
+});
+
 const segmentGroupContainerStyle = css({
   marginBottom: "[8px]",
 });
@@ -99,6 +125,7 @@ const FiringTimeHeaderAction: React.FC = () => {
 const TransitionFiringTimeContent: React.FC = () => {
   const { transition, isReadOnly, updateTransition } =
     useTransitionPropertiesContext();
+  const expressionOutput = useExpressionOutput(transition, "Lambda");
 
   return (
     <div className={contentStyle}>
@@ -127,19 +154,43 @@ const TransitionFiringTimeContent: React.FC = () => {
           : "Return a numeric rate representing the average number of firings per second. The transition fires stochastically according to this rate."}
       </div>
 
-      <CodeEditor
-        path={getDocumentUri("transition-lambda", transition.id)}
-        language="typescript"
-        value={transition.lambdaCode || ""}
-        height="100%"
-        onChange={(value) => {
-          updateTransition(transition.id, (existingTransition) => {
-            existingTransition.lambdaCode = value ?? "";
-          });
-        }}
-        options={{ readOnly: isReadOnly }}
-        tooltip={isReadOnly ? UI_MESSAGES.READ_ONLY_MODE : undefined}
-      />
+      {expressionOutput !== null ? (
+        <Group orientation="vertical" className={panelGroupStyle}>
+          <Panel defaultSize={60} minSize={30} className={panelStyle}>
+            <CodeEditor
+              path={getDocumentUri("transition-lambda", transition.id)}
+              language="typescript"
+              value={transition.lambdaCode || ""}
+              height="100%"
+              onChange={(value) => {
+                updateTransition(transition.id, (existingTransition) => {
+                  existingTransition.lambdaCode = value ?? "";
+                });
+              }}
+              options={{ readOnly: isReadOnly }}
+              tooltip={isReadOnly ? UI_MESSAGES.READ_ONLY_MODE : undefined}
+            />
+          </Panel>
+          <Separator className={resizeHandleStyle} />
+          <Panel minSize={20} className={panelStyle}>
+            <ExpressionOutputPanel output={expressionOutput} />
+          </Panel>
+        </Group>
+      ) : (
+        <CodeEditor
+          path={getDocumentUri("transition-lambda", transition.id)}
+          language="typescript"
+          value={transition.lambdaCode || ""}
+          height="100%"
+          onChange={(value) => {
+            updateTransition(transition.id, (existingTransition) => {
+              existingTransition.lambdaCode = value ?? "";
+            });
+          }}
+          options={{ readOnly: isReadOnly }}
+          tooltip={isReadOnly ? UI_MESSAGES.READ_ONLY_MODE : undefined}
+        />
+      )}
     </div>
   );
 };
diff --git a/libs/@hashintel/petrinaut/src/views/Editor/panels/PropertiesPanel/transition-properties/subviews/transition-results/subview.tsx b/libs/@hashintel/petrinaut/src/views/Editor/panels/PropertiesPanel/transition-properties/subviews/transition-results/subview.tsx
index ffe19fb3796..0140d3a912f 100644
--- a/libs/@hashintel/petrinaut/src/views/Editor/panels/PropertiesPanel/transition-properties/subviews/transition-results/subview.tsx
+++ b/libs/@hashintel/petrinaut/src/views/Editor/panels/PropertiesPanel/transition-properties/subviews/transition-results/subview.tsx
@@ -1,5 +1,6 @@
 import { css } from "@hashintel/ds-helpers/css";
 import { use } from "react";
+import { Group, Panel, Separator } from "react-resizable-panels";
 import { TbDotsVertical, TbSparkles } from "react-icons/tb";
 
 import { IconButton } from "../../../../../../../components/icon-button";
@@ -8,6 +9,8 @@ import type { SubView } from "../../../../../../../components/sub-view/types";
 import { Tooltip } from "../../../../../../../components/tooltip";
 import { UI_MESSAGES } from "../../../../../../../constants/ui-messages";
 import { generateDefaultTransitionKernelCode } from "../../../../../../../core/default-codes";
+import { ExpressionOutputPanel } from "../../../../../../../expression/expression-output-panel";
+import { useExpressionOutput } from "../../../../../../../expression/use-expression-ir-output";
 import { CodeEditor } from "../../../../../../../monaco/code-editor";
 import { getDocumentUri } from "../../../../../../../monaco/editor-paths";
 import { EditorContext } from "../../../../../../../state/editor-context";
@@ -30,6 +33,29 @@ const contentStyle = css({
   minHeight: "[0]",
 });
 
+const panelGroupStyle = css({
+  flex: "[1]",
+  minHeight: "[0]",
+});
+
+const panelStyle = css({
+  height: "full",
+});
+
+const resizeHandleStyle = css({
+  borderLeftWidth: "thin",
+  borderLeftColor: "neutral.a20",
+  cursor: "ew-resize",
+  backgroundColor: "[transparent]",
+  transition: "[background-color 0.15s ease]",
+  "&[data-separator=hover]": {
+    backgroundColor: "neutral.a40",
+  },
+  "&[data-separator=active]": {
+    backgroundColor: "blue.s60",
+  },
+});
+
 const messageStyle = css({
   padding: "[12px]",
   fontSize: "xs",
@@ -136,6 +162,7 @@ const ResultsHeaderAction: React.FC = () => {
 const TransitionResultsContent: React.FC = () => {
   const { transition, places, isReadOnly, updateTransition } =
     useTransitionPropertiesContext();
+  const expressionOutput = useExpressionOutput(transition, "TransitionKernel");
 
   const hasOutputPlaceWithType = transition.outputArcs.some((arc) => {
     const place = places.find((p) => p.id === arc.placeId);
@@ -154,19 +181,43 @@ const TransitionResultsContent: React.FC = () => {
 
   return (
     <div className={contentStyle}>
-      <CodeEditor
-        path={getDocumentUri("transition-kernel", transition.id)}
-        language="typescript"
-        value={transition.transitionKernelCode || ""}
-        height="100%"
-        onChange={(value) => {
-          updateTransition(transition.id, (existingTransition) => {
-            existingTransition.transitionKernelCode = value ?? "";
-          });
-        }}
-        options={{ readOnly: isReadOnly }}
-        tooltip={isReadOnly ? UI_MESSAGES.READ_ONLY_MODE : undefined}
-      />
+      {expressionOutput !== null ? (
+        <Group orientation="vertical" className={panelGroupStyle}>
+          <Panel defaultSize={60} minSize={30} className={panelStyle}>
+            <CodeEditor
+              path={getDocumentUri("transition-kernel", transition.id)}
+              language="typescript"
+              value={transition.transitionKernelCode || ""}
+              height="100%"
+              onChange={(value) => {
+                updateTransition(transition.id, (existingTransition) => {
+                  existingTransition.transitionKernelCode = value ?? "";
+                });
+              }}
+              options={{ readOnly: isReadOnly }}
+              tooltip={isReadOnly ? UI_MESSAGES.READ_ONLY_MODE : undefined}
+            />
+          </Panel>
+          <Separator className={resizeHandleStyle} />
+          <Panel minSize={20} className={panelStyle}>
+            <ExpressionOutputPanel output={expressionOutput} />
+          </Panel>
+        </Group>
+      ) : (
+        <CodeEditor
+          path={getDocumentUri("transition-kernel", transition.id)}
+          language="typescript"
+          value={transition.transitionKernelCode || ""}
+          height="100%"
+          onChange={(value) => {
+            updateTransition(transition.id, (existingTransition) => {
+              existingTransition.transitionKernelCode = value ?? "";
+            });
+          }}
+          options={{ readOnly: isReadOnly }}
+          tooltip={isReadOnly ? UI_MESSAGES.READ_ONLY_MODE : undefined}
+        />
+      )}
     </div>
   );
 };
diff --git a/libs/@hashintel/petrinaut/src/views/SDCPN/components/viewport-settings-dialog.tsx b/libs/@hashintel/petrinaut/src/views/SDCPN/components/viewport-settings-dialog.tsx
index 95321d15e1b..e0dacaa6ded 100644
--- a/libs/@hashintel/petrinaut/src/views/SDCPN/components/viewport-settings-dialog.tsx
+++ b/libs/@hashintel/petrinaut/src/views/SDCPN/components/viewport-settings-dialog.tsx
@@ -100,6 +100,8 @@ export const ViewportSettingsDialog: React.FC<ViewportSettingsDialogProps> = ({
     setPartialSelection,
     useEntitiesTreeView,
     setUseEntitiesTreeView,
+    showExpressionOutput,
+    setShowExpressionOutput,
   } = use(UserSettingsContext);
 
   return (
@@ -167,6 +169,20 @@ export const ViewportSettingsDialog: React.FC<ViewportSettingsDialogProps> = ({
                 onCheckedChange={setUseEntitiesTreeView}
               />
             </SettingRow>
+            <SettingRow
+              label={
+                <>
+                  Expression output{" "}
+                  <span className={badgeStyle}>Experimental</span>
+                </>
+              }
+              description="Show a read-only panel with the compiled expression IR next to code editors"
+            >
+              <Switch
+                checked={showExpressionOutput}
+                onCheckedChange={setShowExpressionOutput}
+              />
+            </SettingRow>
             <SettingRow label="Arcs rendering">
               <Select
                 className={selectStyle}