Geo2Gcode: From 3D Geometry to CNC Programs through Structured Machining Primitives

Sangmin Hong, Dohee Cho, Mohsen Yavartanoo, Kyoung Mu LeearXiv 2026 · arXiv

TL;DR

Geo2Gcode is a new framework that automates the "mesh-to-machine" pipeline for CNC milling. By combining structured machining primitives with a reinforcement learning-based parameter selector, it generates standard, machinist-readable G-code directly from 3D geometry, achieving roughing fidelity comparable to expert-tuned commercial software without any manual intervention.

What Problem Does This Paper Address?

While 3D printing (additive manufacturing) has become highly automated, CNC machining (subtractive manufacturing) remains a bottleneck in the digital-to-physical workflow. Currently, turning a 3D model into a physical metal part requires a skilled machinist to use Computer-Aided Manufacturing (CAM) software to manually select tool orientations, cutting tools, step-down increments, and toolpath patterns.

Existing AI approaches generally fall into two camps:

  1. CAD Reconstruction: These methods turn meshes into CAD primitives (like "extrude" or "revolve"), but you still need a human to perform the CAM step afterward.
  2. Low-level Motion Learning: Methods like CNC-Net learn to predict raw tool movements, but these outputs are often "black boxes"—hard for machinists to read, verify, or trust on expensive industrial hardware.

Geo2Gcode seeks a "middle path": automating the decision-making process while keeping the output in a structured, standard format that industrial controllers can execute and humans can understand.

Methods

The authors introduce Structured Machining Primitives. A primitive is a bundle containing a machining direction, a target mesh for that view, and specific parameters (tool radius, layer height, and clearing pattern).

The pipeline consists of three main stages:

  1. Tool Orientation Selection: Using a greedy iterative approach, the system selects a small set of views (usually 5 or fewer) that maximize the visible surface area of the target object.
  2. Visibility-Based Reconstruction: For each view, it creates a "closed" version of the target mesh, filling in occluded regions to ensure the toolpath generator has a solid volume to work against.
  3. The Selector & Compiler:
    • The Selector: A Deep Q-Network (DQN) acts as the "machinist." It looks at the geometry and chooses the best tool radius, layer height, and clearing strategy (Zigzag, Periphery, or Spiral) for each view.
  4. The Compiler: A deterministic algorithm takes these choices and uses Signed Distance Function (SDF) queries to generate layer-by-layer G-code. It always includes a "Contour" pass to ensure surface fidelity.

The DQN is trained using a voxel-based stock simulator that provides feedback on how much material was removed, how much of the target was accidentally gouged, and how long the toolpath took.

Datasets

The researchers evaluated Geo2Gcode on two major 3D datasets:

  • ** ABC Dataset:** A collection of 5,000 mechanical CAD parts. This is the primary benchmark for "machinability."
  • ShapeNet: A dataset of 35,000 diverse 3D objects (chairs, planes, etc.) used to test the system's ability to generalize to organic or non-mechanical shapes.
  • Out-of-Domain (OOD) Testing: They also tested on classic graphics models like the Stanford Bunny and the Eiffel Tower to demonstrate zero-shot generalization.

Key Insights and Ideas

  • The "Middle Path" is Key: By restricting the AI to choosing parameters for standard machining patterns (Zigzag, Spiral, etc.) rather than free-form tool movements, the resulting G-code remains compatible with industrial standards and is inherently "machinist-readable."
  • Fidelity vs. Efficiency: The authors found that the deterministic compiler provides most of the geometric accuracy, while the RL selector's primary job is balancing accuracy against time. The selector achieved 97.8% of the fidelity of the "finest" possible settings but at only 25% of the toolpath length.
  • Visibility as a Proxy: Using simple ray-casting for visibility proved to be a highly effective and computationally cheap proxy for complex cutter-accessibility analysis.
  • Sequential Awareness: Because each machining view removes material left by the previous one, the DQN is trained to understand the sequence of operations, ensuring that early views don't leave "bad" stock for later views to deal with.

Key Results

  • Superiority over AI Baselines: Geo2Gcode significantly outperformed CNC-Net on the ABC dataset, achieving an Intersection over Union (IoU) of 0.848 compared to CNC-Net's 0.824.
  • Matching the Experts: When compared against MeshCAM (a commercial tool), Geo2Gcode matched the fidelity of an expert-tuned setup. While its toolpaths were roughly 20% longer than the expert's, it required zero manual tuning, whereas the expert had to manually choose setups and tools for every part.
  • Physical Validation: The authors successfully machined a part on a physical FANUC Robodrill using G-code generated entirely by the system, proving the code's readiness for real-world controllers.
  • Speed: Orientation selection and G-code generation take roughly 15 seconds per part—faster than the commercial baseline.

Limitations and Future Work

  • Roughing Only: The current system focuses on "roughing" (removing the bulk of the material). It does not yet handle "finishing" passes, which require much tighter tolerances and different toolpath strategies.
  • Collision Constraints: The simulator currently models the cutting tool but not the tool holder, machine spindle, or workholding fixtures (clamps). In a real shop, these are critical for avoiding catastrophic crashes.
  • 3+2 Axis Limit: The system uses "indexed" 3+2 axis machining (the part rotates, then stays still while the tool moves). It does not yet support continuous 5-axis simultaneous motion.
  • Material Science: The model does not currently account for cutting loads, heat, or material-specific properties (e.g., the difference between milling aluminum vs. steel).

Summary updated

Abstract

Turning a 3D shape into a Computer Numerical Control (CNC) program is still largely manual. For every part, a machinist chooses setups, tools, step-downs, and toolpath patterns. We present Geo2Gcode, which converts a target mesh directly into standard G-code through structured machining primitives. Each primitive couples an indexed machining direction, a closed per-view reconstruction of the target, and explicit tool-radius, layer-height, and clearing-pattern parameters, and compiles deterministically into layerwise toolpaths via signed-distance queries. Most of the fidelity comes from this compiler. A lightweight selector trained with a voxel stock simulator fills in primitive parameters without per-part manual settings, approaching the finest fixed setting at about a quarter of its toolpath length. In simulation on ABC parts, Geo2Gcode reaches roughing fidelity comparable to an expert-tuned commercial CAM setup with a moderately longer toolpath, and clearly improves on a default CAM configuration. Generated programs run in a commercial G-code simulator, and one part is machined on a physical CNC mill. These results demonstrate that roughing programs can be generated directly from geometry without per-part CAM tuning.
BibTeX
@misc{hong2026geo,
  author = {Sangmin Hong and Dohee Cho and Mohsen Yavartanoo and Kyoung Mu Lee},
  title = {{Geo2Gcode: From 3D Geometry to CNC Programs through Structured Machining Primitives}},
  year = {2026},
  eprint = {2611.20092},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.20092},
}
Figure