---
title: "VMC Machine Setting and Programming Basics, Start to First Part"
description: "Running a VMC is two skills in sequence: setting (workholding, tools, offsets) and programming (the code that uses them). The basics of each, in order."
url: https://gcodepractice.com/journal/vmc-machine-setting-and-programming-basics/
canonical: https://gcodepractice.com/journal/vmc-machine-setting-and-programming-basics/
author: "Lawrence Arya"
authorUrl: https://www.linkedin.com/in/vibecoding/
published: 2026-06-07
updated: 2026-06-07
category: "Guides"
tags: ["vmc", "setting", "programming basics", "setup"]
lang: en
---

# VMC Machine Setting and Programming Basics, Start to First Part

> **TL;DR** Producing a part on a vertical machining center is two skills in sequence. Setting prepares the physical world: workholding (vise or fixture, trammed and square), tools assembled and measured, work offset established by touch-off, tool length offsets entered. Programming then acts in that prepared world: the standard core of motion, planes, units, the work and tool offset calls, canned cycles for holes, and a safe start and end. The order is fixed, setting before programming proves out, because the program assumes the setup it was written for. Learn the code core to fluency, learn the setting steps in sequence, and the first good part is the meeting of the two.

A vertical machining center makes a part in two acts. Setting prepares the world, the workholding, the tools, the offsets, the physical reality the program will assume, and programming acts in that world, the code that moves the prepared tools through the prepared part. The two are separate skills, they happen in a fixed order, and a good first part is simply the moment they meet correctly. Learning a VMC means learning both, in sequence.

The split matters because beginners often try to learn them as one blurred topic and stall, unsure whether a problem is a setup mistake or a program mistake. Keeping them mentally separate is itself a diagnostic tool: when the first part comes out wrong, you ask which act failed, did the setup not match what the program assumed, or did the program not say what the print required, and the answer points at one half or the other instead of a vague everything. Most first-part failures are setup-side, a touch-off off by the paper thickness, a vise a few thousandths out of tram, precisely because the program is the same proven text while the setup is freshly built each time.

## Act one: setting

Setting is the physical half, and the program trusts every value it produces:

| Setting step | What it establishes | Why the program needs it |
| --- | --- | --- |
| Workholding | A trammed, square, secure part | The program's coordinates assume this position |
| Tools assembled and measured | Known tools in known pockets | The T and offset calls name them |
| Work offset by touch-off | Where part zero is in machine space | G54 points the program at the part |
| Tool length offsets entered | Each tool's reach | G43 H makes Z correct per tool |

The [milling machine](https://en.wikipedia.org/wiki/Milling_machine) is unforgiving about setup quality: a vise out of tram, a part not square, an offset off by the touch-off error, and a flawless program makes scrap, because the program cannot know the setup is wrong, it just executes against the values you entered. This is why setting is its own discipline, the [work-offset-and-touch-off workflow](/journal/how-to-set-work-zero-on-a-cnc-vs-3d-printer/) plus tool measurement that lands values on the [offset page](/journal/how-to-manually-enter-a-tool-offset-in-g-code/), and why a setter's pay reflects owning it.

## Act two: programming

Programming acts in the prepared world with the standard mill core. A VMC program's basics, documented in any [G-code reference](https://linuxcnc.org/docs/html/gcode/g-code.html), are: motion (G00-G03), plane and units (G17, G20/G21), distance modes (G90/G91), the offset calls that connect code to setup ([G54](/journal/g54-work-offsets-explained/) and [G43 H](/journal/g43-tool-length-offset-explained/)), the [drilling cycles](/journal/g81-vs-g83-drilling-canned-cycles/) for hole work, [cutter compensation](/journal/g41-vs-g42-cutter-compensation/) where features need it, and a safe start (establishing modes explicitly) and end (retract, spindle off, program end). That core covers the large majority of VMC programs; the part's print decides which pieces a given job uses, which is where [blueprint reading meets programming](/journal/interactive-cnc-blueprint-reading-and-programming/).

## The fixed order, and why

Set first, then prove the program. The order is not preference, it is logic: the program was written assuming a specific setup, work offset here, this tool in that pocket, these lengths, so the setup must exist and be correct before the program is meaningful. Proving a program against a wrong or absent setup tests nothing useful and risks a crash, which is why the [prove-out](/journal/how-to-safely-restart-a-cnc-program-from-the-middle/) always follows the setup, single block, conservative overrides, the first part watched. The two acts in their order are the whole job: a prepared world, then correct action in it.

## Learning both

The efficient path splits by where each skill is learnable. The code core transfers and studies anywhere, so build it first to fluency, the free 60-second rounds on the [G-code practice page](/g-code-practice/) drill exactly the mill core above, and arrive at the machine able to read what you will run. Setting is physical and supervised, so learn it hands-on in sequence, on real iron with someone who knows the machine. The two together, code fluency plus setting judgment, in the production order, are [machining](https://en.wikipedia.org/wiki/Machining) on a VMC reduced to its basics: prepare the world, then act in it, and the first good part proves you did both.

## Sources

- [LinuxCNC: G-code reference](https://linuxcnc.org/docs/html/gcode/g-code.html)
- [Wikipedia: Milling machine](https://en.wikipedia.org/wiki/Milling_machine)
- [Wikipedia: Machining](https://en.wikipedia.org/wiki/Machining)

## Frequently asked questions

### What are the basics of VMC setting and programming?

Two skills in sequence. Setting prepares the physical world: workholding trammed and square, tools assembled and measured, work offset by touch-off, tool length offsets entered. Programming acts in it: the motion-plane-unit core, the G54 and G43 H offset calls, drilling cycles, and a safe start and end. Setting comes first.

### What does setting up a VMC involve?

Mounting and truing workholding, assembling and measuring tools, establishing the work offset by touch-off, and entering each tool's length offset. Its quality determines whether a perfect program makes a good part or scrap, because the program trusts every setup value.

### What programming basics does a VMC need?

The standard mill core: motion, plane, units, distance modes, the G54 and G43 H offset calls, the G81-G83 drilling cycles, cutter comp where needed, and a safe start and end. The part's print decides which pieces a job uses.

### Should I learn VMC setting or programming first?

Learn the code core first (it transfers and studies anywhere), then setting on the machine (it is physical and supervised), and run them in production order: set first, then prove the program. The free G-Code Sprint app builds the code core.

---

Source: https://gcodepractice.com/journal/vmc-machine-setting-and-programming-basics/
Author: Lawrence Arya — https://www.linkedin.com/in/vibecoding/