Autodesk Fusion Post Processor Basics: How .CPS Posts Work

Autodesk Fusion uses post processors to convert CAM toolpaths into the machine-specific program required by a CNC controller. Fusion post processors are normally stored as .cps files and define how machining operations, tools, coordinates, cycles and machine functions are translated into the final NC output.

A post processor can control much more than the formatting of G-code. Depending on the CNC machine, it may handle tool changes, work offsets, drilling cycles, rotary-axis positioning, retract behaviour, machine-specific M-codes, aggregates, safety moves and even structured native output formats.

Fusion provides post processors for many common CNC controllers, but a generic configuration does not automatically match every physical machine. The post must correspond to the real controller, machine kinematics and production configuration.

This guide explains how Fusion post processors work, where .cps files fit into the CAM workflow, what can be changed through Post Properties, when the post source code needs to be edited and how modifications should be tested before production use.

The CAM toolpath describes what the cutting tool should do. The post processor determines how those instructions are written for the actual CNC machine.

What Is an Autodesk Fusion Post Processor?

An Autodesk Fusion post processor is the translation layer between the toolpaths calculated inside the Manufacture workspace and the CNC program that is sent to the machine.

Fusion internally knows information such as:

• tool position;
• cutting direction;
• tool orientation;
• spindle speed;
• cutting feed;
• tool number;
• work coordinate system;
• drilling cycles;
• machining planes;
• rapid and cutting movements.

The CNC controller does not directly execute Fusion’s internal CAM data.

During Post Process, Fusion sends machining events to the selected post processor. The .cps configuration interprets those events and writes the corresponding machine program.

For a conventional CNC milling machine, this may result in ISO-style G-code.

For other CNC systems, particularly woodworking machines, the same Fusion operations may be translated into a completely different machine-specific or structured output format.

For a more general explanation of what a CNC post processor does, see our guide to CAM post processing.

Where Does the Post Processor Fit in the Fusion Workflow?

A typical Autodesk Fusion CAM workflow looks like this:

1. Create the manufacturing setup

Define the stock, work coordinate system and machine orientation.

2. Create machining operations

Create operations such as contouring, pocketing, drilling, boring or multi-axis machining.

3. Calculate toolpaths

Fusion calculates the required tool motion.

4. Simulate

Check the machining strategy, stock removal and potential collisions inside Fusion.

5. Select the post processor

The post must correspond to the target CNC machine or controller.

6. Configure Post Properties

If the selected post exposes configurable properties, these can be adjusted before generating the program.

7. Post Process

Fusion executes the .cps post processor and generates the CNC program.

8. Review the generated output

The NC program should be checked before it reaches the machine.

9. Validate on the CNC

Machine-specific behaviour must finally be verified using a controlled and safe test procedure.

What Is a .CPS File in Autodesk Fusion?

Fusion post processors normally use the .cps file extension.

A .cps file contains JavaScript-based post-processing logic that receives machining information from Fusion and converts it into the required machine output.

The postprocessor can define:

• program headers;
• program numbers;
• sequence numbers;
• units;
• coordinate formatting;
• tool calls;
• spindle commands;
• feeds;
• work offsets;
• rapid positioning;
• cutting movements;
• arcs;
• drilling cycles;
• tool compensation;
• work-plane changes;
• rotary axes;
• retract behaviour;
• machine-specific macros;
• program end sequences.

A production post processor can therefore range from a relatively simple three-axis G-code generator to a complex machine interface containing thousands of lines of machine-specific logic.

Where Can I Find Fusion Post Processors?

Autodesk provides a Post Library containing configurations for many common CNC machines and controllers.

A standard post from the library is often a good starting point for conventional machines using common controller behaviour.

However, matching the controller name alone is not enough to guarantee compatibility.

For example, two machines using the same controller can still have different:

• axis configurations;
• rotary directions;
• tool changers;
• safety positions;
• machine macros;
• spindle functions;
• probing functions;
• drilling cycles;
• work offset behaviour.

A post should therefore always be checked against the actual machine configuration before production use.

The official Autodesk Fusion Post Library is the best starting point for downloading a post processor for a common CNC machine or controller.

Machine age adds another variable: an older controller may accept a library post’s syntax but still struggle with program size or block-processing speed. See our guide to using Autodesk Fusion with older CNC machines for how smoothing, tolerance and post-processor adjustments address that.

How to Install a Post Processor in Autodesk Fusion

A custom or downloaded .cps file can be added to the user’s Fusion post library and then selected when an NC program is created.

The exact interface can change between Fusion versions, but the basic workflow is:

1. Open the Manufacture workspace.
2. Open the Fusion Post Library.
3. Select the appropriate personal or local post library.
4. Import or copy the .cps post processor.
5. Select the post when creating or editing the NC Program.
6. Review the available Post Properties.
7. Generate a controlled test program before using the post in production.

Post Properties vs Editing the .CPS File

Not every postprocessor change requires programming.

Many Fusion post processors expose configurable Post Properties that allow the user to change selected behaviour without editing the .cps source code.

These properties may control options such as:

• sequence numbers;
• optional stops;
• work offsets;
• retract behaviour;
• coolant output;
• program comments;
• tool information;
• machine-specific switches.

More fundamental machine behaviour normally requires a change to the .cps source.

Post Properties are ideal for behaviour that the post developer intentionally made configurable.

Editing the .cps file changes the underlying translation logic and therefore requires a deeper understanding of both Fusion post-processing and the target CNC machine.

How Does Fusion Post Processor Code Work?

Fusion post processing is event-based.

As Fusion processes the CAM program, the post processor receives events representing different parts of the machining program.

Common post-processing functions include:

• onOpen() — beginning of the CNC program;
• onSection() — beginning of a new machining section;
• onRapid() — rapid movement;
• onLinear() — linear cutting movement;
• onCircular() — circular interpolation;
• work-plane and rotary-axis handling;
• drilling-cycle processing;
• onClose() — end of the program.

The postprocessor decides how each event is converted into machine output.

Code example

function onOpen() {
  writeComment("Program generated by Autodesk Fusion");
}
function onLinear(x, y, z, feed) {
  writeBlock(
    gMotionModal.format(1),
    xOutput.format(x),
    yOutput.format(y),
    zOutput.format(z),
    feedOutput.format(feed)
  );
}

This simplified example illustrates the principle.

When Fusion processes a linear cutting move, onLinear() receives the required coordinates and feed rate. The post processor then formats these values according to the rules defined for the CNC machine.

A production post processor normally contains significantly more logic for modal commands, coordinate transformations, tool changes, cycles, machine limits, multi-axis behaviour and safety functions.

Example: Changing Machine-Specific Output

One of the easiest ways to understand post processing is to compare the CAM operation with the machine output.

Assume that Fusion uses:

Tool: T5
Spindle speed: 18,000 RPM
Operation: Contour

A generic CNC may accept:

T5 M6
S18000 M3

Another machine may require a sequence such as:

M5
G53 G0 Z0
T5 M6
S18000 M3

The Fusion toolpath did not change.

The difference is entirely inside the machine-specific post-processing logic.

The same principle applies to:

• work offsets;
• tool compensation;
• drilling cycles;
• spindle commands;
• safety retracts;
• rotary-axis positioning;
• aggregate selection;
• machine macros.

This is why repeatedly correcting the same NC code manually is usually less reliable than correcting the rule inside the post processor.

Should I Edit the G-Code or Fix the Post Processor?

Manual editing can be useful during troubleshooting, but it should not normally be part of a repeated production workflow.

If the same correction is required after every Post Process, the correction usually belongs in the post processor.

Typical repeated edits that should be investigated include:

• changing the same M-code;
• inserting the same safety move;
• correcting tool numbers;
• changing work offsets;
• modifying retract positions;
• changing drilling syntax;
• correcting spindle commands;
• adding the same program header;
• changing rotary-axis output;
• correcting tool compensation commands.

A reliable CAM-to-machine workflow should minimise repeated manual changes to generated production programs.

Tool compensation is a good example of how Fusion CAM settings and postprocessor logic interact. Compensation modes such as In Control or Wear require the CAM strategy and generated controller commands to work together correctly. See our guide to tool compensation in Autodesk Fusion for a practical example of how CAM settings affect the generated CNC program.

What Changes With 4-Axis and 5-Axis Fusion Posts?

Multi-axis post processors require more than simply outputting an additional A, B or C coordinate.

The post processor may need to understand:

• machine kinematics;
• rotary-axis direction;
• rotary-axis limits;
• preferred orientation;
• shortest-path behaviour;
• indexed work planes;
• simultaneous tool orientation;
• TCP or non-TCP machine behaviour;
• safe retracts;
• coordinate transformations;
• singularities and machine limits.

A three-axis post should therefore not be converted into a production-ready five-axis post simply by adding rotary-axis output.

The post configuration must match the physical kinematics and controller behaviour of the machine.

Fusion Post Processors for Woodworking CNC Machines

Woodworking CNC machines often require significantly more machine-specific post-processing than conventional three-axis milling machines.

In addition to the main spindle, a woodworking machining centre may contain:

• vertical drilling spindles;
• horizontal drilling spindles;
• multi-spindle drilling heads;
• saw aggregates;
• angle heads;
• automatic workpiece positioning;
• multiple vacuum zones;
• 3+2 machining;
• simultaneous 5-axis machining.

The output may also use a native machine format instead of conventional ISO G-code.

Typical workflows include:

In these cases, the Fusion post processor may need to translate a CAM operation into structured machine-specific operations rather than simply writing XYZ coordinates.

For example, a Fusion drilling operation may need to become a native drilling command that selects a specific spindle from a multi-spindle boring head.

Read more about using Fusion for woodworking CNC and automated production workflows.

See an example of a machine-specific SCM Maestro XCS postprocessor for Autodesk Fusion.

See our Fusion and Holzher NC HOPS integration example for a practical woodworking workflow.

How Are Fusion Post Processors Edited?

Simple settings can often be handled through Post Properties.

Machine-specific development requires editing the .cps source code.

A typical development workflow includes:

1. Keep a backup of the original post.
2. Work on a separate development copy.
3. Generate a small controlled CAM program.
4. Compare the generated output with a proven machine program.
5. Modify one behaviour at a time.
6. Re-post the same test.
7. Compare the resulting NC output.
8. Validate the change before adding more complexity.

For complex machines, post development should be based on both the controller requirements and the real machine configuration.

A post that produces syntactically valid code is not necessarily production-ready if its tool changes, rotary axes, drilling cycles or safety logic do not match the actual CNC.

How to Test a Fusion Post Processor Safely

A new or modified post processor should be tested progressively.

Do not begin validation with a large production program.

Recommended validation sequence

1. Program header and footer — Check program numbers, units, modal commands and end-of-program behaviour.
2. Basic positioning — Test simple XYZ rapid and feed movements.
3. Spindle commands — Check spindle direction and RPM output.
4. Tool changes — Verify tool numbers, tool-change positions and required machine commands.
5. Work offsets — Check coordinate systems such as G54 or the machine-specific equivalent.
6. Contouring — Test linear and circular movements.
7. Drilling — Verify drilling cycles, retract positions and feed behaviour.
8. Compensation — Test the compensation modes that will actually be used in production.
9. Rotary axes — For multi-axis machines, validate indexed movements before simultaneous machining.
10. Machine-specific functions — Test aggregates, macros, probing or other machine options separately.
11. Controlled machine validation — Perform the final test on the real CNC using the appropriate machine safety procedures.

Common Fusion Post Processor Problems

Tool change is incorrect

Possible causes:

• wrong machine sequence;
• incorrect tool numbering;
• missing safety retract;
• machine-specific macro not implemented.

Retract height is wrong

Possible causes:

• post-specific retract logic;
• clearance/retract handling;
• safe-position configuration;
• rotary-axis transition logic.

Drilling output is wrong

Possible causes:

• unsupported canned cycle;
• controller-specific cycle format;
• drilling-head logic;
• incorrect retract mode.

Rotary axis moves the long way around

Possible causes:

• rotary preference;
• axis range;
• cyclic configuration;
• shortest-path settings;
• machine kinematics.

Fusion simulation is correct but machine motion is wrong

Possible causes:

• postprocessor output;
• machine configuration;
• controller settings;
• work offsets;
• rotary transformation;
• TCP/non-TCP mismatch.

When troubleshooting, always separate the problem into three layers: CAM toolpath → Postprocessor output → CNC machine behaviour.

This makes it much easier to determine where the error actually originates.

Autodesk Fusion Post Processors for CNC Machines

CCSOFTCZ develops and modifies Autodesk Fusion post processors for conventional CNC controllers as well as woodworking machining centres. See the full list of supported Fusion postprocessors.

Projects can include:

• three-axis CNC machines;
• four-axis machines;
• 3+2 machining;
• simultaneous five-axis machining;
• drilling heads;
• aggregates;
• machine-specific macros;
• ISO G-code;
• structured or native CNC formats.

View supported Fusion postprocessors →