---
title: "Engraving Text in G-Code: Fonts, Depth, and Feeds"
description: "Crisp engraving is decided before the code runs: single-line fonts, V-bit depth-width coupling, blending settings, and reviewing generated toolpaths."
url: https://gcodepractice.com/journal/engraving-text-g-code-basics/
canonical: https://gcodepractice.com/journal/engraving-text-g-code-basics/
author: "Lawrence Arya"
authorUrl: https://www.linkedin.com/in/vibecoding/
published: 2026-08-20
updated: 2026-08-20
category: "Guides"
tags: ["engraving", "fonts", "v-bit", "g-code", "router", "marking"]
lang: en
---

# Engraving Text in G-Code: Fonts, Depth, and Feeds

> **TL;DR** Engraved text quality is set by three inputs: a single-line stroke font (outline fonts double-trace every stroke into mush at small sizes), a V-bit or fine engraver whose line width couples directly to depth, and a shallow depth cut on a surface flat enough to keep that width constant. In the machine, tighten path blending for crisp corners and respect the planner on segment-dense text. Generate code from an engraving-aware tool, check for mirroring on mold work, and test-cut at the stock edge first.

Engraving text in G-code comes down to three decisions made before any code exists: the font, which must be a single-line stroke font rather than an outline font for small text; the tool, usually a V-bit or fine engraving cutter whose tip geometry sets the line width at a given depth; and the depth, typically a few thousandths to a hundredth of an inch, controlled tightly because a V-tool's line width grows with every extra thousandth of plunge. The G-code itself is unglamorous: a long series of short G01 moves, one pen-stroke per letter segment, with retracts between characters. What separates crisp engraving from melted-looking text is rarely the code and almost always those three inputs plus two machine settings, path blending tolerance and feed, tuned for the tiny geometry that lettering is.

## Stroke fonts versus outline fonts: the decision that decides everything

Every ordinary computer font, the ones in documents and on the web, is an outline font: each letter is a closed shape with an inside, designed to be filled with ink or pixels. Hand an outline font to a toolpath generator and it does the only honest thing: traces the boundary of each letter, producing double lines around every stroke, and for filled text, hatching between them. At sign-sized letters that can look fine. At the small text sizes most engraving lives at, part numbers, serials, labels, the double-traced boundary of a 3 mm letter turns into overlapping cuts and mush.

Stroke fonts, also called single-line or engraving fonts, define each letter as the path a pen would draw: an A is three strokes, an O one loop, with no inside or outside. One pass of the tool per stroke, and the letter is done. The classic public collection is the [Hershey fonts](https://en.wikipedia.org/wiki/Hershey_fonts), digitized in the 1960s for exactly this kind of vector drawing and still shipped in CNC and CAM software today because the problem they solve has not changed. CAM engraving modules, dedicated engraving programs, and most router UIs offer them under names like single-line, stick, or engraving fonts; choosing one is the single largest quality decision in the whole job, and using an outline font at small sizes is the mistake behind most first-attempt disappointments.

The engraving tradition these fonts serve, cutting legible marks into hard material with a pointed tool, is far older than CNC, as the [history of engraving](https://en.wikipedia.org/wiki/Engraving) shows; the machine changed the motive power, not the geometry of the problem.

## Tool and depth: where line width actually comes from

With a V-point tool, the engraved line's width is not a property of the tool alone but of the tool-depth pair: a 60-degree V cutting 0.005 inch deep leaves a line about 0.006 inch wide, the same tool at 0.010 deep leaves double that, and a 90-degree V widens faster still. That coupling is the fundamental equation of engraving practice, and it has two faces. It is the mechanism of ruin, since a few thousandths of extra depth from an unlevel part visibly fattens the lettering mid-word; and it is a design dial, since choosing depth sets stroke weight deliberately.

| Tool | Typical use | Line width behavior |
| --- | --- | --- |
| 60° V-bit | General small text in metal and plastic | Width ≈ 1.15 x depth; fine, sensitive to depth error |
| 90° V-bit | Larger text, wood signs | Width = 2 x depth; bolder, very depth-sensitive |
| 0.010-0.030 in ball or flat engraver | Uniform-width lines, panels | Width fixed by tool, depth-insensitive |
| Drag engraver (spring-loaded diamond) | Metal marking without spindle | Hairline width, surface finish marking |

Depth control at the few-thousandths scale is a flatness problem before it is a programming problem. Across a nameplate, 0.005 inch of part tilt is the difference between hairline and bold, so engraving work leans on surface-aware tactics: facing the blank in the same setup, probing a grid and letting software tilt the toolpath on capable systems, or using spring-loaded drag engravers and floating heads that follow the surface mechanically, which is how the drag-engraving world sidesteps the problem entirely. For spindle engraving on a machine you trust, the practical sequence is simple: face or indicate the surface, touch off carefully at the engraving location itself, and cut a test line at the edge of the stock before committing to the text; the [work offset discipline](/journal/g54-work-offsets-explained/) is the same as any precision job, just with tighter stakes per thousandth.

## What the G-code looks like, and the two settings that shape it

An engraving program is thousands of tiny moves. Each character becomes a handful of strokes; each stroke is a rapid to its start, a plunge to depth, a chain of short G01 segments, and a retract; curves in letters arrive as either many small lines or, from better generators, [G02/G03 arcs](/journal/g02-vs-g03/). A fragment engraving a letter V at 0.005 deep makes the shape concrete:

```
G00 X0.520 Y0.900 (start of stroke)
G01 Z-0.005 F3.0 (plunge)
G01 X0.560 Y0.700 F8.0 (down-stroke)
G01 X0.600 Y0.900 (up-stroke)
G00 Z0.050 (retract, next character)
```

Multiply by every stroke of every letter and the program's character emerges: dense, short-segment, retract-heavy. That geometry is exactly the workload where two machine behaviors dominate the result. Path blending decides whether letter corners stay crisp: a loose blending tolerance rounds the sharp junctions that make text legible, so engraving wants a tight tolerance or exact-stop behavior on the critical strokes, the [G61/G64 territory](/journal/g09-g61-g64-exact-stop-and-path-smoothing/) applied at its smallest scale. And short segments at speed are precisely the diet that starves a slow planner, so engraving on older controls or streamed links stutters unless segment density, feed, and the machine's [look-ahead capability](/journal/what-is-block-look-ahead-why-cnc-pauses-between-moves/) are matched. Text that comes out melted usually means blending too loose; text whose machine crawled and burned usually means feed and segment density beyond the planner.

Feeds and speeds for engraving run counter to intuition: tiny tools want high RPM, the fragile V-tip wants modest chip loads, and depths are so shallow that cutting forces are trivial, so the limiting factors are tip strength and planner behavior rather than horsepower. Typical practice lands at maximum available spindle speed for small V-bits with feeds tuned by test cut, and plunges gentled to protect the tip, because a V-point's failure mode is chipping at the apex, invisible until every subsequent line cuts wide and torn.

## Generating the code: from text string to toolpath

Nobody types engraving programs by hand beyond a test line; the code comes from a generator, and the choices are tiered. CAM engraving operations take a font, a string, size, and depth, and emit the toolpath, with the stroke-font selection living in the font dropdown. Dedicated engraving tools, from free utilities to sign-making packages, add conveniences that matter in production: text on arcs and circles for dial faces, automatic serialization for sequential part numbers, single-line font libraries beyond Hershey. Router ecosystems build the same features into their design software, which is where most [hobby-machine engraving](/journal/shapeoko-cnc-router-g-code-practice/) actually happens, and macro-capable industrial controls sometimes carry parametric engraving cycles that draw characters from variables, the [macro-programming approach](/journal/g65-macro-call-vs-m98-subprogram/) applied to lettering.

Whatever generates the code, the same review applies before cutting: check the font actually engaged was single-line (double-traced outlines are visible in any backplot), check depths in the code match intent, and check the retract plane clears clamps across the whole text block, since text often spans more of the part than any single feature. Mirrored text for molds and dies deserves its own flag: engraving the cavity means the text must read backwards in the code so the molded part reads forwards, an inversion the generator handles if asked and ruins the workpiece if forgotten.

## Materials, and the honest limits

Material behavior spreads wider in engraving than in general milling because the cuts are so shallow. Aluminum and brass engrave beautifully and forgivingly, the reason practice and first jobs should start there. Steels engrave with sharper tools, slower feeds, and more respect for tip wear. Plastics range from crisp acrylic to gummy polyethylene that smears instead of cutting, where a drag of the letters with a deburring pass or a different tool geometry decides legibility. Anodized aluminum is its own reward: barely-there depths through the colored layer produce high-contrast text with almost no tool load, which is why it is the classic nameplate stock.

The honest limits: spindle engraving at very small text sizes eventually loses to marking processes built for it, laser marking for permanence at speed, dot-peen for traceability codes, and a shop quoting thousands of serialized parts should compare processes rather than heroically engraving. And on machines without fine Z control or with worn spindles, drag engraving beats rotary engraving for surface marking, because its spring supplies the depth control the machine lacks. Engraving in G-code earns its place for integrated work, text on parts already on the machine, modest quantities, tool-room jobs, which is exactly where knowing the stroke-font, tool-depth, and blending rules pays.

## Bottom line: three inputs, two settings, then the code

Crisp engraved text is decided before the program runs: a single-line stroke font, a tool whose geometry suits the stroke weight, and a depth chosen with the width-depth coupling in mind, cut on a surface flat enough for that coupling to stay constant. In the machine, tighten blending for corner crispness and respect the planner on segment-dense text. Generate the code from a tool that knows engraving fonts, review for double-traced outlines, depth, retracts, and mirroring, and test-cut at the stock's edge first. The G-code itself is the easiest part of the job, and that is the point: get the inputs right and the thousands of little G01 lines take care of themselves.

## Frequently asked questions

### How do I engrave text with G-code?

Choose a single-line stroke font (Hershey-style, not an ordinary outline font), a V-bit or fine engraver, and a shallow depth, typically 0.003 to 0.010 inch, then let a CAM engraving operation or dedicated engraving tool generate the toolpath from the text string. Review the output for single-line strokes, correct depth, and safe retracts, tighten path blending for crisp corners, touch off carefully at the engraving location, and cut a test line before the real text.

### Why does my engraved text look like double lines or mush?

An outline font was used: ordinary fonts define letters as closed shapes, so the toolpath traces both sides of every stroke, which turns small text into overlapping cuts. Switch to a single-line (stroke/engraving) font in the generator, the option exists in most CAM and router software, and small text becomes one clean pass per stroke. Secondary suspects for mushy text: loose path blending rounding the corners, and a chipped V-tip cutting wide.

### How deep should I engrave text?

Shallow: 0.003 to 0.005 inch for fine text in metal with a 60-degree V-bit, up to 0.010 or more for bolder lettering, and barely through the coating on anodized aluminum. With V-tools the line width grows directly with depth, roughly equal to depth times the tool's angle factor, so depth is really the stroke-weight dial, and depth consistency across the part matters more than the exact number: a few thousandths of tilt visibly fattens letters mid-word.

### What is the best way to learn the codes an engraving program uses?

Engraving programs are a vocabulary drill in themselves: G00/G01 chains, plunges, retracts, occasional arcs, and the blending codes that keep corners sharp. Recall practice makes reviewing generated code fast, and a free app like G-Code Sprint quizzes exactly that everyday vocabulary in short timed rounds, repeating what you miss, so scanning an engraving file for wrong depths or missing retracts becomes a seconds-long habit rather than a lookup exercise.

### Can I engrave with a laser or drag engraver instead of a spindle?

Often yes, and sometimes better. Drag engravers, spring-loaded diamond tips, excel at surface marking on metal with no spindle and mechanical depth-following, forgiving unlevel parts. Laser marking wins for very small permanent text at production speed. Spindle engraving holds the middle: real depth, integrated into machining setups, flexible materials. The stroke-font rule applies to all three, and the G-code for laser and drag work is the same short-segment geometry with power or spring replacing depth.

## Sources

- [Wikipedia: Hershey fonts](https://en.wikipedia.org/wiki/Hershey_fonts)
- [Wikipedia: Engraving](https://en.wikipedia.org/wiki/Engraving)
- [LinuxCNC G-code reference](https://linuxcnc.org/docs/html/gcode/g-code.html)

---

Source: https://gcodepractice.com/journal/engraving-text-g-code-basics/
Author: Lawrence Arya — https://www.linkedin.com/in/vibecoding/