The same feed for wildly different cuts — that constant number is time, tool life, and energy left on the table
Watch closely what actually happens while a milling program runs, and two things stand out. There are moves through air held at the working feed. And there are cuts held at the same feed even though the material removed per unit time varies enormously from one moment to the next. The feedrate in the program is largely constant; the tool’s engagement is anything but. Every stretch where the feed is too low for a light cut is time you’re giving away; every stretch where it’s too high for a heavy cut is wear you’re spending on the tool. Tighten the management of those stretches and you cut cycle time, extend tool life, and lower energy use at the same time — and on a mold shop’s numbers, even a figure like 10% is a large result in cost and capacity.
The reason this opportunity exists is simple: the NC program a CAM system posts — the G-code (what Europe often calls the ISO program), or Klartext on a Heidenhain control — is never optimal. There are the limits of the CAM’s own calculation, the effects of the post-processor on top, and the use of variables to set feeds parametrically. What’s left — refining the feed to the real cut — is usually delegated to the experience of the operator at the machine, tweaking overrides by feel. That works, up to a point, and it doesn’t scale.
The principle: feed the tool by its real engagement, moment to moment
To regulate the feed along the whole path so the cutting conditions stay optimal, you have to know the tool’s actual engagement at each instant on the trajectory. Simplified: slow down where the engagement is greater, speed up where it’s smaller. That has to be done within limits and with a myriad of other factors in mind — the transition from climb to conventional milling, for instance, changes what’s safe.
Modern CNCs already exploit a version of this with adaptive control: they monitor a quantity like spindle load to sense when the tool is removing more material (or harder material) and reduce the feed accordingly, even halting the machine if a collision looks imminent. Those systems are genuinely useful — especially when the raw stock differs from the theoretical 3D, as with castings — but they’re prudential and reactive. They always intervene with a delay, however small, and they can’t perform a global optimization of the process: they react to the cut as it happens rather than planning the whole path in advance.
Eureka Chronos: a process twin plus AI that re-plans the feed globally
Eureka Chronos closes that gap by doing the optimization before the machine runs, over the whole program. It uses a sophisticated digital twin of the milling process to analyze the tool’s cutting conditions point by point along the entire path — the real engagement, not a proxy like spindle load. Those data feed AI algorithms that re-modulate the feedrate and write a new NC program to send to the machine. The method — patented by Roboris in 2019 — is fully automatable, so the whole thing runs in a few clicks rather than by hand-tuning overrides. It also optimizes parametrized feedrates — F values expressed through variables or parameters rather than literal numbers — which are common in parametric and Heidenhain programs and which manual override tuning and simpler optimizers struggle to handle.
And it isn’t limited to 3-axis milling. Chronos optimizes turning as well, and — the harder, higher-value case — continuous 5-axis machining. On parts like impellers, where roughing removes material at a rate that swings constantly and the feed has to track the tool’s engagement through simultaneous rotary motion, that’s often where the biggest gains show up.
It needs only three inputs: the NC milling program, the tool geometry, and the starting stock geometry — all of which transfer into Chronos automatically through interfaces with the major CAD/CAM systems and tool managers. Its interpreter reads the controls most common in the mold sector — G-code and conversational alike: Heidenhain, Fanuc, Selca, Fidia, and Röders — plus many others, including Siemens, Datron, Fagor, Toshiba, MillPlus, Roland, OSAI, NUM, and Z32 (D.Electron). Crucially, it needs no libraries of material or tool cutting data to build or maintain: the optimization works from the geometry and the tool’s real engagement, not from a database that has to be populated for every new material or tool.
Proven on the bench: an independent validation
The “faster and gentler on the tool” claim isn’t only theory. In an independent study commissioned to the University of Florence (Department of Industrial Engineering, Manufacturing Technologies Research Lab), a facing cycle on 42CrMo4 steel — cut dry, with the radial engagement deliberately varied along the path — was optimized in Chronos in automatic (AI) mode with productivity prioritized. The optimized program cut the cycle time by 17.2% and, measured on the actual worn edge pass after pass, left the tool with less wear, not more: the optimized cycle managed an additional facing pass before the cutting edge was spent — more material removed at equal wear.
That’s exactly what the approach predicts. Because Chronos slows the feed where the tool’s engagement is high — protecting the edge — and raises it only where engagement is low, cycle time and tool wear come down together instead of trading one for the other. Raising the feed uniformly does the opposite: in the same study, a flat higher feed drove the edge into catastrophic wear far sooner. It’s the selective modulation that makes the difference.
As always with cutting data, the numbers are specific to what was tested — this facing case, this tool, this material (42CrMo4, dry). A different tool–material pair would need its own wear characterization, though a similar percentage improvement is reasonable to expect.
Beyond that controlled study, the same pattern shows up in real production. Across roughing and finishing programs in mold making, aluminum casting, and 5-axis part production, Chronos has repeatedly delivered double-digit cycle-time reductions while holding surface quality and dimensional accuracy — with tool wear reduced or unchanged, not worsened.
Optimize only or optimize and verify
Chronos comes two ways. As a stand-alone tool for shops that just want to optimize. And as a module integrated into Eureka G-Code, for shops that also need to verify their NC programs — to cut setup time and avoid downtime or collisions from programming errors.
Inside Eureka G-Code, the program is simulated on a reliable digital twin of the machine tool — any kinematics, any CNC, well beyond five axes. The simulation runs a full collision check, including cutting-edge against the finished part and holder against the workpiece in progress, checks the proximity between cutting edge and fixturing, checks for the presence of pre-holes before tapping, and verifies the travel limits. For mold work especially, the accurate comparison between the machined part and the finished 3D is highly valued: it finds and measures any differences, identifying heel rubbing, excess material, or other inconsistencies. And a recent addition strengthens the verification of cutting conditions — flagging the stretches machined in conventional (rather than climb) milling and the stretches cut with the tip of a ball tool, where conditions are worst.
Put together, that’s the full loop a mold shop wants: prove the program is safe and correct, then make it faster and gentler on the tool — from the same real NC program, before the machine cuts.
> Take a mold-milling program you run often — a roughing or finishing job with long, varied cuts — and put it through Eureka Chronos. Compare the optimized cycle time and tool load to the original, on your real program. The difference is the time and tool life the constant feed was hiding.
FAQ
What does Eureka Chronos optimize?
The feedrate along a milling program. It analyzes the tool’s real cutting engagement point by point using a digital twin of the milling process, then uses AI to re-modulate the feed — slowing it where engagement is high, raising it where engagement is low — and writes a new NC program. The result is shorter cycle time, longer tool life, and lower energy use.
Does Chronos work on turning and 5-axis, or only 3-axis milling?
All three. Chronos optimizes 3-axis milling, turning, and continuous 5-axis machining — including demanding parts like impellers, where the feed has to track the tool’s engagement through simultaneous rotary motion. The principle is the same everywhere: match the feed to the tool’s real material-removal rate, whatever the axes are doing.
How is this different from the adaptive control on my CNC?
Adaptive control is reactive: it monitors something like spindle load and reduces the feed as the cut happens, always with a small delay, and can’t optimize the whole process. Chronos optimizes offline, globally — it analyzes the entire path in advance from the real geometry and re-plans the feed for the whole program, which the machine can’t do while cutting. The two are complementary.
Is there independent proof that Chronos reduces both cycle time and tool wear?
Yes. In a study commissioned to the University of Florence’s Manufacturing Technologies Research Lab, a Chronos-optimized facing cycle on 42CrMo4 steel cut cycle time by 17.2% while leaving the cutting edge less worn — the optimized cycle completed an extra pass before the tool was spent. The results are specific to the tested facing case, tool, and material, but they show the approach reduces time and wear together rather than trading one for the other.
What does Chronos need to run?
Just three things: the NC milling program, the tool geometry, and the starting stock geometry. These transfer in automatically through interfaces with the major CAD/CAM systems and tool managers.
Do I need to build a material or tool database to use Chronos?
No. The optimization needs no cutting-condition libraries for materials or tools. It works from your NC program, the tool geometry, and the stock geometry — using the tool’s real engagement rather than a database you have to populate and maintain for every new material or tool.
Which controls does it support?
Its interpreter reads the controls most common in the mold sector — G-code and conversational alike — Heidenhain, Fanuc, Selca, Fidia, and Röders — plus many others, including Siemens, Datron, Fagor, Toshiba, MillPlus, Roland, OSAI, NUM, and Z32 (D.Electron).
Does it work on programs with parametrized (variable) feedrates?
Yes. Chronos optimizes even feedrates set through variables or parameters rather than literal F numbers — common in parametric and Heidenhain programs — which manual override tuning and simpler optimizers struggle to handle.
Do I have to use Eureka G-Code to optimize?
No. Chronos is available stand-alone for optimization only. It’s also available as a module integrated into Eureka G-Code, for shops that want to verify their NC programs — collisions, part-vs-model, cutting conditions, travel limits — as well as optimize them.
Next step
Eureka Chronos — optimize your NC programs; available stand-alone or integrated in Eureka G-Code. Request a demonstration.
Optimize the feed to the real cut — from the real NC program, before the machine runs — and take back the time, tool life, and energy a constant feedrate leaves on the table.
Related Articles
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.
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.
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.
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
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
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
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.
Verify automatic head changes, kinematic transforms, and large-envelope ISO code on PAMA Speedram and Speedmat machines with Eureka G-Code
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
Prevent sub-spindle handoff crashes, front/back side errors, and XB B-axis mismatches on Nomura NN-20J3 Swiss machines with Eureka G-Code.
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.
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.
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.
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.
Standardize program verification across plants with automated, on-premises batch simulation. Eliminate bottlenecks and ensure no G-code runs unverified
Prevent head order errors, turret mirror mismatches, and EIA/ISO sequence crashes on the Mazak i-300 ST with Eureka G-Code digital twins
Discover common multichannel sync errors on the Okuma Multus U4000. Prevent crashes and deadlocks by simulating real ISO code on a digital twin.
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
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.
Avoid two-turret crashes on Nakamura-Tome machines. Learn to verify pinch turning, superimpose modes, and waiting M-codes across channels.
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
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.
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.
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.
Master Bumotec s191 process orchestration across turning, milling, and grinding. Discover how digital twin simulation prevents costly first-cut errors.
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.
Why G83 peck depths, G98/G99 retracts, and control-specific behaviors cause crashes and scrap. Simulate real canned cycles on a digital twin offline.
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 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 sliding-headstock (Swiss-type) machine that reads the real ISO code and proves it out before the bar runs. Any controller, any kinematics
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.
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
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
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
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
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.
Prevent slow, costly collisions on large vertical lathes like the Pietro Carnaghi AP80. Verify part zero, attachments, and G-code before production.
Why safe Z heights set below clamps or raised features cause rapid collisions between operations. Verify real ISO rapids over actual fixtures on a twin
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
Master B-axis signs, sub-spindle logic, and Fanuc cycles on the SMX 2100ST. Verify actual ISO code with Eureka G-Code digital twins
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.

