Editable pressure variable in G-code files, with a fallback checkbox

Pressure-owning files now start with a hand-editable variable line
({preset}{aux_command}globals().update(pressureN = X)) that every
pressure command references — the preset is setpress(pressureN) and each
ramp step is round(min(pressureN + k, 100), 1) — so a print's pressure
can be changed by editing one number in the file, no regeneration
needed. The line's shape is dictated by the TCode host: {aux_command}
keeps it off the motion timeline (routing is by substring), presets are
exec'd as one list literal so only expressions survive, and the name is
per-port because all files share one exec namespace.

An "Editable Pressure Variable" checkbox (on by default) falls back to
the plain numeric format in case a host cannot run the variable form;
it participates in the staleness banner and settings export/import.
Verified against a simulation of TCode.py's routing/exec pipeline,
including hand-edit rebasing and multi-port independence.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

README.md

@@ -123,9 +123,10 @@ The **Multi-Nozzle Split** accordion on the **Shapes & G-Code** tab can split on
 - Generated G-code starts in relative coordinate mode (`G91`).
 - The app opens the valve where the tool path is inside a shape's layer polygons and closes it elsewhere.
 - Generated files include pressure preset commands and WAGO valve commands based on the selected pressure, valve, and port; the nozzle number controls layout/spacing assignment.
-- Pressure commands are written **once per port**: when shapes share a serial port, only the first shape's file carries the preset, toggle, and per-layer ramp — the print host compiles every file onto one timeline, and duplicated toggles would flip the regulator on/off/on at start. Valve commands stay per shape in every file.
+- Pressure commands are written **once per port**: when shapes share a serial port, only the first shape's file carries the pressure variable, preset, toggle, and per-layer ramp — the print host compiles every file onto one timeline, and duplicated toggles would flip the regulator on/off/on at start. Valve commands stay per shape in every file.
+- **Editable pressure variable** (checkbox, on by default): each pressure-owning file starts with `{preset}{aux_command}globals().update(pressure3 = 25)` (the value from the Shape Settings table, the variable named after the file's serial port), and every pressure command references that variable — the preset is `setpress(pressure3)` and each ramp step is `setpress(round(min(pressure3 + 0.1, 100), 1))`. To print the same file at a different pressure, edit the one number on the first line; the preset and the entire ramp follow, no regeneration needed. The line's exact shape is dictated by the TCode print host: `{aux_command}` keeps it off the motion timeline (only lines containing `{aux_command}`/`serialPort` are routed as commands), and the host execs all `{preset}` commands as one list literal, so the line must be a pure expression — `globals().update(...)` is the expression form of the assignment. Naming the variable per port keeps multi-port prints independent, since the host runs every file in one shared namespace. Unchecking **Editable Pressure Variable** writes plain numeric pressure commands instead (the pre-variable format, e.g. `setpress(25)` with ramp values baked in), as a fallback in case a host cannot run the variable form.
 - Pressure increases by `0.1` psi per layer by default.
-- Pressures are bounded to the regulator's range: table values clamp to 0–100 psi and snap to the tenths place (the serial protocol encodes `pressure × 10`), the per-layer ramp never climbs past 100 psi in the files, and the generation status warns when a ramp would hit the ceiling before the last layer.
+- Pressures are bounded to the regulator's range: table values clamp to 0–100 psi and snap to the tenths place (the serial protocol encodes `pressure × 10`), the ramp expressions clamp at 100 psi even for hand-edited variable values, and the generation status warns when a ramp would hit the ceiling before the last layer.
 - Every movement line is emitted as `G1` at one constant speed (no `G0` rapid travel); the WAGO valve commands mark where material is dispensed vs where the head just travels.
 - **Lead In**: enabled per shape via the **Lead In** column in Shape Settings; the Lead In Options accordion sets the patch geometry. Prints a purge patch before layer 1: **Lead In Position** (Left/Right/Up/Down) picks which side of the shape it sits on, **Lead In Clearance** how far away, and **Lead In Line Direction** which way the purge strokes run — Auto points them at the shape (the historical behavior), or force Horizontal/Vertical (e.g. a patch below the shape with horizontal strokes). The purge always finishes at the patch corner nearest the toolpath start, whatever the line count's parity: strokes running across the approach print the farthest line first and step back toward the shape, and the zigzag starts from whichever end makes the last stroke land on the start corner — so the freshly primed nozzle travels only the short clearance lane to the print, never back across the wet purge lines. For grid-split pieces the clearance is automatically extended by the assembly's remaining extent along the purge axis (reported in the G-code status), so under shared reference motion every nozzle's purge patch lands clear of the whole assembled part instead of on a neighbor's print area. The **Lead In** column in Shape Settings controls dispensing per shape: an opted-out head still travels the shared patch (keeping parallel heads in sync) but keeps its valve shut, and skips the lead-in moves entirely when printing without shared motion.
 - **Combined reference outline for motion** (always on): every shape's *motion* is taken from the combined reference layer union while each shape's *valve/dispensing* comes from its own layer polygons — so parallel print heads share one synchronized nozzle path and each deposits only its own geometry. The reference union is rebuilt automatically whenever shapes are sliced or G-code is generated. Contour tracing stays synchronized too: every shape traces every traced shape's contour, opening its valve only on its own outline.

app.py

@@ -4806,6 +4806,7 @@ def _gcode_settings_snapshot(
     sweep_buffer: float = 0.8,
     lead_in_orientation: str | None = None,
     contour_order: str | None = None,
+    pressure_variable: bool = True,
 ) -> dict:
     """Fingerprint of every setting that shapes this record's G-code.
 
@@ -4839,6 +4840,7 @@ def _gcode_settings_snapshot(
         "scale_mode": _normalize_scale_mode(scale_mode),
         "sweep_buffer": round(_coerce_float(sweep_buffer, 0.8), 6),
         "contour_order": str(contour_order or CONTOUR_ORDER_LAST),
+        "pressure_variable": bool(pressure_variable),
     }
 
 
@@ -4863,6 +4865,7 @@ def check_gcode_staleness(
     sweep_buffer: float = 0.8,
     lead_in_orientation: str | None = None,
     contour_order: str | None = None,
+    pressure_variable: bool = True,
 ) -> str:
     """Warning banner text when generated G-code no longer matches the settings."""
     records = _apply_shape_settings(records or [], settings_table)
@@ -4881,6 +4884,7 @@ def check_gcode_staleness(
         sweep_buffer,
         lead_in_orientation,
         contour_order,
+        pressure_variable,
     )
     for record in records:
         if not record.get("gcode_path"):
@@ -4927,6 +4931,7 @@ def export_project_settings(
     lead_in_orientation: str | None,
     nozzle_speed: Any,
     contour_order: str | None = None,
+    pressure_variable: bool = True,
     split_columns: Any = None,
     split_rows: Any = None,
     split_overlapping_layers: Any = None,
@@ -4970,6 +4975,7 @@ def export_project_settings(
             "lead_in_orientation": str(lead_in_orientation or LEAD_IN_LINE_AUTO),
             "nozzle_speed": _coerce_float(nozzle_speed, 10.0),
             "contour_order": str(contour_order or CONTOUR_ORDER_LAST),
+            "pressure_variable": bool(pressure_variable),
             "split_columns": max(1, _coerce_int(split_columns, 2)),
             "split_rows": max(1, _coerce_int(split_rows, 1)),
             "split_overlapping_layers": bool(split_overlapping_layers),
@@ -5001,7 +5007,7 @@ def import_project_settings(
     """
 
     def _skip_options() -> tuple:
-        return tuple(gr.skip() for _ in range(19))
+        return tuple(gr.skip() for _ in range(20))
 
     paths = _uploaded_file_paths(settings_upload)
     if not paths:
@@ -5064,6 +5070,7 @@ def import_project_settings(
         option("scale_mode"),
         option("nozzle_speed"),
         option("contour_order"),
+        option("pressure_variable"),
         option("split_columns"),
         option("split_rows"),
         option("split_overlapping_layers"),
@@ -5111,6 +5118,7 @@ def generate_dynamic_gcode(
     sweep_buffer: float = 0.8,
     lead_in_orientation: str | None = None,
     contour_order: str | None = None,
+    pressure_variable: bool = True,
     progress: gr.Progress = gr.Progress(),
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
@@ -5217,6 +5225,7 @@ def generate_dynamic_gcode(
                 infill=_coerce_float(record.get("infill", 100.0), 100.0) / 100.0,
                 motion_infill_fractions=motion_infill_fractions,
                 emit_pressure_commands=owns_port_pressure,
+                pressure_variable=bool(pressure_variable),
                 # Same buffer for every shape: the shared motion must match.
                 sweep_buffer=max(0.0, _coerce_float(sweep_buffer, 0.8)),
                 lead_in_enabled=bool(lead_in_enabled),
@@ -5250,6 +5259,7 @@ def generate_dynamic_gcode(
                 sweep_buffer,
                 lead_in_orientation,
                 contour_order,
+                pressure_variable,
             )
             messages.append(f"Shape {record['idx']}: wrote `{gcode_path.name}`.")
         except Exception as exc:
@@ -5799,6 +5809,16 @@ def build_dynamic_demo() -> gr.Blocks:
                 """
             )
             gcode_pressure_ramp_enabled = gr.Checkbox(label="Increase Pressure Each Layer", value=True)
+            gcode_pressure_variable = gr.Checkbox(
+                label="Editable Pressure Variable",
+                value=True,
+                info=(
+                    "Start each pressure-owning file with a pressureN variable that every "
+                    "pressure command references, so the print pressure can be changed by "
+                    "editing one number in the file — no regeneration needed. Uncheck to "
+                    "write plain numeric pressure commands instead."
+                ),
+            )
             with gr.Row(elem_id="gcode-raster-row"):
                 gcode_raster_pattern = gr.Dropdown(
                     label="Raster Pattern",
@@ -6234,6 +6254,7 @@ def build_dynamic_demo() -> gr.Blocks:
                 gcode_lead_in_orientation,
                 viz_nozzle_speed,
                 gcode_contour_order,
+                gcode_pressure_variable,
                 split_columns,
                 split_rows,
                 split_overlapping_layers,
@@ -6264,6 +6285,7 @@ def build_dynamic_demo() -> gr.Blocks:
                 scale_mode,
                 viz_nozzle_speed,
                 gcode_contour_order,
+                gcode_pressure_variable,
                 split_columns,
                 split_rows,
                 split_overlapping_layers,
@@ -6291,6 +6313,7 @@ def build_dynamic_demo() -> gr.Blocks:
             gcode_sweep_buffer,
             gcode_lead_in_orientation,
             gcode_contour_order,
+            gcode_pressure_variable,
         ]
         shape_settings.change(
             fn=check_gcode_staleness,
@@ -6311,6 +6334,7 @@ def build_dynamic_demo() -> gr.Blocks:
             gcode_sweep_buffer,
             gcode_lead_in_orientation,
             gcode_contour_order,
+            gcode_pressure_variable,
         ):
             stale_control.change(
                 fn=check_gcode_staleness,
@@ -6400,6 +6424,7 @@ def build_dynamic_demo() -> gr.Blocks:
                 gcode_sweep_buffer,
                 gcode_lead_in_orientation,
                 gcode_contour_order,
+                gcode_pressure_variable,
             ],
             outputs=[shape_records, ref_layers, gcode_downloads, gcode_status, gcode_text_source, gcode_source, gcode_download_all],
         ).then(

tests/test_nozzle_spacing.py

@@ -2011,6 +2011,7 @@ def test_project_settings_export_import_round_trip(tmp_path) -> None:
     settings_path, status = export_project_settings(
         records, None, 0.4, 0.4, None, "Circle Spiral raster", False, 1.2,
         6.0, 7.0, 4, "Down", "Horizontal", 15.0,
+        pressure_variable=False,
         split_columns=3, split_rows=2, split_overlapping_rows=True,
         split_overlap=1.5,
     )
@@ -2033,10 +2034,11 @@ def test_project_settings_export_import_round_trip(tmp_path) -> None:
     assert option_updates[2]["value"] == 1.2
     assert option_updates[8]["value"] == 0.4  # layer height
     assert option_updates[11]["value"] == 15.0  # nozzle speed
-    assert option_updates[13]["value"] == 3  # split columns
-    assert option_updates[14]["value"] == 2  # split rows
-    assert option_updates[16]["value"] is True  # overlapping rows
-    assert option_updates[18]["value"] == 1.5  # overlap mm
+    assert option_updates[13]["value"] is False  # pressure variable off
+    assert option_updates[14]["value"] == 3  # split columns
+    assert option_updates[15]["value"] == 2  # split rows
+    assert option_updates[17]["value"] is True  # overlapping rows
+    assert option_updates[19]["value"] == 1.5  # overlap mm
 
     # A file listed in the export but not loaded is reported.
     partial = import_project_settings([settings_path], _records_from_files(["egg_inside.stl"], None), None)

tests/test_vector_gcode.py

@@ -209,16 +209,23 @@ def test_gcode_header_writes_presets_before_initial_aux_commands(tmp_path) -> No
         if line.strip()
     ]
 
-    assert lines[0] == "G91"
+    # The hand-editable pressure variable leads the file; every pressure
+    # command below references it, so editing this one number retunes the
+    # whole print without regenerating. The odd shape is host-dictated:
+    # {aux_command} routes the line off the motion timeline, and the host
+    # execs presets as one list literal, so the line must be an expression
+    # (a bare `pressure3 = 25` assignment would be a syntax error there).
+    assert lines[0] == "{preset}{aux_command}globals().update(pressure3 = 25)"
+    assert lines[1] == "G91"
     # No metadata comments: the file starts straight with machine commands
     # (the toolpath's world anchor is returned via origin_sink instead).
     assert not any("PathOrigin" in line for line in lines)
-    assert lines[1] == "{aux_command}WAGO_ValveCommands(7, 0)"
+    assert lines[2] == "{aux_command}WAGO_ValveCommands(7, 0)"
     # {preset} marks pressure setup for the Aerotech host runtime.
-    assert lines[2] == "{preset}serialPort3.write(eval(setpress(25)))"
-    assert lines[3] == "{preset}serialPort3.write(eval(togglepress()))"
+    assert lines[3] == "{preset}serialPort3.write(eval(setpress(pressure3)))"
+    assert lines[4] == "{preset}serialPort3.write(eval(togglepress()))"
     # The header ends there: no dummy valve-100 init, no duplicate close.
-    assert lines[4].startswith("G")
+    assert lines[5].startswith("G")
     assert not any("WAGO_ValveCommands(100" in line for line in lines)
 
 
@@ -304,6 +311,36 @@ def test_sweep_buffer_is_adjustable_and_can_be_disabled(tmp_path) -> None:
     assert none[0]["start"] == (0.0, 0.0, 0.0)
 
 
+def _pressure_values(gcode_text: str, override: float | None = None) -> list[float]:
+    """Evaluate every setpress(...) expression the way the print host does.
+
+    The TCode host routes lines containing {aux_command}/serialPort as
+    commands, strips the markers, execs the {preset} commands as ONE list
+    literal in its module namespace, and execs ramp commands individually
+    in that same namespace. This mimics exactly that: the file's own
+    variable line defines `pressureN`, then each setpress argument is
+    evaluated in the shared namespace. `override` simulates the user
+    hand-editing the variable's value before printing.
+    """
+    namespace: dict = {}
+    values = []
+    for line in gcode_text.splitlines():
+        line = line.strip()
+        if "{aux_command}" not in line and "serialPort" not in line:
+            continue  # the host would parse this as a motion line
+        command = line.replace("{aux_command}", "").replace("{preset}", "")
+        if "globals().update(" in command:
+            expr = command.split("globals().update(", 1)[1].rsplit(")", 1)[0]
+            name, value = (part.strip() for part in expr.split("="))
+            namespace[name] = float(value) if override is None else override
+        elif "setpress(" in command:
+            # The command ends `...setpress(EXPR)))` — closing setpress,
+            # eval, and write; the expression itself may contain parens.
+            expr = command.split("setpress(", 1)[1].rsplit(")))", 1)[0]
+            values.append(float(eval(expr, namespace)))
+    return values
+
+
 def test_pressure_ramp_clamps_at_the_regulator_limit(tmp_path) -> None:
     import re
 
@@ -319,11 +356,18 @@ def test_pressure_ramp_clamps_at_the_regulator_limit(tmp_path) -> None:
         pressure_ramp_enabled=True,
         output_dir=tmp_path,
     )
-    values = [
-        float(match) for match in re.findall(r"setpress\(([\d.]+)\)", gcode_path.read_text())
-    ]
+    text = gcode_path.read_text()
+
+    # The file ships with the configured pressure as its variable default.
+    default = re.search(r"globals\(\)\.update\(pressure3 = ([\d.]+)\)", text)
+    assert default is not None and float(default.group(1)) == 99.8
+
     # Preset, then the ramp climbing 0.1/layer but never past 100 psi.
-    assert values == [99.8, 99.9, 100.0, 100.0]
+    assert _pressure_values(text) == [99.8, 99.9, 100.0, 100.0]
+
+    # Hand-editing the variable rebases the ENTIRE ramp — the point of the
+    # feature: no regeneration needed to print the same file at 50 psi.
+    assert _pressure_values(text, override=50.0) == [50.0, 50.1, 50.2, 50.3]
 
 
 def test_port_sharing_files_emit_pressure_commands_once(tmp_path) -> None:
@@ -356,10 +400,75 @@ def test_port_sharing_files_emit_pressure_commands_once(tmp_path) -> None:
     assert "serialPort3" not in follower
     assert _pressure_set_count(follower) == 0
     assert "togglepress" not in follower
+    # The pressure variable lives only in the port-owning file too.
+    assert "globals().update(pressure3 = 25)" in owner
+    assert "globals().update" not in follower
     # Valve control is per shape and unaffected.
     assert follower.count("WAGO_ValveCommands(7, 1)") == owner.count("WAGO_ValveCommands(7, 1)")
 
 
+def test_pressure_variable_is_namespaced_per_port(tmp_path) -> None:
+    # The print host execs every file's commands in ONE shared namespace:
+    # if two port-owning files used the same variable name, each file's
+    # ramp would read whichever file defined it LAST. Naming the variable
+    # by port keeps each regulator on its own knob.
+    layer = box(0.0, 0.0, 2.0, 2.0)
+
+    def _generate(port: int) -> str:
+        path = generate_vector_gcode(
+            _stack(layer, layer),
+            shape_name=f"port{port}",
+            pressure=25,
+            valve=7,
+            port=port,
+            fil_width=1.0,
+            layer_height=1.0,
+            pressure_ramp_enabled=True,
+            output_dir=tmp_path / f"port{port}",
+        )
+        return path.read_text()
+
+    on_port2 = _generate(2)
+    on_port3 = _generate(3)
+
+    assert "globals().update(pressure2 = 25)" in on_port2
+    assert "pressure3" not in on_port2
+    assert "globals().update(pressure3 = 25)" in on_port3
+    assert "pressure2" not in on_port3
+    # Every setpress in each file references its own port's variable.
+    assert "setpress(pressure2)" in on_port2
+    assert "pressure2 + 0.1" in on_port2
+    assert "setpress(pressure3)" in on_port3
+    assert "pressure3 + 0.1" in on_port3
+
+
+def test_pressure_variable_can_be_disabled(tmp_path) -> None:
+    # The "Editable Pressure Variable" checkbox off: files fall back to the
+    # plain numeric format (pre-variable), in case the host chokes on the
+    # variable form.
+    layer = box(0.0, 0.0, 2.0, 2.0)
+    gcode_path = generate_vector_gcode(
+        _stack(layer, layer, layer),
+        shape_name="no_variable",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        layer_height=1.0,
+        pressure_ramp_enabled=True,
+        pressure_variable=False,
+        output_dir=tmp_path,
+    )
+    text = gcode_path.read_text()
+
+    assert "globals().update" not in text
+    assert "pressure3" not in text
+    assert text.startswith("G91\n")
+    assert "{preset}serialPort3.write(eval(setpress(25)))" in text
+    # Ramp values are baked in, clamped and rounded at generation time.
+    assert _pressure_values(text) == [25.0, 25.1, 25.2]
+
+
 def test_gcode_lead_in_runs_once_before_first_layer(tmp_path) -> None:
     gcode_path = generate_vector_gcode(
         _stack(box(0.0, 0.0, 0.5, 0.5), box(0.0, 0.0, 0.5, 0.5)),

vector_gcode.py

@@ -53,19 +53,73 @@ __all__ = [
 ]
 
 
-def _setpress_cmd(port: str, pressure: float, start: bool) -> str:
+def _pressure_variable_name(port: int) -> str:
+    """The hand-editable pressure variable, one per serial port.
+
+    The name carries the port number because the print host execs every
+    file's commands in ONE shared namespace: with several port-owning files
+    in a print, a single shared name would leave every ramp reading the
+    LAST file's base pressure. Pressure is a port property, so `pressureN`
+    is also the natural granularity.
+    """
+    return f"pressure{port}"
+
+
+def _pressure_variable_cmd(port: int, pressure: float) -> str:
+    """The one hand-editable knob: `pressureN = X` on the file's first line.
+
+    The exact form is dictated by how the TCode print host consumes files:
+
+    - Only lines containing `{aux_command}` or `serialPort` are routed as
+      commands; anything else is parsed as a G-code move. The `{aux_command}`
+      marker (stripped by the host) is what keeps this line off the motion
+      timeline.
+    - The host joins all `{preset}` commands into ONE list literal and
+      exec()s it at the controller's START signal, so the line must be a
+      pure EXPRESSION — a bare `pressure = X` assignment would be a syntax
+      error there. `globals().update(pressureN = X)` is an expression that
+      still reads like the assignment, and it lands the name in the host's
+      module globals where the setpress preset (same exec, evaluated next)
+      and the mid-file ramp commands (exec'd individually) can see it.
+
+    Editing this single number retunes every pressure command in the file —
+    no need to regenerate the G-code just to print at a different pressure.
+    """
+    return (
+        f"{{preset}}{{aux_command}}globals().update("
+        f"{_pressure_variable_name(port)} = {pressure:g})"
+    )
+
+
+def _setpress_cmd(port: str, expression: str, start: bool) -> str:
     """Pressure preset in the readable host dialect.
 
     Every pressure command uses the same `eval(setpress(...))` form (the
-    print host defines `setpress`, which builds the serial byte string), so
-    the values are human-readable throughout the file. `start` adds the
-    {preset} marker: the host executes presets at the controller's START
-    signal, before the initial toggles; ramp commands mid-file run at their
-    scheduled times instead.
+    print host defines `setpress`, which builds the serial byte string).
+    `expression` is evaluated by the host — it references the `pressureN`
+    variable declared at the top of the file rather than a baked-in number,
+    so hand-editing that variable retunes the preset and the whole ramp.
+    `start` adds the {preset} marker: the host executes presets at the
+    controller's START signal, before the initial toggles; ramp commands
+    mid-file run at their scheduled times instead.
     """
     if start:
-        return f"\n\r{{preset}}{port}.write(eval(setpress({pressure:g})))"
-    return f"\n\r{port}.write(eval(setpress({pressure:g})))"
+        return f"\n\r{{preset}}{port}.write(eval(setpress({expression})))"
+    return f"\n\r{port}.write(eval(setpress({expression})))"
+
+
+def _ramp_expression(port: int, offset: float) -> str:
+    """Ramp step as an expression of the top-of-file `pressureN` variable.
+
+    The regulator tops out at MAX_PRESSURE_PSI and resolves tenths, so the
+    clamp and rounding travel inside the expression — they must hold for
+    whatever value the user hand-edits the variable to, which rules out
+    pre-computing them here.
+    """
+    return (
+        f"round(min({_pressure_variable_name(port)} + {offset:g}, "
+        f"{MAX_PRESSURE_PSI:g}), 1)"
+    )
 
 
 def _toggle_cmd(port: str, start: bool) -> str:
@@ -102,29 +156,43 @@ def write_gcode_file(
     pressure_ramp_enabled: bool,
     all_g1: bool,
     emit_pressure_commands: bool = True,
+    pressure_variable: bool = True,
 ) -> None:
     """Write the move list as a G-code file.
 
-    `emit_pressure_commands` gates EVERY pressure command (preset, toggle,
-    per-layer ramp, closing toggle): the pressure regulator is a PORT
+    `emit_pressure_commands` gates EVERY pressure command (the top-of-file
+    `pressure` variable, preset, toggle, per-layer ramp, closing toggle):
+    the pressure regulator is a PORT
     device, so when several shapes share a serial port only ONE of their
     files may own it — the print host compiles all files onto one timeline,
     and duplicated toggles would flip the regulator on/off/on at start.
+
+    `pressure_variable` picks the pressure command style: True writes the
+    hand-editable `pressureN` variable on the first line with every
+    setpress referencing it; False writes plain numeric setpress commands
+    (the pre-variable format) with the ramp values baked in.
     """
     off_color = 0
     com_port = f"serialPort{port}"
     color_dict: dict[int, int] = {0: 100, 255: valve}
 
     # The regulator tops out at MAX_PRESSURE_PSI and resolves tenths: clamp
-    # the preset AND the per-layer ramp so no command asks the impossible.
+    # the default the file ships with; the ramp expressions carry their own
+    # clamp so hand-edited values stay legal too.
     pressure = round(min(max(float(pressure), 0.0), MAX_PRESSURE_PSI), 1)
-    setpress_lines = [_setpress_cmd(com_port, pressure, start=True)]
+    preset_expression = (
+        _pressure_variable_name(port) if pressure_variable else f"{pressure:g}"
+    )
+    setpress_lines = [_setpress_cmd(com_port, preset_expression, start=True)]
     pressure_on_lines = [_toggle_cmd(com_port, start=True)]
     pressure_off_lines = [_toggle_cmd(com_port, start=False)]
 
+    ramp_layer = 0
     pressure_cur = float(pressure)
 
     with open(gcode_path, "w") as f:
+        if emit_pressure_commands and pressure_variable:
+            f.write(f"{_pressure_variable_cmd(port, pressure)}\n")
         f.write("G91\n")
         f.write(_valve_cmd(valve, 0))
         if emit_pressure_commands:
@@ -156,10 +224,22 @@ def write_gcode_file(
                     f"Z{_coord(move['Z'])} ; Color {move['Color']}"
                 )
                 if pressure_ramp_enabled and emit_pressure_commands:
-                    pressure_cur = round(
-                        min(pressure_cur + increase_pressure_per_layer, MAX_PRESSURE_PSI), 1
+                    if pressure_variable:
+                        ramp_layer += 1
+                        offset = round(increase_pressure_per_layer * ramp_layer, 6)
+                        ramp_expression = _ramp_expression(port, offset)
+                    else:
+                        pressure_cur = round(
+                            min(
+                                pressure_cur + increase_pressure_per_layer,
+                                MAX_PRESSURE_PSI,
+                            ),
+                            1,
+                        )
+                        ramp_expression = f"{pressure_cur:g}"
+                    pressure_next = _setpress_cmd(
+                        com_port, ramp_expression, start=False
                     )
-                    pressure_next = _setpress_cmd(com_port, pressure_cur, start=False)
                 else:
                     pressure_next = None
             else:
@@ -197,6 +277,7 @@ def generate_vector_gcode(
     infill: float = 1.0,
     motion_infill_fractions: list[float] | None = None,
     emit_pressure_commands: bool = True,
+    pressure_variable: bool = True,
     sweep_buffer: float | None = None,
     increase_pressure_per_layer: float = 0.1,
     pressure_ramp_enabled: bool = True,
@@ -385,5 +466,6 @@ def generate_vector_gcode(
         pressure_ramp_enabled=bool(pressure_ramp_enabled),
         all_g1=bool(all_g1),
         emit_pressure_commands=bool(emit_pressure_commands),
+        pressure_variable=bool(pressure_variable),
     )
     return gcode_path