Design Software History: From G-Code to API-First: Technical History of Software-Defined Manufacturing

From NC Code to API-First: A Short History of Software-Defined Manufacturing

From Paper Tape to DNC: Wiring the First Digital Factories

The earliest wave of software-defined behavior in manufacturing arrived before anyone called it software-defined. In the 1960s and 1970s, numerically controlled machines consumed paper tape encoded with EIA RS-274D, the ancestor of what machinists colloquially call G-code/M-code. The workflow was strictly serial: offline CAM systems produced toolpaths, postprocessors converted them to machine-specific dialects, and operators fed physical media into a controller. When RS-232 serial links replaced paper tape, the paradigm did not change—it merely became faster and less error-prone. The emergence of Distributed Numerical Control (DNC) centralized program storage on a server, pushing files to machines on demand; it was the shop’s first orchestration layer, albeit one that orchestrated files rather than meaning. Every nuance—from tool length offsets to canned cycles—was embedded in opaque lines like G71, G76, or M06, binding the job’s intent tightly to the quirks of a controller brand or even a specific firmware revision. This tight coupling made early automation brittle: a change of controller often meant rewriting postprocessors and revalidating programs. Nevertheless, the DNC era foreshadowed a future where machines were nodes on a network. The lesson from that period is still relevant today: when control is expressed as vendor-specific strings, portability suffers, and the “API” is, effectively, the parser inside each CNC control.

• Paper tape and RS-232 linked geometry to motion via ISO 6983-style codes.
• DNC centralized program distribution but not semantics or capability models.
• File-based control optimized throughput, not interoperability or intent preservation.

CIM and MES: Integrating Islands Without Shared Semantics

By the 1980s and 1990s, Computer Integrated Manufacturing (CIM) attempted to stitch CAD, CAM, planning, and shop execution into a coherent whole. The movement catalyzed early Manufacturing Execution Systems (MES), which scheduled jobs, tracked work-in-process, and logged operator activity. Vendors like IBM, Honeywell, GE Fanuc, and later SAP and Oracle brought enterprise gravity to the plant, while PLM platforms from Dassault Systèmes, Siemens, and PTC managed product definitions upstream. Yet the machine level remained stubbornly opaque: MES could dispatch a file and record a timestamp, but it could not query, in a standard way, whether a given controller understood helical interpolation in a certain plane or supported a particular probing macro. CIM delivered integration across departments but lacked real-time, standardized machine semantics. This pushed complexity into custom adapters, tribal postprocessor know-how, and brittle spreadsheets—powerful in the hands of experienced teams, but difficult to scale or transfer. The gap between enterprise intent (a drawing, a BOM, a routing) and machine capability persisted because the lingua franca was still G-code and manual conventions, not a typed, negotiable model of behavior. CIM’s legacy, however, was foundational: it normalized the idea that the digital thread must run from design through production, even if its lower layers were still file-oriented rather than truly programmable.

• MES linked planning to execution but did not standardize controller capabilities.
• PLM governed product data while machine behavior remained controller-specific.
• Custom adapters compensated for the lack of shared machine semantics.

STEP-NC and Semantic CAD: Intent Tries to Escape the G-code Box

The late 1990s and early 2000s saw the emergence of STEP-NC (ISO 14649), a bold proposal to exchange features, strategies, and resources instead of lines of G- and M-code. Rather than “drive to X, feed at F,” STEP-NC expressed the manufacturing intent—rough pocket with a specific strategy, finish wall to a tolerance with a defined tool and coolant requirement—leaving the controller to compute the exact paths based on its kinematics and constraints. Adoption was partial: entrenched controller architectures, safety concerns, and the sheer installed base of ISO 6983 made wholesale replacement difficult. Yet STEP-NC shifted expectations and influenced downstream data richness. In parallel, model-centric engineering matured. Product Manufacturing Information (PMI)Model-Based Definition (MBD) workflows across CATIA, NX, Creo, and SolidWorks. The STEP AP242 standard emerged as a neutral backbone for exchanging geometry plus PMI, enabling downstream automation to consume the same source of truth used by design. Even when G-code continued to drive spindles, CAM began to inherit more intent directly from CAD. The net effect was a two-tier reality: controllers speaking legacy motion files, orchestration layers speaking richer models, and postprocessors acting as translators between intent and motion. That boundary is precisely where today’s APIs are focused—compressing the gap between what the product requires and how a heterogeneous machine park fulfills it.

• ISO 14649 (STEP-NC) modeled features and strategies over raw motion blocks.
• STEP AP242 plus PMI/MBD established intent-rich design data for automation.
• G-code persisted, but richer models began steering CAM and inspection planning.

From Files to Services: “Software-Defined” Manufacturing Takes Shape

The concept of software-defined manufacturing borrows consciously from software-defined networking (SDN): abstract heterogeneous hardware behind programmable, policy-driven interfaces. Instead of “drop a file and hope it runs,” the vision is to publish machine capabilities, subscribe to production intent, and negotiate execution via APIs. Telemetry is normalized, commands are typed and authenticated, and orchestration can compose robots, CNCs, printers, and inspection systems as services. In this framing, postprocessors become compilers targeting open capability models, not just proprietary dialects; controllers expose state machines, safety envelopes, and tool libraries through discoverable schemas; and quality systems feed measurement results back into design and CAM rules. The orchestration layer ceases to be a folder on a network share and becomes an intelligent control plane spanning cloud and edge. The irony is that G-code may still exist, just as assembly persists below high-level languages, but it becomes an implementation detail rather than the integration surface. This is the crucial pivot: move from file formats optimized for motion description to APIs optimized for intent orchestration. As we will see, the building blocks—standards like MTConnect, OPC UA, STEP AP242, and QIF, along with modern messaging and security—are finally mature enough to make that pivot practical.

Foundations and Standards: Making Machines Legible to Software

CAD-to-Machine Semantics: PMI, MBD, STEP AP242, and QIF

Orchestration begins upstream, with the model. PMI transforms a geometric model into an executable specification by encoding tolerances, GD&T frames, surface finish, material, and process notes. MBD formalizes the practice of making that annotated model the master, rather than a drawing-derived derivative. STEP AP242 weaves geometry and PMI into an interoperable exchange that downstream systems—CAM, CMM programming, and shop documentation—can parse without losing meaning. On the quality side, the QIF standard, stewarded by the Digital Metrology Standards Consortium (DMSC), provides schemas for feature definitions, measurement plans, and results, allowing GD&T intent to drive CMM execution and enabling measured results to close the loop with design. Legacy DMIS still powers many coordinate measuring machines (CMMs), and bridges exist to translate between DMIS programs and QIF plans. This semantic stack upgrades the old drawing’s role: instead of human interpretation, machines can compute, validate, and negotiate based on declared tolerances and features. For example, a downstream CAM engine can select strategies based on profile tolerance and datum schema; a metrology planner can auto-generate probing patterns tied to the same PMIs; a supplier portal can assess manufacturability by checking tolerance budgets against known process capability indices. In this way, CAD ceases to be a picture and becomes a contract that software can reason about, paving the path for truly intent-aware automation.

• STEP AP242 carries geometry and PMI for interoperability across vendors.
• QIF structures measurement plans and results to close the loop to design.
• DMIS remains common in CMM controllers, with translators to QIF-based pipelines.

Shop-Floor Communication: MTConnect, OPC UA, umati, ROS-Industrial, and ISA Layers

On the machine side, visibility and control require standardized communication. MTConnect, championed by AMT and advocates like Dave Edstrom, normalizes read-only telemetry across machine tools—spindle speeds, feeds, alarms, part counts—via a vocabulary and XML/JSON transports. Its deliberate read-only design lowered risk and accelerated adoption, making it a de facto baseline for shop monitoring. For typed, secure, bidirectional interaction, OPC UA from the OPC Foundation (with leaders such as Stefan Hoppe) provides a rich information model, built-in security, and a service-oriented address space. The umati initiative led by VDW/VDMA builds machine-tool profiles on UA, so a controller can present capabilities—axes, channels, tool data, and job states—in a consistent way. Robots bring their own ecosystem: ROS-Industrial adapts the Robot Operating System to manufacturing, enabling modular perception and motion nodes to integrate with PLCs and HMIs. For discrete machines and packaging lines, PackML and ISA-88 define state models, recipes, and modular unit operations; ISA-95 maps the layers between enterprise systems and control systems. Together, these standards turn islands of proprietary signals into a fabric of understandable, composable services. Crucially, they align semantics—what does “Executing” mean across vendors? what is a “ToolLife” record?—so orchestration software can reason across fleets without per-machine hacks.

• MTConnect: normalized telemetry for visibility and analytics (read-only by design).
• OPC UA + umati: typed, secure, vendor-agnostic control and capability models.
• ROS-Industrial, PackML/ISA-88, ISA-95: state machines and integration layers that unify robots, cells, and enterprises.

Additive Manufacturing Pipelines: STL, AMF, 3MF, and Fleet APIs

Additive brought its own data stack. The venerable STL triangulates surfaces and ignores units, colors, and material semantics, yet remains the lingua franca for printer motion because of its simplicity. To move beyond the limitations, AMF (ISO/ASTM 52915) introduced units, materials, lattices, and color; 3MF, created by a consortium including Microsoft, Autodesk, Dassault Systèmes, and others, emphasized a modern, open package for geometry, metadata, materials, and build instructions. At the fleet level, vendors recognized that orchestration requires APIs: OctoPrint, created by Gina Häußge, exposed printer control over HTTP and WebSocket, inspiring toolchains for hobbyist farms and small labs; Ultimaker Digital Factory, Formlabs Dashboard, and Stratasys GrabCAD Print brought fleet management to professional and industrial environments, enabling job queuing, monitoring, material tracking, and traceability. The additive world also normalized slicing as a programmable step—algorithms for lattice infill, supports, and orientation can now be automated, and results can be re-associated with the source CAD via component identifiers. As additive moves deeper into regulated industries, these APIs are increasingly tied to provenance—who sliced it, with which parameters, on which build, and with what post-processing—connecting directly to the broader digital thread of design, qualification, and inspection.

• STL remains ubiquitous but is semantically thin; AMF and 3MF enrich content.
• Fleet APIs from Ultimaker, Formlabs, and Stratasys enable lights-out orchestration.
• Automated slicing and lattice generation are becoming first-class programmable steps.

Cloud-to-Edge Plumbing: REST, gRPC, MQTT, and Deterministic Loops

Turning standards into operations requires reliable, secure plumbing. Control planes increasingly speak REST and gRPC, making capabilities and jobs addressable resources with versioned schemas. Event streams ride on MQTT, AMQP, or Kafka, decoupling producers (machines, sensors, vision nodes) from consumers (dashboards, alerting, optimizers). At the edge, containerized runtimes—Docker and lightweight Kubernetes distributions like K3s—host protocol gateways, data historians, ML inference, and safety supervisors close to the workcell. When cyclic determinism matters, e.g., for robot coordination or multi-axis synchronization, Time-Sensitive Networking (TSN) and real-time fieldbuses keep control loops local while the cloud orchestrates state and policy. The pattern is: push decision authority as far to the edge as necessary for safety and latency, while keeping orchestration declarative and portable. This separation of concerns mirrors modern distributed systems: strong contracts at the API, idempotent commands, and backpressure-aware event streams. The outcome is a plant that behaves like a distributed application—composable services, observable state, and well-defined failure modes—rather than a collection of bespoke, fragile integrations.

• REST/gRPC for control APIs; MQTT/AMQP/Kafka for eventing.
• Docker/K3s enable manageable, updatable edge runtimes.
• TSN preserves determinism where microsecond-level timing matters.

Security and Trust: From Controller to Cloud, Identity is the Interface

As machines become services, the attack surface expands, making security a first-class design requirement. OPC UA bakes in authentication, authorization, and encryption, aligning with enterprise public key infrastructures and certificate lifecycles. At the architectural level, a Zero Trust stance at the edge treats every device, container, and user as untrusted until proven otherwise, enforcing least privilege and continuous verification. Industrial cybersecurity frameworks such as ISA/IEC 62443 guide network segmentation, secure remote access, patching strategies, and supplier risk management. Beyond confidentiality and integrity, manufacturing needs traceability: provenance chains that bind CAD revisions, CAM settings, machine parameters, and measurement results into an auditable ledger. Whether implemented with conventional databases or append-only mechanisms, this “digital thread” ensures that when a nonconformance appears, teams can answer what changed, when, and why. Security is not just firewalls; it’s identity, policy, and provenance that travel with the job—from PLM to cell to CMM and back—so that orchestration can be both agile and compliant. Without it, software-defined manufacturing would collapse under the weight of trust assumptions, regulatory requirements, and the real-world hazards of connecting heavy machinery to networks.

• OPC UA Security provides cryptography and identity for machine interfaces.
• Zero Trust at the edge enforces least privilege and continuous verification.
• ISA/IEC 62443 and provenance chains strengthen the digital thread end to end.

Platforms, People, and Products: CAD-Driven Orchestration in Practice

CAD/PLM Suites That Push Executable Intent

Major design and manufacturing platforms have spent a decade turning product intent into executable operations. At Dassault Systèmes, Bernard Charlès championed the 3DEXPERIENCE vision linking CATIA and DELMIA, so the same model that defines a part can simulate and then deploy robot and machine programs—virtual commissioning as a precursor to real commissioning. Siemens, under Tony Hemmelgarn, connects NX to SINUMERIK, Opcenter, and MindSphere, aligning with OPC UA and umati profiles to make lines discoverable and orchestrable. PTC, led by Jim Heppelmann, pairs Creo with ThingWorx for industrial IoT integration, while Onshape, founded by Jon Hirschtick, brings cloud-native APIs and webhooks that trigger release-to-make pipelines as soon as a design version is approved. Autodesk, guided by Andrew Anagnost, uses Fusion 360 Manufacture and Platform Services (formerly Forge) to automate CAM, nesting, and job dispatch to partners or in-house cells. Across these ecosystems, the common thread is that CAD data—augmented with PMI, material specs, and manufacturing rules—sets off a cascade: generate toolpaths or print files, verify with simulation, package with capability constraints, then schedule to machines that publish their availability and health via standard interfaces. The platforms are converging on the idea that the file you send is not a static artifact but an executable declaration of intent enriched with context and policies.

• Dassault Systèmes: CATIA/DELMIA/3DEXPERIENCE for virtual-to-real commissioning.
• Siemens: NX + SINUMERIK + Opcenter + MindSphere with OPC UA/umati alignment.
• PTC: Creo + ThingWorx; Onshape APIs/webhooks for release-to-make automation.
• Autodesk: Fusion 360 Manufacture and Platform Services for CAM and dispatch.

Additive-First Orchestration: From Slicing to Lights-Out Traceability

Some of the most advanced orchestration has emerged in additive manufacturing, where machines are natively digital and fleets are common. Oqton Manufacturing OS, co-founded by Ben Schrauwen with leadership contributions from Samir Hanna, automates scheduling, labeling, lattice generation, and quality routing across multi-brand printers and downstream inspection. Materialise CO-AM and its Streamics heritage provide enterprise-grade job preparation, routing, and traceability that bind design parameters to machine logs and post-processing steps. Printer ecosystems such as Formlabs (Max Lobovsky), Prusa, Ultimaker, and Stratasys expose fleet APIs that allow lights-out operations: automated queuing, material and resin management, camera-based monitoring, and certificate-ready build records. What distinguishes additive-first stacks is their comfort with variability: lattice structures, orientation tradeoffs, support strategies, and build compensation are not exceptions—they are core. This variability demands declarative, repeatable pipelines and rich metadata to ensure that every knob turned by algorithms is recorded and replayable. It is also a proving ground for closed-loop control: in-situ sensors feed anomalies to analytics that adjust parameters or pause jobs, pushed through APIs rather than manual intervention. These patterns are now informing how subtractive and hybrid cells evolve their orchestration models.

• Oqton automates scheduling and geometry pipelines across heterogeneous fleets.
• Materialise CO-AM unifies job prep, routing, and compliance-grade traceability.
• Printer ecosystems (Formlabs, Ultimaker, Stratasys) enable fleet-level APIs.

No-Code/Low-Code and Machine-Cloud: Democratizing Integration

Modern factories need agility, not just scale, and that means front-line engineers must be able to adapt systems without waiting months for custom software. Tulip exemplifies this with operator app builders and connectors that integrate machines, sensors, and MES logic through drag-and-drop widgets and node-based flows. Vention MachineCloud, led by Etienne Lacroix, extends browser-to-machine deployment for modular automation equipment, so a design assembled online can be commissioned on the floor with minimal friction—electronics, firmware, and safety logic pre-integrated with configuration-driven behavior. Bright Machines, steered by Amar Hanspal, packages microfactory cells with software-defined pathways that can be retargeted to new products through configuration, not custom code. The unifying idea is that manufacturing logic is declarative: define states, transitions, and data bindings; connect to MTConnect or OPC UA sources; publish events to MQTT; and let operators see and act on context-rich information. These tools do not replace the need for deep controls expertise, but they distribute capability: an industrial engineer can connect a CMM result to an SPC chart and then trigger a rework task without writing a monolithic application. As more vendors adopt embedded APIs and profiles, low-code orchestrators will compose them like microservices, accelerating continuous improvement.

• Tulip enables operator-centric apps with plug-and-play connectors.
• Vention MachineCloud streamlines browser-to-machine deployment.
• Bright Machines packages reconfigurable, software-defined microfactories.

CNC and Robot Connectivity: APIs Behind the Iron

At the edge, enabling orchestration means exposing the “guts” of controllers through stable interfaces. On CNCs, Fanuc FOCAS, Siemens SINUMERIK APIs, Heidenhain DNC channels, and Haas Ethernet interfaces provide access to program management, tool tables, offsets, and status registers—capabilities that, when bridged via OPC UA or MTConnect, become part of a plant-wide vocabulary. Robots add their own SDKs: URCaps for Universal Robots, ABB RobotStudio SDKs, and ROS-Industrial bridges let orchestration software load programs, adjust parameters, and query safety states. The trend is toward publishing standard state machines (e.g., “Idle,” “Executing,” “Held,” “Complete”), typed parameters (e.g., tool wear models), and transactional operations (e.g., atomic program updates) rather than relying on file drops in watch folders. This shift clarifies failure modes and enables robust rollbacks: if a program update fails capability checks, it is rejected; if a tool exceeds life thresholds, the schedule can be automatically adjusted. As these interfaces converge on open profiles like umati, the gap between a multi-brand cell and a coherent, software-defined resource shrinks dramatically.

• CNC APIs: FOCAS, SINUMERIK, Heidenhain, and Haas Ethernet services.
• Robot SDKs: URCaps, ABB RobotStudio, and ROS-Industrial bridges.
• Standardized states and typed parameters simplify orchestration and recovery.

Market Integrators and Networks: Manufacturing as an API

Sourcing and quality are becoming programmable, too. Xometry and Fictiv expose procurement as an API, where a CAD file with PMI becomes a priced, lead-time-validated quote, and job status can be polled or subscribed to as events. This “manufacturing-as-API” paradigm pushes standardization upstream: to make pricing predictable, the model must unambiguously encode tolerances, materials, finishes, and inspection levels. On the quality side, Hexagon’s Nexus and metrology suites—including PC-DMIS with QIF bridges—help close the loop by aligning measurement plans with design intent and pushing results into SPC and PLM. These networks create a feedback economy: heterogeneous shops can signal capacity and capability; orchestrators can route based on cost, quality history, and risk; and digital threads can travel with the work from design office to supplier floor and back. The more machine-level semantics are standardized, the more these marketplaces can move from quoting files to negotiating executable intent—“I can meet this flatness with this process at this yield”—turning what used to be manual vendor management into an algorithmically assisted, intent-aware supply chain.

• Xometry and Fictiv expose pricing and lead times via programmable interfaces.
• Hexagon connects metrology (e.g., PC-DMIS) to PLM through QIF.
• Executable intent improves routing, quality, and supplier collaboration.

Conclusion

From File Drops to Intent-Oriented APIs: The Arc, Frictions, and Convergence

Manufacturing has moved from paper tape and DNC file drops to an era where machines are increasingly exposed as secure, typed services. The arc of change is clear: we are replacing ad hoc postprocessor tribal knowledge with orchestrators that consume PMI-rich AP242 models, consult standardized capability profiles, and deploy jobs through APIs that enforce identity and policy. The hard parts are equally clear: legacy G-code isn’t going away overnight; deterministic, real-time control must coexist with cloud-scale analytics; cybersecurity at the edge must be engineered, not assumed; and the semantics of the digital thread must be governed across organizations and lifecycles. Yet convergence is happening. MTConnect provides a common heartbeat; OPC UA/umati expresses typed capabilities; QIF closes the quality loop; and modern cloud-to-edge stacks make it feasible to orchestrate at scale without sacrificing safety. What was once a vision—software-defined manufacturing—is becoming the default way to think about plants: composable, observable, and governed by intent rather than file formats. The remaining work is less about inventing new acronyms and more about hardening profiles, aligning certification programs, and enabling graceful coexistence with the massive installed base of legacy controllers.

• What’s hard:
  • Interoperability across legacy G-code and controller dialects.
  • Reconciling deterministic real-time control with cloud latency and variability.
  • Cybersecurity and Zero Trust at the edge, including identity lifecycle.
  • Governance of semantics and provenance across the digital thread.
• What’s converging:
  • PMI-rich AP242 driving automatic CAM and inspection planning.
  • Telemetry via MTConnect coupled with OPC UA/umati capabilities.
  • QIF-enabled closed-loop quality feeding design and process adjustments.

What’s Next: Open Toolpath APIs, Smarter Schedules, and Resilient Edge-Cloud Meshes

The next decade will be defined by standardization and openness at the control surface. Expect momentum toward standardized toolpath/control APIs that expose motion planning as a capability—negotiated and verified—rather than a line-by-line file contract. CNC vendors will increasingly offer open, versioned interfaces for program deployment, probing, tool management, and safety envelopes, aligning with OPC UA profiles and making umati-like models the norm. AI will move from dashboards to the loop: scheduling engines will learn constraints and yields across multi-mode machines; anomaly detectors will correlate vision, vibration, and spindle load to recommend parameter changes or trigger holds; and reinforcement learning will optimize nesting, orientation, and CAM strategy selection within safety and policy bounds. Architecturally, resilient edge-cloud meshes will make orchestration robust to outages—state machines living at the cell, policies and analytics in the cloud, and TSN preserving local determinism. The most important cultural change will be treating identity as the interface: every job, tool, program, and operator authenticated, authorized, and audited end-to-end. As these capabilities coalesce, “software-defined manufacturing” will no longer be a differentiator—it will be the baseline expectation, and competitive advantage will come from how elegantly organizations compose standards, platforms, and people into a coherent, continuously improving whole.