---
title: "Shapeoko Carbide Create G-code List: The Codes You Will See"
description: "The Shapeoko runs GRBL, and Carbide Create generates a compact G-code set: G0, G1, arcs, and M3 to M5 for the router. Here is the list and how to read it."
url: https://gcodepractice.com/journal/shapeoko-carbide-create-g-code-list/
canonical: https://gcodepractice.com/journal/shapeoko-carbide-create-g-code-list/
author: "Lawrence Arya"
authorUrl: https://www.linkedin.com/in/vibecoding/
published: 2026-06-08
updated: 2026-06-08
category: "Code reference"
tags: ["shapeoko", "carbide create", "grbl", "g-code"]
lang: en
---

# Shapeoko Carbide Create G-code List: The Codes You Will See

> **TL;DR** The Shapeoko runs GRBL firmware, and Carbide Create generates a compact G-code set for it: G0 rapids, G1 feed moves, G2 and G3 arcs, G20 or G21 units, work coordinates, and M3 to M5 to control the router or spindle. GRBL supports a subset of full G-code, so the list is short and learnable. Read the file in blocks and confirm the zero and units before you cut.

The Shapeoko is one of the most popular desktop CNC routers, and like any CNC it runs on G-code. What makes its code approachable is that the Shapeoko uses GRBL firmware, which supports a deliberately compact subset of G-code, and Carbide Create, the companion software, generates that code for you. So the list of codes you actually encounter on a Shapeoko is short, which is good news: you can learn to read the whole vocabulary your machine uses, and reading it is what lets you catch a problem before it ruins a workpiece.

This guide lists the G and M codes you will see in Carbide Create output, explains what each does, and shows how to read a Shapeoko program in blocks. You do not need to write the code by hand, because Carbide Create writes it, but being able to read it is the skill that keeps you in control of the cut.

## How the Shapeoko makes G-code

The workflow is straightforward. In Carbide Create you draw or import your design and set toolpaths, then it generates a G-code file. You load that file in Carbide Motion, the control software, which streams it to the Shapeoko. The machine itself runs [GRBL](https://en.wikipedia.org/wiki/G-code), an open firmware that interprets a focused subset of standard G-code. Because GRBL targets small routers, it leaves out the canned cycles and advanced features of industrial controls and keeps the essentials.

The Shapeoko is also a common choice for [shop class CNC router projects](/journal/shop-class-cnc-router-project-codes), precisely because its short code list suits beginners. That subset is why a Shapeoko program looks cleaner and shorter than industrial code. The [Carbide 3D documentation](https://docs.carbide3d.com/) covers the software side, and the [Carbide 3D site](https://carbide3d.com/) describes the machines, but the file itself is plain G-code you can read once you know the short list.

## The G-code list for Carbide Create and GRBL

Here are the codes you will see most in a Shapeoko program.

| Code | Meaning | Notes |
| --- | --- | --- |
| G0 | Rapid move | Positioning without cutting |
| G1 | Feed move | Cutting move with an F feedrate |
| G2 / G3 | Clockwise / counterclockwise arc | Curved cuts |
| G17 | XY plane | The router default |
| G20 / G21 | Inch / millimeter units | Set per project |
| G90 / G91 | Absolute / incremental | Usually absolute |
| G54 | Work coordinate system | The job zero |
| M3 / M4 / M5 | Spindle or router on / on reverse / off | Router control |
| M0 / M2 | Program pause / end | Stops and ends |

A few things stand out. The codes are written G0 and G1 rather than G00 and G01, a GRBL style that means the same thing. The router control uses M3 and M5 like a spindle, even though many Shapeoko users run a trim router rather than a controlled spindle, in which case M3 and M5 may control a relay or simply mark where the router should be on. A general reference such as the [CNCCookbook code list](https://www.cnccookbook.com/g-code-m-code-reference-list-cnc-mills/) explains any standard code, though GRBL implements only the subset above plus a handful more.

## Read a Shapeoko program in blocks

A Carbide Create file reads best in blocks, like any G-code. The top sets units and the work coordinate system and moves to a safe height. The router turns on with M3. Then the cutting section repeats G0 rapids to position and G1 feed moves, with G2 and G3 for curves, following the toolpath. At the end the router stops with M5 and the program ends. Reading it as setup, cut, and finish turns a long file into a few repeating sections, the same approach that works when you [read a Snapmaker CNC file](/journal/snapmaker-2-0-cnc-g-code-guide) or any other machine's output.

Understanding [how the machine reads the program](/journal/how-does-a-cnc-machine-read-code-step-by-step) step by step makes this clearer, because it shows why the order of the blocks and the modal state matter.

## What to confirm before you cut

On a desktop router, two settings cause most trouble, and reading the file helps confirm both. First, the job zero: Carbide Create sets where X, Y, and Z zero sit on your stock, and you must set the same zero on the machine in Carbide Motion, or the cut lands in the wrong place. Second, the units: confirm G20 for inch or G21 for millimeter matches your project, since a mismatch scales every move. The most common beginner failure, the router cutting air above the stock, almost always traces back to the Z zero, which the dedicated guide on [why a CNC router cuts air](/journal/why-does-my-cnc-router-cut-air) covers in detail.

## A sample program, read in plain language

To make the list concrete, here is how the opening of a typical Carbide Create file reads.

| Line | What it means |
| --- | --- |
| G90 | Absolute coordinates |
| G21 | Millimeter units |
| G0 Z5 | Rapid to a safe height |
| M3 S10000 | Router on, speed reference |
| G0 X0 Y0 | Rapid to the start position |
| G1 Z-1 F500 | Feed down 1 mm at 500 mm per minute |
| G1 X30 F1000 | Cut a straight line at the cutting feed |
| G0 Z5 | Rapid retract |
| M5 | Router off |

Reading those nine lines confirms the units, the safe approach, the router state, and the first cut, which is most of what you need to verify before pressing start. The safe Z move before the router starts and again before repositioning is the kind of detail you learn to look for.

## Why GRBL keeps the list short

It helps to understand why the Shapeoko's code is so compact. GRBL runs on a small microcontroller and is built for hobby routers, so it implements the motion and basic control codes and skips the canned cycles, probing macros, and advanced features of industrial controls. That is a feature for a learner, not a limitation: the entire vocabulary your machine uses fits on a small card, so there is no excuse not to learn all of it. If you later move to an industrial control, the core motion codes transfer directly, and you add the extras then.

Other controls keep their own conventions in the opposite way; a conversational control such as the one behind the [common ProtoTRAK M-codes](/journal/common-m-codes-for-xyz-protrak) hides the codes behind prompts rather than exposing a short list. The trade with GRBL is that some things an industrial machine does in one canned cycle, GRBL does with explicit moves that Carbide Create writes out. So a Shapeoko drilling program, for example, shows the up-and-down moves rather than a single G81 cycle. Reading those explicit moves is actually good practice, because it shows you exactly what the machine is doing rather than hiding it inside a single cycle code. A beginner who learns on a Shapeoko therefore sees the bare mechanics of every operation, which is a genuine head start when they later read the more compressed code an industrial control produces.

## Carbide Create, Carbide Motion, and GRBL: who does what

It helps to be clear on the three pieces, because beginners often blur them. Carbide Create is the design and toolpath software where you make the part and generate the G-code file. Carbide Motion is the control program on your computer that loads that file, lets you set the zero, and streams the code to the machine. GRBL is the firmware on the Shapeoko's controller that actually interprets each line and moves the motors. So the code is created in Carbide Create, sent by Carbide Motion, and executed by GRBL. Knowing which piece does what makes troubleshooting far easier: a toolpath problem lives in Carbide Create, a zero or connection problem lives in Carbide Motion, and how a code is interpreted is GRBL's job. The G-code file is the common thread that passes between all three.

## Setting the work zero on a Shapeoko

Because the zero causes most desktop-router trouble, it deserves a clear routine. In Carbide Motion you jog the machine to where you want X, Y, and Z zero on your stock and set it there, and that must match the zero you chose in Carbide Create. Many users set XY zero at a corner of the stock and Z zero at the top surface. A probe such as Carbide 3D's BitZero automates this by touching the tool to a reference, which removes a lot of guesswork, but the principle is the same: the machine has to know where the stock is. If the Z zero is set while the bit floats above the surface, the cut will be too shallow or cut air; if it is set too low, the bit plunges into the wishboard. Confirming the zero every time is the single habit that prevents the most common ruined cuts.

## The skill behind reading any of it

Whether the code comes from Carbide Create, Fusion, or anything else, the skill that keeps you in control is reading it. On the Shapeoko the list is short, the codes G0, G1, G2, G3, M3, and M5 covering most of it, so it is an ideal place to build that fluency. When you can read those at a glance, you stop trusting the file blindly and start verifying it, which prevents wasted material and broken bits.

That recognition is recall, built by short practice. The free G-Code Sprint app at GCodePractice.com runs 60-second rounds on the common G and M codes and repeats whatever you miss, so the codes in your Shapeoko files become instantly readable. It is an educational practice tool for building that fluency, not a machine controller and not a replacement for Carbide Motion, so always set up and prove your cut carefully on the machine. Learn the short list, read every file in blocks, and the Shapeoko stops feeling like a black box.

## Frequently asked questions

### What G-code does the Shapeoko use?

The Shapeoko runs GRBL firmware, which supports a compact subset of G-code, and Carbide Create generates it. You will see G0 for rapids, G1 for feed moves, G2 and G3 for arcs, G20 or G21 for units, G54 for the work zero, and M3 to M5 for the router, plus M0 and M2 for pause and end. To read those codes fluently, the free G-Code Sprint app at GCodePractice.com drills the common G and M codes in 60-second recall rounds.

### Does Carbide Create output standard G-code?

Yes, it outputs standard G-code in the GRBL subset, written in a GRBL style such as G0 and G1 rather than G00 and G01. The codes mean the same as on any machine; GRBL simply implements a focused set aimed at desktop routers.

### How do you read a Shapeoko G-code file?

Read it in blocks: the top sets units and the work coordinate system and moves to a safe height, the router starts with M3, the middle repeats G0 rapids and G1 cutting moves with G2 and G3 arcs, and the end stops the router with M5. Confirm the job zero and units before cutting.

### Why does my Shapeoko cut in the wrong place or cut air?

Almost always the job zero is set wrong, especially the Z zero. The zero in Carbide Create must match what you set in Carbide Motion on the machine, and the Z zero is usually the top of the stock. Reading the program and confirming the setup prevents most of these problems.

### Does GRBL support all G-codes?

No. GRBL implements a subset focused on motion and basic control, leaving out canned cycles and advanced features found on industrial controls. That keeps the Shapeoko's code short and learnable, and the core motion codes transfer if you move to a bigger machine later.

### Do I need to know G-code to use the Shapeoko?

You do not need to write it, since Carbide Create generates it, but you should read it well enough to confirm the zero, the units, and the depths before cutting. Because GRBL's list is short, learning to read all of it is realistic and prevents most wasted material.

---

Source: https://gcodepractice.com/journal/shapeoko-carbide-create-g-code-list/
Author: Lawrence Arya — https://www.linkedin.com/in/vibecoding/