Hitachi Seiki CNC Lathe and Sae Morse Lathe: One Program, Two Machines
A Hitachi Seiki CNC lathe and a Sae Morse lathe can run the same G-code, but only if the control, offsets and tool data line up. This page explains what has to match, what never will, and how to decide when one program for both machines saves time and when it costs you a scrapped batch.

In this article
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
Why a Hitachi Seiki CNC lathe and a Sae Morse lathe can share G-code at all
Most lathes built after 1985 speak a dialect of ISO 6983. A Hitachi Seiki CNC lathe with a Fanuc or Seicos control and a Sae Morse lathe with a similar control read the same G71, G76 and G92 blocks in the same order. The words are the same. The meaning of a few words is not.
The difference is not in the G-code itself. It sits in the machine data: work offsets, tool offsets, turret geometry, spindle orientation and the axis limits that decide whether a rapid move is legal. Two lathes can read identical code and cut two different parts.
So the useful question is not "can they share a program". They can. The question is which parameters must be normalized first, and which of them cannot be normalized at all. That is what the rest of this page covers.
We run 127 high-precision CNC machines across three wholly-owned plants in Dongguan and Singapore. Program portability is a daily production decision, not a theory exercise.
- 1Same code, different offsetsG54 and tool offset values live in the control, not the program.
- 2Same code, different geometryTurret station height and X reference point rarely match between models.
- 3Axis limits are hard stopsA legal move on one lathe can trip an overtravel alarm on the other.
Five conditions that decide whether one program runs on both lathes
Program sharing is a checklist, not a switch. If all five conditions below are true, one file will run on both machines with only a work offset change at setup. If any one is false, you need a post-processor variant or a manual edit before the first part.
Control family comes first. A Fanuc 0T, 16T, 18T or 21T block set transfers between machines cleanly. Seicos controls on older Hitachi Seiki lathes handle most standard cycles but differ on canned cycle return planes and on how they read certain M-codes.
Turret and tool geometry comes second. Twelve stations on one lathe and eight on the other means every T-word needs a map, and any grooving or boring holder that sits at a different center height will cut off-center on the second machine.
Third is the coordinate convention. Diameter programming for X is standard on both, but some older controls accept radius values when a parameter is flipped. One flipped bit turns a Ø40 mm turn into a Ø20 mm cut. Check the parameter, not the drawing.
Fourth is spindle and feed behavior. Constant surface speed, spindle orientation for bar feed, and thread chamfering at the end of a G76 cycle all depend on parameters that live in the machine, not the file.
Fifth is the axis envelope. The two lathes may look similar on the floor and still differ by 100 mm of Z travel.
- 1Control familyFanuc to Fanuc transfers cleanly. Seicos needs a read-through.
- 2Turret mappingStation count and holder center height must be reconciled.
- 3X conventionConfirm diameter programming before the first rapid move.
Offsets, tool data and the parameters that do not travel with the file
A G-code file contains geometry, not machine state. Everything a machinist touches at setup, the work offset, the tool offset, the wear value, the turret index reference, stays inside the control. That is good news for portability and bad news for the first article.
Work offsets are the easy part. Measure the same datum on both machines, write the same G54 values, and the program will position the tool correctly on both. This is the only offset most shops need to change between the two lathes.
Tool offsets are the hard part. A tool that touches off at 210.4 mm on the Hitachi Seiki CNC lathe will touch off at a different value on the Sae Morse lathe, often by several millimeters, because the reference point of the turret is a physical property of the casting.
Wear values are the quiet failure. If an operator on machine A adds 0.03 mm of wear compensation to hold a tolerance, that correction sits in machine A. Machine B will cut 0.03 mm off nominal until someone measures the first part.
The practical rule: never trust a tool offset table across machines. Re-touch every tool on the second lathe and record the values in a setup sheet that names the machine.
- 1Work offsetUsually the only value you must change between machines.
- 2Tool offsetAlways re-measure. Turret reference points differ.
- 3Wear compensationStays with the machine and is invisible in the file.
Where program sharing breaks down, and what it costs
Two failures show up again and again on the floor. The first is a thread that pulls out at a different chamfer angle on the second machine. The G76 cycle reads a parameter for chamfer amount. If that parameter differs, the thread still gauges correctly but the entry looks different, and on a sealing thread that difference matters.
The second is a turret collision during a rapid approach. The program was proven on the Hitachi Seiki CNC lathe, where station 7 sits clear of the tailstock. On the Sae Morse lathe, the same station is 12 mm closer. The rapid move is legal in the file and illegal in the machine.
Both failures share a cause. The program was validated against one machine and assumed valid against another. Simulation catches some of this, but only if the simulation uses the second machine's kinematic model, not a generic lathe.
The engineering answer is a machine-specific verification pass. Run the first article on the second lathe in single block with rapid override down, measure the critical dimensions, and only then release the program for production. On a 500-piece batch that pass costs less than an hour.
- 1Thread chamfer parameterDiffers between controls and changes the thread entry.
- 2Turret clearanceStation positions are physical, not programmed.
- 3Single block first articleCheapest insurance before a production run.
Cutting data does not transfer, even when the G-code does
Feeds and speeds in the program are a starting point tied to one machine's rigidity, spindle torque and toolholder stiffness. A Hitachi Seiki CNC lathe with a heavier bed will accept a deeper cut than a lighter lathe running the same insert.
For aluminium 6061-T6 and 7075, the difference is usually small enough to ignore on roughing and large enough to matter on finishing. Surface speed around 300–500 m/min holds on both, but depth of cut should drop on the lighter machine if chatter appears.
Stainless 304, 316 and 17-4PH behave differently. These grades work-harden, so a light pass on a less rigid lathe can rub instead of cut and raise the surface hardness under the insert. If you see Ra climbing between parts, increase feed per revolution rather than reducing depth of cut.
Titanium TC4 (Ti-6Al-4V) and Inconel punish any rigidity gap. Keep surface speed low, around 40–60 m/min, use high-pressure coolant, and treat the second lathe as a different process window rather than a copy of the first.
A program that shares G-code across two lathes should still carry a per-machine cutting data table. The geometry travels. The speeds do not have to.
- 1Aluminium 6061-T6Speeds transfer well; watch depth of cut on light lathes.
- 2Stainless 304 / 17-4PHWork-hardening punishes light passes.
- 3TC4 and InconelTreat each lathe as its own process window.
Why we keep the same program on both lathes at GreatLight
Part of our turning work runs across mixed lathes because the batch size needs the capacity. Keeping one proven program and changing offsets is faster than maintaining two files that drift apart after every engineering change.
The version control matters more than the time saving. When a drawing revision lands, one program is edited, proven, and released. Two programs mean two edits, two first articles, and a real chance that one file keeps the old dimension.
We hold ±0.005 mm on turned features and inspect 100% of parts before shipment, with raw material checks, in-process monitoring and final inspection. Reports are available on request. Certification covers ISO 9001:2015, IATF 16949:2016, ISO 13485:2016 and ISO 27001:2022.
No minimum order quantity applies, from one prototype to 10,000+ part runs. Quotation and free DFM analysis come back within 12 hours, and production can start within 24 hours. Parts ship in 3–5 days.
- 1One file, one revisionA drawing change is proven once, not twice.
- 2Offset-driven setupMachine differences live in the control, not the program.
- 3Documented first articleEvery machine pair carries its own signed-off setup sheet.
How to release one program to both lathes, step by step
Follow the order. Skipping step 3 is the most common cause of a scrapped first article.
- 1Confirm control family and optionsRecord the control model on both lathes. Compare canned cycle sets, return plane behavior and M-code lists. Note every difference in a setup sheet.
- 2Map the turretWrite down station number, holder type and center height on both machines. Build a T-word translation table if the counts differ.
- 3Verify the X conventionCheck the diameter/radius parameter in both controls before running anything. One flipped bit halves or doubles every X move.
- 4Re-touch all toolsMeasure every tool on the second lathe and store new offsets. Do not copy the offset table from machine A.
- 5Run the first article in single blockFeed override at 50% or lower, rapid override down, hand near the feed hold. Watch the first approach of every tool.
- 6Measure and adjustCheck the critical dimensions against the drawing. Adjust wear values on the second lathe only. Do not edit the shared program to compensate.
- 7Release with a machine noteStore the program with a header comment naming both machines and the offset values used. The next setup then takes minutes, not hours.
When one program for both lathes is the right call
Match the part and the batch size to the machine pair before you commit the file.
| Situation | One program, both lathes | Separate programs |
|---|---|---|
| Batch over 500 pcs, two lathes needed | Yes, offsets only | No, wasted setup time |
| Tolerance tighter than ±0.01 mm | Only after first-article on both | Safer, tune each machine |
| Same control family, same turret count | Yes, straight transfer | Unnecessary work |
| Different turret station count | Only with a T-word map | Cleaner, less risk |
| Thread and grooving features | Check chamfer parameters first | Recommended for G76 |
| One-off prototype | Not worth the setup | Single program, one lathe |
The verdict on sharing one program
If both lathes share a control family and turret layout, run one program and manage the difference through offsets. If turret geometry or canned cycle behavior differs, keep two programs and pay the editing cost. Geometry is cheap to duplicate. A scrapped batch is not.
Questions engineers ask before sharing a program
Can a Hitachi Seiki CNC lathe run a program written for a Sae Morse lathe without edits?
Usually yes, if both controls are from the same family and use diameter programming. The G-code blocks transfer as written. What does not transfer is the offset table, so every tool must be re-touched on the second machine before the first cut.
If the controls come from different families, expect differences in canned cycle return planes and in some M-codes. Read the program in single block before you trust it.
Which G-codes cause the most trouble when one program runs on two lathes?
G76 threading and G71/G72 roughing cycles cause the most trouble. G76 reads machine parameters for chamfer amount and pull-out angle, so the same block can produce a different thread entry on each lathe.
G71 and G72 differ in how they handle the return plane and whether they respect a partial retract. Check both on the second machine before running a full cycle.
Do tool offsets have to be re-measured on the second lathe?
Yes. Tool offsets describe the physical distance between the turret reference point and the tool tip. That distance is a property of the machine casting and the holder, so it changes between lathes even when the tool is identical.
Copying an offset table between machines is the fastest way to scrap a first article. Re-touch every tool and record the values against the machine name.
How long does it take to prove one program on a second lathe?
For a simple turned part with six to eight tools, plan on 40 to 90 minutes: re-touching tools, running the first article in single block, and measuring the critical dimensions.
Complex parts with threads, grooving and tight concentricity call for a longer pass. Budget half a shift the first time, then reuse the setup sheet on the next run.
Does sharing a program change the achievable tolerance?
No. The tolerance comes from the machine, the tooling and the process, not from the file. A lathe that holds ±0.005 mm on its own will hold it with a shared program, provided the offsets are correct.
What changes is your confidence before the first article. Measure the second machine's output instead of assuming the first machine's result carries over.
Should the cutting data in the program be the same on both lathes?
Not necessarily. Keep the geometry the same and let feeds and speeds differ where rigidity or spindle power differs. Aluminium usually tolerates the same data.
Stainless, titanium and Inconel do not. On the lighter lathe, reduce depth of cut or raise feed per revolution to avoid rubbing and work-hardening.
Send turning work that has to run on more than one lathe
Upload your drawing and we will confirm the machine pair, the tolerance and the lead time before you commit. Quotation and free DFM analysis within 12 hours.
12-hour quote100% inspectionNo minimum order