What this is not
Every limit below is one we would have to explain in the first project meeting anyway. It is cheaper for both of us if you read it now. None of it is a roadmap promise — it is the state of the code, and the state of what has actually run on a real cell.
The simulator is not a safety function
It is an auxiliary engineering tool. It is not a safety function within the meaning of the Machinery Directive, it is not assessed as one, and it does not replace the cell’s own safety systems — fencing, safety controller, the dual-channel emergency stop chain, speed and space limitation. Collision checking, soft axis limits and the proximity guard reduce the number of ways a program can be wrong before it ever reaches the controller. They do not make a wrong program safe.
One consequence we built for rather than argued around: the emergency stop path depends on neither the internet nor an open browser window. The real stop is the dual-channel chain on the pendant. A button in an interface is convenience, not protection.
Where the edges are
- Process
One proven process: milling
Milling is what has run in production, on real parts, for a long time. Polishing, finishing, painting and large-format printing sit on the same continuous contact-path maths and are the nearest ports — but “nearest” is not “done”. Machine tending is a different class of motion entirely: no toolpath, but points, grippers, I/O handshakes with the machine and part-presence checks. Cell model, collisions, calibration, bridge and operator window carry over; the motion layer is written new. Which of the two you are asking for will be stated in the quote, not blurred in it.
- A new robot model
A different arm is a calibration campaign, not a checkbox
The kinematic model is parameterised, not hard-wired: link geometry, axis limits and mounting arrive from the cell document, so describing another arm does not mean a different build. What does not come for free is trust in the numbers. Every constant we run today was taken from a real controller backup and carries its source, and that is the standard a new model has to meet as well — its data assembled, the tool centre point re-verified on the machine, the arm checked through its own limits. There is one risk in that step we will not bury in a footnote: moving from hand-calibrated frames to generic catalogue frames can shift the TCP. So a new robot model is quoted as the work it is, with the verification included, rather than waved through as a setting.
- A different controller
The post-processor is written for your controller, inside the delivery
Everything above the controller is vendor-neutral by construction: the kinematic core is a pure function, the cell is a document, the robot arrives as a parameter, the mounting is floor, track or pedestal. Two things sit below that line and are written per controller — the post-processor that emits the program, and the driver that talks to the machine while it runs. The current production adapter writes RAPID and speaks to an IRC5 over RWS, which is what production has proven. For another controller both are engineered and verified on your cell, as part of the project: a line in the estimate with a scope and a price, not a switch in a settings panel and not a promise that it already exists. What that port contains is laid out below.
- Cell size
Two robots proven, not four
Multi-robot is native in the parts that are expensive to retrofit: a robot roster in the cell document, per-robot addressing, isolated state per window, and a check that refuses to send a command into the wrong controller. What is pairwise today is the neighbour ghost and the proximity guard — they watch one neighbour. With two robots that is complete, and on a live cell it has stopped both machines without a human in the loop. With three or more it is not: an all-pairs guard is required work inside the project, before a third arm shares the workspace.
- Collisions
Collision checking is sampled
Batch checking walks the trajectory with a stride. A collision short enough to happen between two samples can go unnoticed. That is a deliberate trade for being able to check hundreds of thousands of points in a browser tab — 118 417 of them on the current cell — and it is exactly why the first run on real hardware is done at reduced speed with a hand on the pendant. Simulation removes surprises; it does not remove care.
- Delivery
No self-service, no sign-up
There is no trial to register for and no download that configures itself. Every delivery starts with looking at your cell, your part and your controller. That limits how fast we can start and how many cells can run at once — and it is also why what ends up installed matches the machine that is actually standing in your workshop.
- Team
One engineer builds this (bus factor 1)
The code, the cell model and the deliveries are one engineer’s work. That is the honest risk of working with us, and the answer to it is not a promise to hire. The answer is contractual: source handover, written documentation and runbooks as part of the delivery rather than after it, and source escrow if you want it — a subject for the contract, not a topic to be steered around. The application also runs standalone, with no backend and no bridge, so a cell that is running keeps running.
What a port actually contains
The line between “ours” and “per controller” is not a slogan; it is where the code is cut. Above the line nothing knows which brand is on the nameplate. Below it, four things do — and a port is those four, written and then proven.
Above the line — the same for every controller
- The cell document: roster of robots, mounting on floor, track or pedestal, tool and work-object frames.
- Kinematics and inverse kinematics with soft joint limits and track placement.
- TCP calibration from four points, and part position from probed sketches.
- Toolpath import, the solver, cycle time with dynamics, the timeline.
- Collision checking and the proximity guard between robots.
- The operator window in the browser, roles, short-lived signed tokens and the append-only audit chain.
Below the line — written per controller
- The post-processor: the program language, motion instructions, configuration flags, speed and zone data, module size limits.
- The live driver: the protocol the controller speaks, telemetry, the execution pointer, program upload, frame reads and writes, panel state.
- The backup reader: where base frames, axis limits and calibration constants are read from — a controller backup, not a spreadsheet.
- The identity check: how the controller names itself, so a program cannot land in the wrong machine.
How a port is done
- A backup of your controller and a survey of the cell. The cell document is seeded from the controller’s own numbers, each with its source.
- The post-processor, written against the controller’s language and checked on the machine at reduced speed before any part is clamped.
- The live driver, read-only first — identity, position, telemetry — then program upload, then frame writes; each step behind the same roles and audit as today.
- Your real part through the whole chain on the real cell, with your operator at the pendant.
When we would call a controller production-proven
Not before all of this has happened on that controller, on a real cell:
- A real part cut under power, from a program the post-processor produced and the driver uploaded — nothing hand-edited in between.
- Live telemetry and the execution pointer read back from that controller during the cut.
- Calibration constants read from that controller’s backup and verified on the machine.
- The same acceptance run as on the reference cell: the sample job converted twice, locally and on the server, files identical byte for byte.
Adapters today: one. ABB IRC5 — RAPID post-processor, RWS driver, backup reader — production-proven on the cell in the case study. No other adapter exists yet; the next one is written for the controller of the next project.
What is not in doubt
The limits above are narrow because the proof behind them is specific.
- 2 robotsABB IRB 6650S-125/3.5 on 20-metre IRBT 6004 tracks, one cell
- 15 mlongest plug milled on that cell
- 118 417trajectory points solved in a browser tab
- 299 filesRAPID modules byte-identical between the local and the server pipeline
Ask the awkward question
If one of the limits above rules us out for your cell, that is a useful answer and it costs one message. If it does not, the same message is the fastest way to find out what your project would actually contain.
Tell us about your robot