For years, owning an industrial metal printer has usually meant owning its software too. The build-prep suite that came with the machine decided how parts were oriented, supported, sliced and scanned, and the machine would only run files from that suite. On November 17, Seattle-based Dyndrite and French OEM Fives AddUp announced a partnership to integrate the FormUp metal printer range into Dyndrite LPBF Pro. The companies say this will be the first time Fives AddUp customers can produce parts on FormUp machines from build files created outside AddUp's own software suite. The release, datelined Seattle and Cebazat, France, calls it an "industry first" for Fives AddUp. FormUp owners are due to get Python-driven automation of build preparation and laser parameter control down to the individual vector, but the software is not out yet: the FormUp build processor is in active development and is expected to reach AddUp early adopters in the New Year.

The news reached most of the industry through Formnext, where TCT Magazine reported the integration on November 19. TCT also pointed out that it follows a similar Dyndrite partnership with Xact Metal set up the week before. Two laser powder bed fusion (LPBF) machine builders have now opened their platforms to the same third-party toolchain within about a week.

What Actually Changes on a FormUp

In practical terms, once the integration ships, a FormUp operator will be able to prepare a job in Dyndrite LPBF Pro and send the result to the printer, instead of being limited to AddUp's native workflow. The announcement says users can work in either the AddUp suite or Dyndrite LPBF Pro. It describes what the Dyndrite toolchain covers:

  • Scripted build prep. Positioning, nesting, labeling, support generation, slicing and toolpathing can be automated in Python and saved as repeatable "build recipes."
  • Vector-level parameter control. Dyndrite's toolpath APIs let users assign laser parameters and scan strategies at the vector level, which the release says gives access to all manufacturing parameters sent to the machine.
  • Materials and process development. The release lists accelerated materials and process development as a capability, which it says enables new materials, better surface finish and printing low-angle, support-free overhangs.
  • Multi-optic support. Users can assign, balance and coordinate work across multiple lasers, including control over how lasers share a part.
  • Interoperability. Users select a machine from a list of compatible OEMs and generate the build file, so the same Python toolpath recipe can drive FormUp machines alongside other systems on the shop floor. TCT describes this as carrying the same workflow across other OEM machines in a fleet.

The release describes the result as "direct, programmatic access" to the LPBF process for FormUp users, and TCT repeats the phrase. That sums up the deal: the printer is no longer a black box behind a vendor GUI. It becomes a target that engineers can drive from code.

Why Recipes Beat Clicks

Python scripting matters most to shops that build the same kinds of parts again and again. In a GUI-driven workflow, each build is prepared by hand. An operator orients parts, packs them onto the plate, adds supports, slices and checks the result. Two operators can produce two slightly different builds from the same geometry, and reproducing a good build months later depends on someone's notes.

A build recipe turns those decisions into code. If positioning, nesting, labeling, supports, slicing and toolpathing are all defined in a script, running it on the same inputs should give the same build. Dyndrite says a build strategy becomes code that can be versioned, shared, qualified and rerun, and it can be reviewed and audited like any other engineering artifact. For regulated production, where traceability is often half the work, that matters.

Advertisement

The vector-level control is aimed at a different user: the process engineer. Laser power, speed and scan strategy determine how the melt pool behaves, and that in turn affects density, surface finish and residual stress in the finished part. Setting those parameters per region is common. Setting them per vector, through an API, lets engineers try strategies that a vendor's preset menus may never offer. That is also why Dyndrite pitches the integration around materials and process development. When parameter experiments are written as code, they can be generated, varied and repeated systematically instead of entered by hand.

The Bigger Pattern: Decoupling Software From Iron

The more significant point is strategic. The release frames this as the first time FormUp customers can print from build files made outside AddUp's own suite, and that is an unusual concession for a machine builder. A proprietary software stack tends to tie a customer to one vendor. Opening the machine to a third-party toolchain gives up some of that hold in exchange for appealing to customers who don't want it.

Those customers are often the ones running mixed fleets. The ability to carry one workflow across other OEM machines is the key detail. A service bureau or production shop with LPBF systems from several vendors normally has to maintain separate build-prep workflows, separate training and separate parameter libraries for each one. A shared, scriptable layer across the fleet could mean one set of recipes, one skill set and one codebase.

The timing points to a trend. With Xact Metal announcing a similar partnership a week earlier and Fives AddUp now following, Dyndrite appears to be collecting OEM integrations quickly, and Formnext was a natural place to announce them. Harshil Goel, Dyndrite's founder and CEO, called Fives AddUp "another OEM that recognizes the importance of openness." Whether that signals a broader shift is our reading rather than something either company says, but it fits the pattern: machine builders increasingly seem to treat an open, programmable build-prep layer as a selling point instead of a threat.

What It Means for Makers

Most FilamentFeed readers won't be buying an industrial LPBF system soon, and the announcement gives no pricing or licensing details for either product. Still, the shift deserves attention, because the desktop world has seen this argument before. Hobbyist FFF printing grew around open file formats and slicers that work with any machine. Metal powder bed fusion has mostly gone the other way, with closed pipelines tied to each vendor.

Announcements like this one suggest the industrial side is slowly moving toward the model makers already know: the machine runs the job, and the user picks the software that defines it. For engineers who already script their work in Python, being able to define a metal build as code with control down to individual laser vectors is a meaningful change. For anyone choosing an LPBF platform, whether a machine accepts outside toolchains is becoming a reasonable question to ask before buying.

There are open questions. The announcement doesn't explain how validated AddUp parameter sets carry over into Dyndrite-generated builds, or how support and warranty work when a third-party toolchain prepares the build file. Shops considering the switch should ask both companies those questions directly. For now, the news is that FormUp machines are set to stop being tied to one software suite once the integration reaches early adopters next year.

Sources