---
title: "Fanuc Robot Teach Pendant vs Standard G-Code Compared"
description: "Fanuc robots run point-taught TP programs; CNC machines run coordinate-explicit G-code. The concepts map cleanly: frames are offsets, points are positions."
url: https://gcodepractice.com/journal/fanuc-robot-teach-pendant-vs-standard-g-code/
canonical: https://gcodepractice.com/journal/fanuc-robot-teach-pendant-vs-standard-g-code/
author: "Lawrence Arya"
authorUrl: https://www.linkedin.com/in/vibecoding/
published: 2026-06-04
updated: 2026-06-04
category: "Code reference"
tags: ["fanuc", "robot", "teach-pendant", "comparison"]
lang: en
---

# Fanuc Robot Teach Pendant vs Standard G-Code Compared

> **TL;DR** A Fanuc robot is programmed through its teach pendant in TP language: motion lines reference taught points (J P[1] 100% FINE), positions captured by jogging the robot there, with user frames and tool center points doing the locating. CNC G-code declares coordinates explicitly in text. The paradigms differ, taught poses versus computed positions, but the concepts map: user frames are work offsets, TCP setup is tool-length offsetting, and CNT blending is path smoothing.

Plants increasingly put machinists next to [industrial robots](https://en.wikipedia.org/wiki/Industrial_robot) and robot techs next to machining centers, and both groups discover the other's programming looks alien: a Fanuc teach pendant full of `J P[1] 100% FINE` lines on one side, [G-code text](https://en.wikipedia.org/wiki/G-code) on the other. The alienness is mostly costume. Underneath, the two worlds solve the same locating and motion problems with mappable concepts.

## How does teach pendant programming actually work?

A Fanuc TP program is a list of motion instructions referencing **taught points**. The programmer jogs the robot to a position, records it into `P[1]`, and the program line says how to travel there:

```
J P[1] 100% FINE
L P[2] 500mm/sec CNT100
C P[3] P[4] 300mm/sec FINE
```

`J` moves in joint space, `L` linearly, `C` circularly; the percentage or speed sets pace; `FINE` stops exactly at the point while `CNT` blends through it. Logic, registers, and I/O wrap around the motion lines, with KAREL available beneath for heavier programming. The deep difference from machining: a robot point is a **pose**, position plus orientation of the tool, six degrees of freedom captured by being there rather than computed from a print.

## What does the concept map look like?

| Robot (Fanuc TP) | CNC G-code | Same idea |
| --- | --- | --- |
| `P[n]` taught points | `X Y Z` coordinate words | Where to go |
| `J` / `L` / `C` motion | `G00` / `G01` / `G02`-`G03` | How to travel |
| User frame | `G54` work offset | Locating the work |
| Tool center point (TCP) | `G43` tool length offset | Locating the tool |
| `FINE` / `CNT` | Exact stop / path blending | Corner behavior |
| Speed override, step mode | Feed override, single block | Prove-out controls |

The locating rows are the revelation for anyone crossing over: a user frame is [a work offset](/journal/g54-work-offsets-explained/) wearing robot clothes, the same measure-the-fixture-once idea, and TCP calibration is the tool-offset problem with orientation added. Prove-out culture transfers wholesale: step through slow, watch the first cycle, keep a hand near stop.

## Why do the worlds keep separate languages?

Because the machines' geometries diverge. A [CNC machine](https://en.wikipedia.org/wiki/Numerical_control) is a rigid Cartesian frame where X50. means one knowable place, so text coordinates work perfectly. A six-axis arm reaches most points in many joint configurations, suffers singularities, and cares about orientation everywhere, which makes taught poses and joint-space thinking the natural idiom. Robot machining cells split the difference in the CAM stage: paths are computed from CAD like any toolpath, then posted to the robot's language rather than to G-code, with only niche add-ons interpreting G-code directly on robot controllers; the same posting-not-converting logic governs [KUKA's KRL world](/journal/kuka-krl-to-standard-g-code-conversion/).

A concrete crossover pattern: a machinist moved to tending a robot-loaded lathe cell learned the pendant in a week of supervised jogging because, in her words, the frames were just offsets and step mode was single block. The reverse crossing runs the same road: a robot integrator picking up [program-reading skill](/journal/how-to-read-a-cnc-program-for-beginners/) for the machine side of the cell finds the coordinates refreshingly honest, one place per number, no configurations to choose.

## Which skill should cell-adjacent people build?

Both, shallowly before deeply. Cells fail at the interfaces, the robot waiting on a machine signal, the machine holding a door for a robot, and the person who reads both sides' programs at even a basic level diagnoses interface problems the specialists each see half of. The robot half is learned at the pendant under supervision; the CNC half is a compact vocabulary, drillable in spare minutes on the [G-code practice hub](/g-code-practice/), and the payoff is the same on both sides: machines stop being black boxes the moment their language stops being one.

## Bottom line

Teach pendant programming moves through taught poses, J, L, and C lines referencing recorded points, while G-code declares coordinates in text; user frames map to work offsets, TCP to tool offsets, CNT to path blending, and prove-out culture transfers untouched. Different languages, shared concepts, and the crossing in either direction is weeks of vocabulary, not a new career.

## Sources

- [Wikipedia: Industrial robot](https://en.wikipedia.org/wiki/Industrial_robot)
- [Wikipedia: G-code](https://en.wikipedia.org/wiki/G-code)
- [Wikipedia: Numerical control](https://en.wikipedia.org/wiki/Numerical_control)

## Frequently asked questions

### What is the difference between a Fanuc teach pendant program and G-code?
TP lines reference taught points captured by jogging the robot there, each carrying full pose; G-code declares coordinates in text computed from a drawing. Motion types map (`J`/`L`/`C` to rapids, lines, arcs) but the unit of motion differs.

### Do industrial robots run G-code?
Not natively as a rule: Fanuc robots run TP with KAREL beneath, and robot machining gets paths via CAM posts to the robot's language. G-code interpreters exist only as add-ons.

### What transfers between CNC G-code skill and robot programming?
The locating concepts (frames as offsets, TCP as tool offsets), corner behavior (CNT as blending), and the entire prove-out safety culture.

### What is the best way to learn G-code if you come from robots, or robots from G-code?
Map concepts to the other side's names, then drill vocabulary. A free app like G-Code Sprint covers the CNC half, quizzing the everyday codes and repeating whichever ones you miss.

*G-Code Sprint is a study and practice tool only. Always follow your instructor, employer, machine manual, and shop safety procedures.*

---

Source: https://gcodepractice.com/journal/fanuc-robot-teach-pendant-vs-standard-g-code/
Author: Lawrence Arya — https://www.linkedin.com/in/vibecoding/