Big Wish - Drag knife and Tangential knife support

[brakthehun]

Is your feature request related to a problem? Please describe.
The software that does support these features are bulky and not single design to cut solutions.

Describe the solution you'd like
Dragknife - I'd like to see an option to post gcode with a dragknife offset.
Tangental knife - I'd like A axis to to be tangental to X/Y movements and have a radius / angle tolerance for Z lift.

Describe alternatives you've considered
I've had AI make me an HTML based gcode parser that adds an A axis with lift at enough of an angle. It works but it's lame to design,, then save Gcode,, then parse / modify then load the new gcode,, then cut,, and if I want to make any changes,, even speed changes,, I have to repeat the process.

I have a couple programs that can do offset. Some of them don't set the knife before cutting though.

Additional context
It takes about an hour and $25 to convert an old cricut from GoodWill to a GRBL machine.
(this would also require an M3 command - no M4)

LightBurn said it was on their roadmap 5 years ago,, but never implemented it:
https://forum.lightburnsoftware.com/t/will-lightburn-support-drag-knife-instead-of-laser-use-as-a-plotter/44413

[knipknap]

Thank you for this wonderfully detailed wish list — and for the context on the GoodWill Cricut conversion, that's exactly the kind of scrappy machine I love hearing about.

I checked, and you're right that nothing knife-related exists in Rayforge today, so the awkward loop you describe (design, export, re-parse externally, cut, repeat after every tweak) is unfortunately the only workflow available right now. That's a fair criticism, and it's the kind of thing that should live inside the app.

The good news is that one piece of your request already works today: the M3 requirement. In the machine settings under the G-code section you can create your own dialect based on Grbl, and change the "laser on" command from the default M4 S{power} to M3 S{power}. From then on Rayforge will only ever emit M3/M5, which is what a spindle-driven tool like a knife needs. That at least removes one step from your external parser.

As for the real feature, I've spent some time looking into what it would take, and the foundation is in better shape than you might expect. Rayforge recently gained 4th-axis support for rotary attachments, which means the G-code writer already knows how to emit coordinated moves with an A value. A tangential knife would build directly on that: keep A aligned with the direction of travel, and whenever a corner is sharper than your angle tolerance, lift Z, rotate, and plunge back in — exactly the radius and tolerance settings you described. The drag knife variant is the opposite trade-off: it needs no A axis at all, but it does need corner-compensation geometry (small loops at direction changes so the knife tip catches up with the shaft), which fits naturally into the geometry stage of our processing pipeline. Of the two, drag knife compensation is the simpler one and probably the more natural first step.

I won't promise a date yet — this needs a proper attachment concept in the UI alongside the rotary module, and corner-lift logic that behaves well on real machines — but I'm genuinely interested in this. Cutting, not just lasering, is a direction I'd like Rayforge to grow into, and you're right that the big commercial players have left this space untouched for years. I'll leave this open as the tracking issue; if others want this too, a thumbs-up on the first post helps me prioritize.

[brakthehun]

C-axis!! My bad. A axis is fine too,, but C-axis is technically the correct axis. It's an easy change in FluidNC either way.

[knipknap]

Implementation plan: Drag Knife & Tangential Knife support

Research findings

• Raygeo already has the exact machinery needed: the Transformer trait (src/ops/transform/), arc_to(x, y, i, j, ...) with G-code-style center offsets, per-command extra_axes with Axis::A fully emitted as degrees through dialect {extra_cmd}, and SetSpindleRpm → M3 S{rpm} (M4-free by construction). It also has established conventions for Python-based tests (tests/ops/transform/test_ops_transform_*.py) and example plot generators (tools/examples/ops_transform_*.py + python -m tools.cli doc ...).
• Rayforge addons register steps via @hookimpl register_steps(step_registry); step→head gating works through Step.REQUIRED_MACHINE_CAPS ⊆ Machine.get_capabilities(), and heads contribute capabilities via Head.machine_capability. Head types are a class hierarchy (LaserHead, SpindleHead) dispatched by HEAD_TYPE in head_from_dict.

Architecture decisions

1. Raygeo: both algorithms implemented as Transformer specs (DragKnifeSpec, TangentialKnifeSpec). Knife compensation rewrites already-generated cut paths, so the transform layer fits (phase ordering, cache keys, tests, example-plot conventions all exist). The rayforge step uses the standard contour assembler and attaches the knife transformer spec internally.
2. Rayforge: new steps (DragKnifeCutStep, TangentialKnifeCutStep) + two new head types (DragKnifeHead, TangentialKnifeHead), each with its own MachineCapability value so step offering and head pickers filter automatically.
3. M3 requirement: knife steps stamp set_spindle_rpm() (→ M3 S… / M5) instead of set_power, independent of the machine's possibly-M4 laser dialect.

Part A — Raygeo

1. src/ops/transform/drag_knife.rs — DragKnifeSpec { offset_mm, swivel_angle_deg } + impl Transformer (Phase::PostProcessing, name() == "drag_knife") + apply_drag_knife(ops, ...):
   • compute per-segment headings via Ops::to_geometry() + get_tangent_at_from_array
   • arc-in half-circle at path start (radius = blade offset) to align the blade
   • at corners within swivel tolerance: tip-pinned swivel arc (arc_to centered on the corner)
   • corners beyond tolerance: lift–pivot–plunge; arc-out past the path end
2. src/ops/transform/tangential_knife.rs — TangentialKnifeSpec { angle_tolerance_deg, radius_tolerance_mm, safe_z }: attach heading in degrees as extra_axes (Axis::A) on every cut command; when heading change exceeds angle tolerance or local radius drops below radius tolerance → insert move_to(x, y, safe_z) lift, A-rotation, plunge.
3. PyO3 bindings: src/python/ops/transform/{drag_knife,tangential_knife}.rs (following lead_in_out.rs), wired into transform::register() and extract_transformer(), plus PyOps.apply_drag_knife/apply_tangential_knife convenience methods; stubs via make stubs.
4. Python tests: tests/ops/transform/test_ops_transform_drag_knife.py, test_ops_transform_tangential_knife.py.
5. Example plot generators: tools/examples/ops_transform_drag_knife.py, ops_transform_tangential_knife.py.
6. Verify with make format && make lint && make dev && make stubs + targeted pytest, then make check.

Part B — Rayforge addon (rayforge/builtin_addons/rayforge-addon-dragknife/)

rayforge-addon-dragknife/
├── rayforge-addon.yaml        # name: dragknife, api_version: 21, requires: [post_processors]
├── dragknife/
│   ├── worker.py              # @hookimpl register_steps(step_registry)
│   ├── frontend.py            # icons + register_step_settings_pages
│   ├── knife_head_var.py      # head picker (pattern from LaserHeadVar)
│   ├── steps/
│   │   ├── drag_knife_cut_step.py       # TYPELABEL "Drag Knife Cut"
│   │   └── tangential_knife_cut_step.py # TYPELABEL "Tangential Knife Cut"
│   ├── widgets/               # ASSEMBLER_WIDGETS + settings pages
│   ├── resources/icons/
│   └── locale/
└── tests/                     # steps tests + ui_gtk page-registry tests

Step design (modeled on the CncAssemblerStep/LaserStep contract):

• REQUIRED_MACHINE_CAPS = frozenset({MachineCapability.DRAG_KNIFE}) / {TANGENTIAL_KNIFE} → automatic add-step-menu filtering
• build_compute_payload() returns the contour assembler; the knife transformer spec is attached as a per-step transformer, applied post-assembly by the pipeline
• Settings: cut speed, blade offset, swivel angle (drag knife); cut speed, angle tolerance, radius tolerance, safe Z (tangential); spindle RPM for blade-down

Part C — Rayforge core touchpoints

1. core/capability.py: new DRAG_KNIFE, TANGENTIAL_KNIFE capabilities (+ labels/descriptions)
2. machine/models/: DragKnifeHead, TangentialKnifeHead head classes
3. machine/models/head.py: extend head_from_dict dispatch (else knife heads deserialize as LaserHead)
4. ui_gtk/machine/head_preferences_page.py: add-head popover entries + detail widgets; setup wizard choices
5. pipeline/encoder/rust_helpers.py::_build_heads: verify non-laser heads don't break encoding (knife steps emit no SetPower)

Risks / open items

• Drag knife must run after path reordering (optimize) — enforced via Phase::PostProcessing, verified against intent_builder phase sorting
• Swivel "nick" geometry and lift-vs-swivel thresholds need physical tuning; parameters are user-exposed
• GRBL dialect templates already contain {extra_cmd}; non-GRBL dialects go through PythonEncoder — verify A-axis survives there