---
title: "Tormach PathPilot vs Fanuc G-Code Differences, Mapped"
description: "PathPilot runs a LinuxCNC-shaped dialect, so vs Fanuc it differs the way LinuxCNC does: shared core, dot-one extensions, G7 lathe diameter mode, structure layer."
url: https://gcodepractice.com/journal/tormach-pathpilot-vs-fanuc-g-code-differences/
canonical: https://gcodepractice.com/journal/tormach-pathpilot-vs-fanuc-g-code-differences/
author: "Lawrence Arya"
authorUrl: https://www.linkedin.com/in/vibecoding/
published: 2026-06-07
updated: 2026-06-07
category: "Code reference"
tags: ["tormach", "pathpilot", "fanuc", "linuxcnc"]
lang: en
---

# Tormach PathPilot vs Fanuc G-Code Differences, Mapped

> **TL;DR** Tormach's PathPilot is built on LinuxCNC, so its G-code differences versus Fanuc are essentially LinuxCNC's differences: the standard core (motion, planes, units, offsets, compensation, common cycles) reads the same, and the divergences are the LinuxCNC-shaped ones, dot-one extensions (G28.1, G33.1, G61.1, G90.1), O-word subroutines instead of Macro B, G7/G8 diameter and radius modes on the lathe rather than a Fanuc parameter, and per-dialect cycle details. Tormach publishes its supported codes, so the authoritative list is theirs, and a Fanuc-trained machinist reads PathPilot's core immediately and meets the LinuxCNC-family edges as the learning.

The single fact that answers most PathPilot-versus-Fanuc questions is genealogical: [PathPilot is built on LinuxCNC](https://linuxcnc.org/docs/html/gcode/g-code.html), with Tormach's interface and workflow layered on top. So its differences from [Fanuc](https://en.wikipedia.org/wiki/FANUC) are, with small exceptions, LinuxCNC's differences from Fanuc, which means the [LinuxCNC-versus-Fanuc map](/journal/linuxcnc-g-code-differences-vs-fanuc/) carries most of the answer, and the rest is what Tormach added on top.

## Why the lineage is the answer

It is worth dwelling on why building on LinuxCNC settles the dialect question so completely. A control's G-code behavior is not a thin surface choice; it is the interpreter, the cycle implementations, the modal-state handling, the extension set, thousands of decisions that a builder either makes from scratch or inherits. Tormach inherited them from LinuxCNC and spent its engineering on the layer customers actually wanted improved: the interface, the workflow, the machine integration. So predicting PathPilot's response to any G-code question starts with how does LinuxCNC do this, and ends with a check against Tormach's published list for the few places Tormach customized, which is a far shorter investigation than reverse-engineering a proprietary control from behavior.

## The shared core, then the family edges

Motion, planes, units, distance modes, the offset family, compensation, the common cycles: identical to Fanuc in reading and writing, the standard core every control shares. A Fanuc-trained machinist reads a PathPilot program's body on first contact, and the divergences arrive exactly where LinuxCNC's do:

| Layer | Fanuc | PathPilot (LinuxCNC-based) |
| --- | --- | --- |
| Rigid tapping | M29 with G84 | G33.1 |
| Subprograms and logic | Macro B, M98/M99 | O-word subroutines |
| Lathe diameter/radius | Parameter-set | G7 diameter, G8 radius as codes |
| Reference setting | Parameter-side | G28.1 and the dot-one family |
| Supported-codes authority | The control's manual | Tormach's published reference |

The lathe row is the one PathPilot users meet earliest: the [G7 diameter convention](/journal/lathe-g-code-x-radius-vs-diameter-programming/) appears as an explicit code rather than the buried Fanuc parameter, which the [PathPilot supported-list walkthrough](/journal/pathpilot-g-code-supported-list/) covers in full. The rigid-tapping and subroutine rows are the [standard LinuxCNC-family spellings](/journal/m29-rigid-tap-fanuc-setup-code/), same jobs, different codes, rebuilt rather than translated when porting.

## What Tormach added on top

The LinuxCNC lineage predicts the dialect; Tormach's contribution is the experience around it: the PathPilot interface, the conversational and workflow features, the integration with Tormach's machines, and crucially a [published supported-codes reference](https://tormach.com/machine-codes/supported-g-codes-reference) that makes the dialect's edges authoritative rather than inferred. That publication is the practical authority for any specific code, the same vendor-documentation virtue that makes [Tormach's lists the reference pattern](/journal/pathpilot-g-code-supported-list/) for the prosumer tier: where most controls leave you inferring, Tormach states it.

## Porting and learning

Program porting follows the LinuxCNC-family rules exactly: core-only Fanuc programs run with normal care, while Macro B logic, Fanuc cycle parameters, and M29/G84 tapping get rebuilt into O-words, documented PathPilot cycles, and G33.1 respectively, and the reverse holds, PathPilot's O-words and dot-one codes mean nothing to a Fanuc. Portable programs stay in the shared core, the [inherited-program discipline](/journal/does-uccnc-use-standard-g-code/) the whole family teaches.

For learning, the Tormach is a genuinely good classroom: the core it runs is the standard core that transfers everywhere, its edges are published rather than mysterious, and a Fanuc-bound owner builds the right fluency from day one. The free 60-second rounds on the [G-code practice page](/g-code-practice/) drill that shared core, and the LinuxCNC lineage gives a Tormach owner a second free resource, LinuxCNC's public documentation, that describes their machine's dialect more deeply than most vendors document their own. Learn the core, read Tormach's list once, and the Fanuc differences become a short, known list rather than a wall.

## Sources

- [Tormach: supported G-codes reference](https://tormach.com/machine-codes/supported-g-codes-reference)
- [LinuxCNC: G-code reference](https://linuxcnc.org/docs/html/gcode/g-code.html)
- [Wikipedia: FANUC](https://en.wikipedia.org/wiki/FANUC)

## Frequently asked questions

### How does Tormach PathPilot G-code differ from Fanuc?

Mostly the way LinuxCNC differs, because PathPilot is built on LinuxCNC: the standard core reads the same, and the divergences are the LinuxCNC-family ones, dot-one extensions, O-words instead of Macro B, G7/G8 lathe modes, and per-dialect cycle details. Tormach publishes its supported list as the authority.

### Is PathPilot really LinuxCNC?

It is built on LinuxCNC with Tormach's interface and workflow on top, so the underlying dialect is LinuxCNC-shaped while the experience is Tormach's. That lineage predicts most of its G-code behavior.

### Will Fanuc programs run on a Tormach?

Core-only programs largely, with LinuxCNC-family porting care: Macro B logic, Fanuc cycle parameters, and M29/G84 tapping get rebuilt into O-words, documented cycles, and G33.1. Portable programs stay in the shared core.

### Is a Tormach a good machine to learn G-code that transfers?

Yes: the core transfers everywhere, and PathPilot's published list plus its LinuxCNC lineage make its edges well-documented. The free G-Code Sprint app drills the shared core that reads on Fanuc iron later.

---

Source: https://gcodepractice.com/journal/tormach-pathpilot-vs-fanuc-g-code-differences/
Author: Lawrence Arya — https://www.linkedin.com/in/vibecoding/