The cut was fine. The rapid across the top wasn't.
Between operations, the tool rapids up to a “safe” Z, traverses to the next position, and comes back down. That safe Z — the clearance plane — is supposed to be high enough to clear everything the tool passes over: the part, the fixtures, the clamps, any raised feature. When it is, the rapid is invisible. When it isn’t — when the safe Z is set below the top of a clamp, or a tall fixture, or a feature standing above the stock — the tool traverses at that height and drives straight into the obstacle at rapid speed. The cutting was correct. The crash is in the move between cuts, at the worst possible feedrate.
It’s an easy mistake precisely because the safe Z looks fine in the part. Every operation reaches its feature; the finished geometry is right. The clearance plane is only about the space above the work, and that space is exactly what a program listing and a part-focused check don’t show.
How a safe Z goes wrong
- Set below a clamp or fixture. The clearance plane clears the part but not the workholding standing above it. The rapid transit clips the clamp.
- A raised feature the tool must cross. A boss, a previously machined stand-off, or a fixture rib sits above the safe Z, and the traverse to the next operation drives into it.
- Copied from a job with a different setup. A safe Z proven on open, flat stock, pasted into a job with tall fixtures, brings a clearance that no longer clears.
- A modal retract left too low. A clearance height set for one operation carried into another with more standing above it.
- Confusing part-Z clearance with machine-Z retract. A retract to a work-coordinate Z isn’t the same as a safe machine position (G53 Z); assuming one for the other can leave the tool lower than intended.
Every one of these clears the features perfectly. It’s the between-features motion, over the real fixtures, that the programmer didn’t picture.
Why this only shows up with the real fixtures in the scene
The listing can’t show it. A safe Z is a number; whether it clears the setup depends on what’s standing in the setup. Reading the code, the clearance looks like a reasonable height — because it is, for the part. The obstacle isn’t in the text.
A simulation without the real fixtures can’t show it either. This is a genuine collision, so in principle a check can catch it — if the fixtures and clamps are modeled, in the right place. If the verification runs on an empty table or an idealized setup, there’s nothing above the safe Z for the tool to hit, and the crash that will happen on the machine simply doesn’t appear. A CAM simulation driven by its own setup assumptions may not represent the real workholding at all.
So catching it reliably needs two things together: the real program executed the way the control runs the rapids, and the real fixtures in place.
Where Eureka G-Code fits
Eureka G-Code executes the true ISO on a digital twin of your machine, with your real fixtures, clamps, and stock in the scene — so the rapid transits happen over the real setup, at the real clearance height. A safe Z set below a clamp, a traverse across a raised feature, a copied clearance that no longer clears, a modal retract left too low: each shows up as a collision or a near-miss on the twin, before the tool ever transits at that height on the machine. Because it distinguishes work-coordinate moves from machine-coordinate retracts (G53) the way the control does, the “I thought that retract was to a safe machine position” mistake is caught too.
Because it reads the real ISO regardless of origin, a clearance error that entered through a hand edit or a copied block is caught as the control will execute it — over your real workholding, not an empty table.
> Take a job with tall fixtures or raised features — anything standing above the stock between operations — and run the real ISO on a twin of your machine in Eureka G-Code with your fixtures in place. Watching the tool rapid across the real setup, before it does it for real, is how the clamp it was about to clip gets caught at a desk.
FAQ
What is a safe Z / clearance plane?
It’s the height the tool rapids up to between operations before traversing to the next position — set high enough to clear the part, fixtures, clamps, and any raised feature it passes over. Too low, and the rapid transit drives into whatever stands above it.
Why does my tool crash on a rapid when every operation is correct?
Almost always a clearance plane set too low. Each operation reaches its feature correctly, but the safe Z doesn’t clear a clamp or raised feature, so the traverse between operations crashes at rapid speed. The fault is in the between-features move, not the cutting.
Why might my simulation miss it?
Because the crash depends on the fixtures. If the workholding isn’t modeled in the right place, there’s nothing above the safe Z for the tool to hit in the simulation, so the crash that will happen on the machine doesn’t appear. Eureka G-Code runs the real program with your real fixtures in place.
What's the difference between part-Z clearance and machine-Z retract?
A retract to a work-coordinate Z depends on the active work offset; a machine-coordinate retract (G53 Z) goes to a fixed machine position. Confusing the two can leave the tool lower than intended. Eureka G-Code executes each the way the control does.
Does it catch a copied or hand-edited safe Z?
Yes. It reads the actual ISO the control receives, so a clearance error from a copied block or a hand edit is caught over your real setup exactly as the control will run it.
Next step
Eureka G-Code — request a demonstration on a digital twin of your own machine and controller.
Run the rapids over your real fixtures — on a digital twin — and catch the clearance that doesn’t clear before the tool does.
Related Articles
Unattended bar work turns a crash from one scrapped part into a stopped run and a damaged machine. Here’s the checklist of what has to be verified before you walk away — and how Eureka Cloud runs those simulations overnight, in queue, so the whole night’s programs are proven before the lights go off. Request a demo on a twin of your machine
Master Bumotec s191 process orchestration across turning, milling, and grinding. Discover how digital twin simulation prevents costly first-cut errors.
Verify automatic head changes, kinematic transforms, and large-envelope ISO code on PAMA Speedram and Speedmat machines with Eureka G-Code
Discover common multichannel sync errors on the Okuma Multus U4000. Prevent crashes and deadlocks by simulating real ISO code on a digital twin.
Master B-axis signs, sub-spindle logic, and Fanuc cycles on the SMX 2100ST. Verify actual ISO code with Eureka G-Code digital twins
Avoid two-turret crashes on Nakamura-Tome machines. Learn to verify pinch turning, superimpose modes, and waiting M-codes across channels.
Single-block on a multitasking machine is defusing a bomb with the timer running. Step through the real G-code off-machine on a digital twin — watch where a variable actually drives the tool, follow subprogram flow across channels — and find the bug at a desk. Eureka G-Code runs and edits the true G-code on a twin of your machine. Request a demo on a twin of your machine.
Prevent slow, costly collisions on large vertical lathes like the Pietro Carnaghi AP80. Verify part zero, attachments, and G-code before production.
Standardize program verification across plants with automated, on-premises batch simulation. Eliminate bottlenecks and ensure no G-code runs unverified
How wrong call numbers, missing M99 returns, and carried modal states cause program flow crashes. Verify nested M98/M99 call structures on a digital twin
A probing cycle sets offsets at runtime and changes what every later move does — yet it’s the part of the program almost nobody simulates, because a toolpath render doesn’t run it. Eureka G-Code executes probing cycles on a digital twin of your machine, and checks pre-holes for tapping too. Request a demo on a twin of your machine.
Prevent head order errors, turret mirror mismatches, and EIA/ISO sequence crashes on the Mazak i-300 ST with Eureka G-Code digital twins
Prevent sub-spindle handoff crashes, front/back side errors, and XB B-axis mismatches on Nomura NN-20J3 Swiss machines with Eureka G-Code.
Why wrong plane selection causes arcs to cut into parts and canned cycles to plunge off-axis. Verify modal G17/G18/G19 plane state on a digital twin.
Deep-hole drilling for injection and die-casting molds (IMSA, CHETO) isn’t just a toolpath: depth vs diameter, chip evacuation, guide bushings, special cycles and process monitoring all matter
A digital twin of your sliding-headstock (Swiss-type) machine that reads the real ISO code and proves it out before the bar runs. Any controller, any kinematics
Why G83 peck depths, G98/G99 retracts, and control-specific behaviors cause crashes and scrap. Simulate real canned cycles on a digital twin offline.
On a Citizen Cincom L20, the pains are multi-system ($1/$2/$3) synchronization, the G600-series machining-mode calls that govern gang, front, back and superimposed work, wait codes that must appear in every system, and Z-shift and guide-bushing traps. Eureka G-Code runs the real ISO across every system on a digital twin of the machine. Request a demo on a twin of your machine.
On the DMG MORI NTX 1000, the recurring pains cluster around tool offsets that rotate with the B-axis or sub-spindle, wrong origins between the main and counter spindle, a post that doesn’t match the real kinematics, and one-setup programs that assume a machine state that isn’t there. Eureka G-Code runs the real posted ISO on a digital twin of the actual kinematics. Request a demo on a twin of your machine.
Why rewrite the same helical interpolation code for every thread size when a macro can generate it from a few parameters? Eureka G-Code simulates the real G-code with macro expansion and helical interpolation, before you cut
Master horizontal spindle kinematics, A’/B’ swivel table logic, and undercut operations on the GROB G350 with Eureka G-Code digital twins.
A digital twin of your multi-channel turn-mill that reads the real ISO of every channel — synchronization, multiple spindles, sub-spindle transfer, constructor cycles and hand edits included — and proves it out before the turrets move. Any controller, any kinematics, no axis limit. Request a demo on a twin of your machine.
G32 cuts a thread one pass per block — every pass, infeed, chamfer and pull-out is on the programmer, and the feed must match the pitch in sync with the spindle. It’s valid code that scraps the thread or crashes the tool when a value is off. Eureka G-Code runs the real G32/G92/G76 passes on a digital twin of your machine
CAM simulation checks the toolpath it generated. The machine runs the posted G-code — with constructor cycles, macros, variables, subprograms and probing the CAM never modeled. On multi-channel and sliding-headstock machines, that gap is where the crash lives. Eureka G-Code simulates the true G-code on a digital twin of your machine. Request a demo on a twin of your machine.
Cut cycle time, extend tool life and save energy by re-modulating feedrates based on real tool engagement. Optimize G-code programs offline
Static checks miss parametric logic errors. Execute Macro B variables, IF/WHILE loops, and family-of-parts math on a digital twin to catch crashes off-line.
How shortest-path rollover, degrees/min feed errors, and C-axis wind-up cause 5-axis crashes. Verify multi-axis kinematics and TCP cycles on a digital twin.
After a coordinate rotation or a tilted working plane, ‘up’ isn’t machine-up anymore — so a retract programmed in the rotated frame, or with the wrong axis order, drives the head straight into the part instead of clearing it. It’s a crash during what should be a safe disengage. Eureka G-Code runs the real ISO — rotation and kinematics included — on a digital twin. Request a demo on a twin of your machine.
Most scrap isn’t a crash—it’s a valid program making an out-of-spec part. Compare real ISO simulation to CAD models to catch shifted offsets offline
How G90/G91 modal errors, lathe U/W mix-ups, and subprogram mode shifts cause wild moves and crashes. Verify real ISO reference frames on a digital twin
On paper the DVF 5000 Gen 2 gives you a big envelope and full 5-face access. In real setups it’s tighter: at tilt the reach shrinks, the fixture and trunnion interfere, the tool setter gets in the way, and the table sits off-center from the spindle. That gap between brochure envelope and usable envelope is where setups crash.
A move that’s geometrically fine can still drive a rotary or B-axis into its travel limit — and because it isn’t a geometry error, a toolpath simulation doesn’t catch it. Eureka G-Code checks overtravel and near-miss against your real machine’s travels on a digital twin. Request a demo on a twin of your machine.
Ask any experienced machinist ‘what’s in your safe start?’ and you’ll get a line like G17 G40 G49 G80 G90 — the block that forces the control into a known state so your program doesn’t inherit leftover modal settings from whatever ran before.
CAM simulations assume correct offsets and miss wrong H numbers or missing G43 codes. Verify runtime control offsets and G49 states on a digital twin
Eureka Cloud turns every PC on your network into a simulation agent, so a whole shift’s worth of NC programs is verified overnight, in parallel — cleared or flagged before they reach the machine. And despite the name, it runs on your own servers: a private cloud, so your NC programs, geometry and IP never leave your network. Highly customizable, it integrates with your CRM, MES or other apps through APIs and scripting, and can automate post-processing, simulation, and feedrate optimization end to end. Request a demo
Feedrate optimization isn’t a lab trick. Across real production — hardened-steel molds, aluminum castings, precision components, large gantry work and continuous 5-axis parts like impellers — Eureka Chronos has cut cycle time by roughly 6–26% while holding surface quality and dimensional accuracy, with tool wear reduced or unchanged. And it needs no material or tool libraries to do it. Request a demo.
Aero-engine blisks and casings push machining to the edge: tough titanium and superalloys, thin deformable parts, and airflow passages between blades so narrow the tool can interfere on a five-axis move
A Swiss-type lathe flips the geometry, packs the tool zone, and lets one tool do many jobs — so the mistakes that scrap parts and crash gang tools are ones a conventional-lathe programmer has never had to think about.
CAM cycle-time math is optimistic on any machine — and on parallel channels with synchronization waits it’s worst of all, because the waits and the interleaving aren’t in the toolpath. Eureka G-Code computes cycle time from the real ISO on a twin of your machine, and Eureka Chronos optimizes it. Request a demo on a twin of your machine
The main-to-sub-spindle handoff is a timed dance — advance, grip, match, release before cut-off — and getting it wrong drops the part or crashes the spindles. It’s timing, not geometry, so a listing and a toolpath sim both miss it. Eureka G-Code executes the real transfer on a digital twin of your machine. Request a demo on a twin of your machine.
On a multi-channel turn-mill, each channel’s program can be flawless and the machine still crashes — because the collision lives in the timing between channels, not in any one line. Eureka G-Code simulates the real ISO of every channel, synchronization commands included, on a digital twin of your machine, so wait-code mistakes surface before the turrets meet. Request a demo on a twin of your machine.
Moving legacy CNC programs to new horizontals risks costly crashes. Learn what breaks in G-code, offsets, and M-codes, and how to verify them

