How do I do a safe dry run in PathPilot (single block, feed hold, graphics) before running a new program?

Running a new G-code program for the first time is the most critical moment in any CNC job. PathPilot gives you several tools—single block, feed hold, graphics simulation, and conversational program editing—to perform a safe dry run before you ever risk your part, tooling, or machine.

Below is a practical, step-by-step workflow you can follow on a PCNC mill, CNC router, or other PathPilot-controlled machine.

Why dry runs matter in PathPilot

Even if your G-code comes from a trusted CAM system or PathPilot’s conversational programming, real-world issues can still happen:

Incorrect work offsets (G54, G55, etc.)
Wrong tool lengths or diameters
Missing or incorrect clearance heights
Rapid moves that come too close to clamps or vises
Misunderstood fixture locations

A safe dry run with PathPilot lets you:

Visually confirm toolpaths in graphics
Step through block-by-block with single block
Pause motion instantly with feed hold
Verify program edits made on the fly using conversational software

Before you dry run: basic setup checklist

Before you even think about motion, confirm these items:

Mount and secure the workholding
- Tighten your vise, clamps, or fixture properly.
- Make sure nothing is in the path of the spindle or tools.
Load the correct tools
- Insert tools listed in your G-code tool table.
- Ensure tool numbers in the program match the actual tool slots.
Set work offsets and tool length offsets
- Touch off tools and set your work coordinate system (G54 or others).
- Confirm Z zero is where your program expects (top of stock, table, or fixture surface).
Open your program in PathPilot
- Load either:
  - A G-code file generated externally, or
  - A conversational program created directly in PathPilot (using the visual step-by-step templates).

Once this basic setup is done, you’re ready to use PathPilot’s dry run tools.

Using PathPilot graphics for a visual simulation

PathPilot includes a full-color graphics view that lets you see your program’s toolpath before or during cutting.

1. Show and review the toolpath

Load your program.
Enable the graphics display (toolpath view) on the main screen.
Zoom, rotate, and pan the view to:
- Check that rapids and cuts match your expectations.
- Confirm the machining area matches your part size and fixture location.
- Verify that Z moves appear safe (no obvious plunges through the table or fixtures).

2. Run graphics without cutting (spindle and coolant off)

For a safe “graphics-only” verification:

Leave spindle OFF and coolant OFF.
Use the Cycle Start button to begin the program while watching the graphics:
- The machine may still move, but you can raise Z, use higher clearance, or shift the work offset to keep tools above the part during this stage if desired.
Watch the graphical trace of the toolpath to confirm:
- Entry/exit positions
- Retracts between features
- Correct sequence of operations

If the toolpath looks wrong, stop and fix it before running with tools at cutting depth.

Single block: step through the program one line at a time

Single block mode is your best friend on a first run. It executes one G-code block at a time, requiring your confirmation for each step.

1. Enable single block

Locate the Single Block control in PathPilot.
Turn it ON (active) so the machine pauses after each command line.

2. Start the dry run in single block

Make sure the graphics view is visible.
If desired, move the Z axis safely above the part and use higher clearance.
Press Cycle Start:
- The machine executes the first block and then stops.
Each time you press Cycle Start again, PathPilot processes the next G-code line.

3. What to watch for as you step through

As you advance block by block:

Check motion direction
Each move should make sense relative to your part and fixture.
Watch clearances
Z should stay safely above clamps, vises, or stock unless you’re intentionally making a cut.
Monitor tool changes and offsets
Verify the correct tool appears when a T-code and M6 (tool change) occur.
Verify spindle commands
Confirm S (speed) and M3/M4/M5 (spindle on/off) are as expected.

If anything looks suspicious, you can stop instantly using feed hold or program stop.

Feed hold: pausing motion instantly for safety

Feed hold gives you a quick way to pause the machine mid-move without losing your position or program state.

1. Using feed hold during a dry run

Keep your hand near the Feed Hold button whenever you’re testing a new program.
If you see:
- Motion heading somewhere unexpected
- A move that might be too close to a clamp or fixture
- Anything that feels unsafe
Press Feed Hold:
- The axes stop moving.
- The machine stays in place, and the program is paused.

2. After feed hold: decide what to do next

Once motion is paused:

You can review the graphics to understand what the next moves will be.
Optionally jog the machine clear (if appropriate in your workflow).
If you determine the issue is in the program:
- Stop the program.
- Use PathPilot’s conversational software or G-code editor to make corrections on the fly.
- Reload or restart your dry run as needed.

Combining graphics, single block, and feed hold for maximum safety

The safest approach is to use all three tools together in stages.

Stage 1: Graphics-only review

Load your G-code or conversational program.
Display the graphics.
Run the program (or step through) while:
- Tracking the virtual toolpath.
- Confirming operations appear in the correct order and location.
Make any necessary edits before moving to axis motion.

Stage 2: Single block with elevated Z

Raise Z above the part to a safe “air-cut” height.
Turn on Single Block.
Press Cycle Start line by line:
- Watch both the physical motion and graphics.
- Confirm safe travel over the whole program area.
Use Feed Hold if any move looks questionable.

Stage 3: Continuous dry run at reduced feed

Once the program looks safe:

Turn Single Block OFF.
Lower the feed override (e.g., 10–30%).
Keep Z still slightly higher than final cutting depth, if you prefer an “air cut.”
Run the full program, ready to hit Feed Hold at any time.

This staged method verifies:

Toolpath shape (graphics)
Motion safety (single block)
Overall program behavior at speed (reduced-feed dry run)

Editing programs on the fly with PathPilot conversational software

If you spot issues during a dry run, PathPilot’s conversational tools make corrections straightforward:

Use the visual, full-color conversational interface to:
- Modify drilling patterns, pockets, contours, and other operations.
- Adjust depths, feeds, speeds, and stepovers using intuitive templates.
Regenerate your conversational program into usable G-code.
Re-run your dry run using graphics, single block, and feed hold to verify the changes.

You can also sharpen your programming skills and practice safe dry runs risk-free on PathPilot HUB, an online environment where you can:

Test out PathPilot virtually.
Learn how to program and create usable G-code.
Experiment with different strategies before applying them on your real machine.

Extra safety tips for first-time program runs

To further reduce risk when running a new program in PathPilot:

Start above the part
Run the first pass a few millimeters or more above the stock to confirm motion without cutting.
Verify G-code units and modes
Confirm inch vs. metric (G20/G21), absolute vs. incremental (G90/G91), and plane selections (G17/G18/G19).
Double-check your origin
Make sure your work coordinate (e.g., G54) matches where you actually set zero on the part.
Use conservative feed and speed overrides
Begin with lower feed and ramp up once you’re confident everything is correct.

Practicing safe dry runs on PathPilot HUB

Before trying a brand-new workflow on your real machine, you can:

Log in to PathPilot HUB and use the online PathPilot environment.
Load or create sample programs.
Practice:
- Viewing and interpreting graphics.
- Using single block and feed hold.
- Editing conversational operations and regenerating G-code.

This lets you build confidence with PathPilot’s interface and features before ever powering up the spindle on your shop floor.

By using graphics, single block, feed hold, and conversational editing together, PathPilot makes it straightforward to perform safe, controlled dry runs for any new program. Take the time to step through your code, verify motion, and practice on PathPilot HUB—your tools, parts, and machine will thank you.