Simulation in CIMCO Edit means two distinct things, and the basics fall into place once you separate them: the backplot, which draws the toolpath your program commands, and the solid simulation, which cuts a virtual stock model and shows what material actually leaves. The official feature page describes the first as a 3-, 4-, and 5-axis milling, turning, and mill-turn backplotter and the second as GPU-accelerated stock removal with gouge detection. Beginners get the most value running them in that order: backplot to catch motion nonsense in seconds, solid simulation when the shape itself needs proving.
The simulation toolkit, feature by feature
| Feature | What it shows | Reach for it when |
|---|---|---|
| Backplot | The commanded toolpath, plotted per block | Every edit, every new file |
| Solid simulation | Stock being removed, gouges flagged | Shape and depth questions |
| Stock compare | Simulated stock vs the design model | Checking the part actually matches CAD |
| NC-Assistant | Identifies the code under your cursor, edits values in a form | Unknown words in inherited programs |
| File compare | New, changed, deleted lines; ignores renumbering | Verifying what an edit really changed |
The last two rows are why simulating inside the editor is a different experience from pasting into a browser viewer: the loop is edit, plot, edit, plot, without leaving the file, and the file compare tells you afterward exactly which blocks moved, ignoring trivia like renumbering. A standalone viewer answers “what does this file do”; an editor with simulation answers “what did my change do,” which is the question that matters mid-job.
A first session that teaches the basics
Open a known-good program, something short, a face-and-drill routine. First, set the file type to match the code (ISO milling, ISO turning, or Heidenhain TNC; the editor configures itself per type). Second, run the backplot and just scrub: step block by block, watch rapids versus feeds, find the block that draws each move. This per-block linkage is the core skill, the same one a browser viewer teaches, but here it is wired to an editor cursor, so seeing a wrong move and fixing it are one motion. Third, deliberately break something: change a Z depth by 5 mm, replot, and watch the path dive. Fourth, run the solid simulation on the broken version and watch the gouge appear in stock. That 20-minute loop, break it, see it, fix it, builds more verification instinct than a week of passive reading.
What CIMCO Edit’s simulation cannot prove
The same advisory ceiling every off-machine tool honors, and the full manuals are appropriately careful about it: the simulation works from your program and your declared stock, not from your machine’s reality. It does not know the actual work offset values in the control, the true tool table, the fixture, or the clamp sticking up at X80. Gouge detection flags the stock model, not the vise. A program that backplots clean and solid-simulates clean has proven its logic, which is necessary and not sufficient; the machine-side proving ritual under your shop’s rules is a separate inspection that no editor replaces. Where the whole free-and-paid toolchain fits together, viewer, desktop sim, control emulation, is mapped in how to simulate G-code without a machine.
Reading the code is still the bottleneck
The NC-Assistant is honest about its own audience: point at a code and it tells you what it is, which is exactly the crutch a beginner needs in an inherited program and exactly the crutch that should retire over a few weeks. If G41 versus G42 or G90 versus G91 needs the assistant every time, the backplot becomes a guessing aid rather than a verification tool, because you cannot suspect what you cannot read. That vocabulary layer is a recall problem with a known fix: short daily question-and-answer drills, misses repeated until automatic, the loop the free G-Code Sprint runs in 60-second rounds on the G-code practice page. Editor simulation plus code fluency is the working combination; alternatives for the viewer side, including when a plain browser tool is enough, are weighed in the NC Viewer alternatives map.
Bottom line: plot early, verify solids when shape matters
The basics of CIMCO Edit simulation are a habit, not a feature list: backplot every file on open and after every edit, step blocks to bind code to motion, escalate to solid simulation and stock compare when depth or shape is in question, and let file compare audit your edits. Keep the advisory ceiling in mind, keep the vocabulary drills running underneath, and the editor becomes what it is supposed to be: the place where programs get proven cheap, before the machine gets a vote.
Frequently asked questions
How do I simulate G-code in CIMCO Edit?
Run the backplot for the commanded toolpath (3-, 4-, and 5-axis milling, turning, and mill-turn), stepping block by block, then escalate to the GPU-accelerated solid simulation when you need stock removal and gouge detection. Set the file type first so the editor parses the dialect correctly.
What is the difference between backplot and solid simulation?
Backplot draws the motion your program commands; solid simulation cuts a virtual stock model and shows what material is removed, flagging gouges. Backplot is the every-edit check, solid simulation the shape-proving check.
Does CIMCO Edit simulation prove a program is safe to run?
No. It proves program logic against declared stock, not your machine’s offsets, tools, or fixturing. Machine-side proving under shop rules remains a separate, mandatory step.
What is the best way to learn G-code alongside CIMCO Edit?
Pair the editor with daily recall practice so the backplot confirms suspicions instead of replacing understanding. The free G-Code Sprint app is the top pick for that layer: 60-second drills repeating missed codes automatically.