Computer-Aided Manufacturing (CAM)

Computer-Aided Manufacturing (CAM). CAM is how a designed body becomes a manufacturing process: toolpaths, mill-turn, additive slice and machine code, sheet, EDM, and CMM programs. It answers how the machine makes the part — not what the part is.

In industry this is Mastercam / PowerMill / NX CAM-class manufacturing process capability. In N23D it is not a seat next to someone else’s stack. It is a peer module on one native Rust binary — N23D — 100% Rust we write.

Five-axis machining center — CAM owns the toolpath on the designed body

Same product. Same binary. CAM is work product on the CAD identity, not a second CAD file and not a plugin that exports a new part number. Speeds and feeds are not a vendor plugin. Materials come from MAT. A fixture is a CAD assembly. The work order and the AssetId of the machine already know the identity CAD named.

What CAM actually does

  • The pipeline is honest: CAD model, stock, fixture, machine, and tools, then setup and WCS, then operations, then cutter-location data, then verification, then post, then a shop packet.
  • Toolpaths are associative. A sketch or feature change dirties dependent operations. Rebuild is explicit. Never a background surprise that overwrites posted code.
  • CAM may tessellate, offset, and slice. It may not sew, fillet, or change design intent. Defeaturing for CAM is a derived body.
  • Material on lots, filament, powder, resin, and weld filler is a VariantId from Materials. CAM does not keep a density table. Wrong-family assign (oil onto a mill stock lot, 304 nest onto a 316 lot) is a hard fail.
  • Process families are first-class: milling (2.5D through 5-axis, router, graph mill), turning (2-axis through mill-turn and Swiss), holemaking, routing, punch and turret, shear and saw, press brake and form, laser cut / weld / clad / clean / mark, plasma, oxy-fuel, waterjet, EDM, grind, additive process, join, heat treat, inspect, assemble and bench, material handling.
  • Control mode is orthogonal to process physics: CNC, conversational, manual, hybrid. Automation: none, bar feeder, pallet, robot, coil line. A laser source is not the same as laser machine kinematics. A machine record stores source, power, pulse regime, delivery, and assist gas. Kilowatts alone are not a capable process.
  • A tool is an assembly of holder, extender, and cutter, not a diameter. Persist ISO 13399 identifiers when present. Feeds and speeds are a function of tool, material, strategy, and engagement, not a single number on the tool. Vendor cutting data is a suggestion. The operation stores the values actually used. A tool without holder geometry is allowed for 2.5D and rejected for 5-axis verify.
  • A machine is an asset, not a kinematics enum: OEM, family, model, serial, plant asset id, processes, control, controller, kinematics, work envelope, shell, automation ports. Inverse kinematics is a pure function from tool tip, tool axis, and machine state, with explicit singularity and limit errors. 5-axis output mode is a machine property: TCP (G43.4 / TRAORI), indexed G68.2, or raw joints. Strategy emits TCP and axis. Post and kinematics decide.
  • Setup binds part occurrences, stock, fixture, machine, work offset, and safety plane. Multiple setups per part. Remaining stock after each verified operation is a dexel or voxel field. Stock is not a CAD body after the first cut.
  • Neutral, machine-agnostic cutter-location IR between strategy and post. Posts must not reach into strategy internals. Generated G-code is not the editable source of truth. Hand-edited NC is a non-associative branch. G-code remains mandatory. STEP-NC is a long-term export and import IR. Do not block the first ship on AP238.
  • 2.5D milling: contour (climb / conventional, G41/G42 or in-computer), pocket (offset, raster, hybrid), adaptive and constant-engagement roughing, face mill, chamfer and deburr. Containment, tabs, islands, open pockets. Lead in and out as line, arc, ramp, helix. Rest 2D from previous tool diameter.
  • Holemaking: drill, peck, chip-break, tap, bore, ream, helical mill, thread mill. Feature holes from the CAD hole wizard and recognized cylinders.
  • 3-axis: parallel and raster finish, waterline, steep-and-shallow, scallop, pencil and leftover, horizontal and vertical area detection, projected curve, stock-aware rest, holder collision using the tool assembly silhouette.
  • Indexed 3+2. Simultaneous 5-axis swarf. Surface-normal plus lead and lean. Tool-axis limits. Collision-aware axis smoothing. Retract-and-reorient versus interpolating through a singularity is a user choice. Output TCP or indexed per machine.
High-tonnage press brake — sheet CAM is not only milling
  • Turning: OD/ID profile, facing, groove, cutoff, thread. Bar pull and stock update. Canned cycles mapped per controller. Live-tool drill and mill on C axis. Tool orientation with ID boring-bar collision.
  • Plate processes (laser, plasma, waterjet, router): closed contour cut with kerf compensation, lead-in and out that does not scar show faces, pierce and ramp rules, consume a nest, common-line cut, tab and micro-joint. DXF/DWG in, NC out.
  • You cannot nest onto a 4×8 you typed. You nest onto a source lot whose size happens to be 4×8. Quoting may use a catalog size. Releasing a nest reserves a real lot. Source lot is inventory: form (sheet, plate, coil, bar, tube, billet, AM build plate, remnant), VariantId, spec, heat/lot/cert, nominal size, usable envelope, grain/fiber/brush, face finish, kerf defaults, mass, status, parent lot, geometry. Remnant is a child lot with polygonal or 3D geometry. Status: available, reserved by nest, consumed, remnant or scrap. Deleting the nest releases the lot. Every produced instance records lot and placement for heat-number traceability. Gauge tables live on the lot’s material, not in the nest UI. 10 gauge steel is not 10 gauge aluminum.
  • 2D nest: rectangular pack and true-shape pack, kerf-aware spacing, sheet-edge margin, optional part-in-hole fill, common-line candidates, grain and brush lock, manual override then re-check, yield report, export as CAD assembly instances plus DXF. Mix of part numbers on one lot, or one part number times N. Overflow across multiple lots. Unplaced list with reason. 1D bar and tube cut list: part lengths, kerf, face-mill allowance, min remnant, pack onto defined bar lengths, remnant bar returned if above min usable length.
  • Machine family catalog plus machine instance on the floor (serial, plant location, installed pose, calibration, current tooling and automation, state, OEE priors). Every family ships at least a coarse envelope solid. Collision verify uses this, not an infinite XYZ cube. Service shell required: volumes that must stay empty for doors, panels, filter carts, chip wagons, fork access. Occupying a service volume is a hard warning. Operator load access and robot load access are different volumes. Shells are CAD assemblies, not screenshots. Envelope is not travel: record axis travel, usable part box after vise/chuck/slats, max mass, min feature, lathe swing. A nest or setup that exceeds the usable part box fails before toolpath. Automation ports: kind, side, physical and logical interface, payload, compatible equipment. Compatibility is a join, not a hope. Users can author a machine family. OEM packs are signed and versioned. Shop instance calibration never lives in the OEM pack. Manual methods use the same asset schema with control mode manual, no post pack, a labor standard instead of NC time, still a floorprint and access volume. Capability query: given a part (size, material, thickness, tolerance, process intent), which instances on this floor can run it. Seed OEM library is schema plus seed catalog, not a dump of all machines from all makers.
  • Shop-floor discrete-event simulation: throughput, queues, labor, bottleneck, OEE. Not toolpath verification and not FEA. Cycle time for a CNC step defaults to verified CAM time plus statistical setup and downtime. Do not invent a 4-minute mill cycle when the posted program is 11:20. Discrete-event engine in Rust: arrival, setup, cycle, fail, repair, shift end. Machine eligibility from the capability query. Labor contention. Calendars and random downtime from MTBF/MTTR. Compare scenarios (add a second laser, add a loader, change batch size). Report bottleneck, throughput versus demand, late work orders. Simulation may read posted cycle time and nest yield. It may not generate toolpaths. A part whose envelope exceeds every mill on the floor is unroutable before the sim runs. Simulation informs planning. MES runs the day. The PLC scans milliseconds. Do not collapse those three.
  • Additive process: hardware and toolpaths. Design for AM stays in CAD. Do not implement a second slicer. Assign filament lots to AMS/MMU slots or extruders. Reject incompatible pairs (TPU on AMS Lite, carbon fiber on brass 0.4). Slice against bound nozzle diameter, line width, layer height, volumetric-flow cap. Supports: same-material, breakaway, soluble. Multi-material paint from CAD regions to tool and slot changes plus purge volume. Purge is process time and scrap mass, visible to shop simulation. 3MF in, machine code out (Marlin, Klipper, Bambu, OEM LPBF). Build-plate nest from the nest module. An AMS is a buffer, not four hotends. Moisture-sensitive lots expire.
  • Laser optical train, not just kilowatts: source, wavelength, power, beam quality, collimator, focus lens, protective window, nozzle, assist gas, delivery. Focus position as a process parameter per material-thickness-gas. Nozzle standoff closed-loop. Pierce recipe separate from cut feed. Kerf model from optics and gas, not a typed 0.2 mm. Thermal-lensing warning when window hours exceed the family limit. 2D flat, tube, and 5-axis or robotic laser share the train. Kinematics differ. Weld mode: keyhole versus conduction, wobble, filler, scan-field. Different recipe, same train family.
  • CNC press brake consumes the CAD unfold. It does not invent K-factors. Import the sheet-metal part and bend table (K-factor and deduction already bound to a tool pair). Tool select from library. Reject over-tonnage and too-narrow V for thickness. Collision: side frames, ram, punch, die rail, backgauge fingers, previous flanges. Bend sequence search with flip count and gauge reach. Backgauge program (X, R, Z1/Z2, X1/X2). Native posts: Delem, Cybelec, ESA, Amada, TRUMPF, LVD, Bystronic class. Setup sheet: tool stations, segmented punch map, first-piece angle check. A five-bend box finds a sequence, no side-frame hit, tonnage under rating, a Delem-class program, and a flat length that matches the CAD unfold within shop table tolerance.
  • Robot offline programming. Robots are machines (six-axis plus externals). This module authors tasks: machine tend, arc weld, 5-axis laser, brake follow, tend and flip, material handle. Cell layout in shop coordinates. TCP frames for grippers, torches, laser heads, with payload and inertia. Reach and collision versus jig, part, machine shell, cables as coarse capsules. Targets from CAD faces, weld PMI, nest placements, not only joint jogging. Posts: FANUC LS/TP, KUKA KRL, ABB RAPID, UR URScript, Yaskawa INFORM, plus OEM brake-robot packs. Calibration hook: measured base, TCP, and part-frame offsets dirty the program until re-solved. I/O handshake map to the machine automation port (door, clamp, cycle start, part-in-position). A robot is not a 6-axis mill with a different post. Share kinematics and collision, not strategy crates.
  • Verification is a product, not a viewer. Backplot of cutter location and of posted G-code. Parse the post output. Posts lie. Remaining stock after each operation. Gouge check. Collision of tool, holder, arbor, rotary head, table, fixture, tailstock. Rapid-through-stock detection. Shaft and holder rub during finish. Report first fault location, operation id, joint pose. Deliberate rapid through stock must fail. Deliberate holder collision must fail. A clean job must pass and produce a stock mesh. Voxel removal at CAMotics class is the minimum bar for 3-axis. 5-axis requires the same stock field plus full kinematic collision.
  • Cutter location to text engine in Rust. Controller packs: Fanuc-class mill, Haas NGC, GRBL/LinuxCNC, Siemens 840D subset. 5-axis: TCP on and off around indexes, Euler versus RPY for G68.2. Unit test each pack against golden NC. Parse posted output back to cutter location for verify-after-post. A job records post id, post revision, and property bag so yesterday’s NC is reproducible. Python is not the post language for the product core. Mazatrol export is out of scope. Mazak ISO pack only. Robot posts live with the robot module, not a mill post with more axes.
  • Shop packet: tool list with stickout, holders, offsets. Setup sheet (origin view, vises, WCS). Estimated cycle time from cutter location, rapids, and toolchange. Work offset list. Operation comment block in NC.
  • Machine instances belong to a legal entity, the plant’s company. 100% Rust we write. No C, C++, or Fortran CAM kernel as a product dependency. No linking OpenCAMLib, ModuleWorks, or Parasolid as the CAM engine.
Lathe turning on the shop floor — turning setups from the same CAD identity

How N23D puts this in one place

Most stacks fail the day after save, when the model, the ticket, or the invoice becomes someone else’s import. N23D removes that day. This module reads the same record as the others.

  • one native Rust binary: N23D. 100% Rust we write. No vendor kernel, ledger, PLC runtime, HRIS, or ITSM as the source of truth. File readers and protocol bridges are interchange.
  • One identity plane: Item, VariantId, Person, and AssetId are global. Invoice, work order, inventory, quote, pay result, and NCR sit on a LegalEntityId.
  • One digital thread: modules read the same record. There is no daily STEP shuffle as the workflow. Check-in is PLM save. CAM does not fork the body.
  • Command::Core is the identity and policy plane. CCB is the full-spectrum change spine (not a second vault). TIX holds operational life of assets; ERP sees only the financial view.
Selective laser melting build — additive CAM on a bound machine profile
  • Materials only from MAT. CAD selects VariantId. Missing density means mass is unknown — we do not invent a number so a BOM or plot closes.
  • ERP is one company’s books. BUS holds HR, org, legal entities, and group consolidation. HoldCo is not a plant. No fake Form 1120. No fake Lohnsteuer.
  • Associative FaceId plus body revision. CAM may not sew, fillet, or change design intent.
  • Authoritative slice and machine code live in CAM. Additive binds a part to a machine-instance profile (AssetId).
  • CMM programs inspect the same VariantId the drawing claims. TIX holds the CMM as an asset; CAM holds the program.
Waterjet cutting cell — nest and cut without forking the body

What we will not fake

This is the product promise, not a claim that every solver and every pack already ships in the binary today. Industry-class names below are capability equals. They are not products we ship.

  • We do not ship Mastercam or wrap a vendor CAM kernel and call it ours. File readers are interchange.
  • CAM does not fork the body. A jig is not a vise checkbox pretending to be design.
  • Sheet-metal K-factor is a process number on the tool pair, not a material scalar invented in CAM.

If CAM still dumps a new file that PLM must reimport, we failed. The process and the body are the same record.

HAAS CNC machining center — mill CAM on production iron

Natively connected, not glued together

N23D runs one data model across design, make, operate, and the business. Nothing is exported as the daily path. Nothing is re-keyed. Nothing is lost in translation between vendors.

CNC mill with robot tending — automated CAM execution on the floor
  • One data model. A part, an order, a nonconformance, a ticket, and a change point at the same objects. No mapping tables, no nightly sync, no drift.
  • No export/import loss. Geometry, tolerances, revisions, asset state, and history stay intact because they never leave the system as the daily path.
  • Auditability by default. Every change is versioned and attributable, so traceability is a query, not a project.
  • Speed. 100% Rust: native performance, small footprint, no runtime surprises.
  • Sovereignty. Your data, your infrastructure, your rules. No lock-in.