RobFlow V8 now runs on ROS 2, the industry-standard robotics middleware — a new foundation that lets us ship features faster and integrate more easily. On top of it, V8 adds two features for more precision and easier factory integration:

• Built on ROS 2: New features faster, more reliable performance, and easier integration with the wider robotics ecosystem.
• RobCalib — Vision-Based Calibration (Beta): In combination with Workspace referencing, this improves absolute accuracy to ~1 mm on a 300×300 mm grid, with a guided calibration you can run yourself.
• OPC UA Server (Beta): Connect Robot cells to MES and factory IT over the industry-standard OPC UA protocol — no custom integration, secure by default.

Features & changes​

Built on ROS 2​

RobFlow's core now runs on ROS 2, the industry standard for robotics. Your Flows and workflows work exactly as before, but the platform beneath them is now aligned with the wider industry — meaning new features faster, a more reliable and future-proof base, and easier integration with the growing world of ROS 2 tools and partners.

RobCalib — Vision-Based Robot Calibration (Beta)​

RobCalib improves your Robot's accuracy so its movements precisely match their intended positions — essential wherever positions are calculated rather than taught by hand, such as palletizing, vision picking, and precision insertion. Combined with Workspace referencing, a calibrated Robot reaches ~1 mm mean error on a 300×300 mm grid.

• Run it yourself: A guided four-step wizard walks you through the whole process — no technician needed.
• Live feedback: Joint-coverage and accuracy metrics update in real time, so you know the result is good before you apply it.
• One-click recurring calibration: Trigger it from a single button in the HMI for cells that recalibrate regularly.
• Import, export & restore: Move calibrations between control units, back them up, or roll back at any time.

OPC UA Server (Beta)​

The new OPC UA Server connects your Robot cells to MES and factory IT systems over OPC UA, the industry-standard protocol. Built on the official OPC Foundation specifications, any compliant MES or SCADA system can read Robot data without custom integration.

• Standards-based: Compliant with OPC 40001-1 (Machinery) and OPC 40010-1 (Robotics), so your MES sees machine states and a standardized Robot model it already understands.
• Live Robot data: Real-time state, safety status, axis positions, and speed override from the controller.
• Automatic axis detection: The axis count is detected automatically at startup, keeping up with our modular Robots.
• Secure by default: All connections are encrypted, signed, and certificate-authenticated — no anonymous access.

Setting it up

Connecting your MES or SCADA system takes two steps:

1. Point your client at the server. Connect over opc.tcp on port 4840, using security policy Basic256Sha256 and security mode SignAndEncrypt. The server generates its own certificate automatically on first start.
2. Add your client's certificate to the trust list. Upload your client's certificate (.der) in RobFlow. The server picks it up within ~200 ms — no restart and no interruption to systems already connected — and your client can then discover and read the Robot data. To revoke access later, simply remove the certificate in RobFlow.

Only clients whose certificate is in the trust list can connect, so access stays fully under your control.

• Variable based Subflow selection: allow variable-based Subflow selection within RobFlow, enabling users to dynamically call different Subflows based on a Variable's value. This is critical for high-variance applications, such as palletizing over 100 different layouts with a single master Flow.
• Improved handling of Variables connected to industrial equipment: Variables connected to protocols (like Modbus or Profinet) can be set up and edited even when the devices are offline. Additionally, you can force-run Flows in debug mode even if some devices aren't reachable.
• Better UX for handling Variables in Expression fields: Expression fields are now available in more places (HTML Nodes, Generic Button Widget HTML action, and SQL Node). Variables appear as visually highlighted in the editor, making complex Expressions easier to read.
• Advanced palletizing Node improvements: Pallet positions can now be controlled dynamically by using cartesian Variables and UX behavior, if pose dimensions don't match the pallet length, has been improved. Additionally, the Node now allows for 1-layer setup.
• Efficient Variable updates: Variable changes during a Flow run are now sent instantly instead of on a regular timer getting rid of any latency.
• Performance improvements: With dedicated efforts the performance has been improved significantly, especially while working with Modbus devices.
• Reworked UX & UI for Robot configuration: The configuration UI and UX have been comprehensively updated, now supporting auto-save and Variable preview tables for CSV.

Features & changes​

Variable based Subflow selection + Dashboard integration​

We have built a feature to allow variable-based Subflow selection within RobFlow, enabling users to dynamically call different Subflows based on a Variable's value. This is critical for high-variance applications, such as palletizing over 100 different layouts with a single master Flow.

Key capabilities:

• Dynamic Subflow property: The Subflow Node allows a string Variable to be assigned to the "Subflow Selection" field, which contains the sub Flow uid.
• Dashboard list selection: A Dashboard function/Widget allows a user to pick a Subflow name from a predefined list and store it in a Variable.
• Generic button extension: Generic button Widget was extended by an option to manually select the current button state instead of relying on activation conditions

When to use:

• Projects with many different palletizing patterns (e.g. 100) and selecting on from the Dashboard

How to use it:

• Palletizing application with different100 layouts
  1. Cleaner main Flow setup

1. Use a generic button with manual selection enabled

1. Include in the HMI

Flow export improvements​

When exporting a process that uses dynamic Subflows, you can now manually select and include all necessary Subflows. This prevents missing required files during backup or transfer.

Key capabilities:

• You can manually select and include additional Subflows when exporting a main Flow that uses dynamic Subflow Nodes.
• This increases reliability for Flow backups and transfers by ensuring all dependencies are included.

Variables​

Variables connected to industrial equipment are now more robust, allowing you to work even when devices are offline. The editor has also been upgraded with much better filtering and sorting.

Key capabilities:

• Working with offline devices: You can now create and change protocol-bound Variables (Modbus, Profinet) even if the physical device is currently offline or unreachable.
• Debug mode flexibility: You can 'force-run' a Flow in Debug mode even if it includes Variables connected to a problematic device (=offline), after receiving a clear error message.
• Better error visibility: Variables are now correctly flagged as problematic when their connected Modbus device is not working.
• Advanced filtering & sorting: New filters are available for Variables bound to protocols (Modbus, Profinet) and for Variables that are currently experiencing issues.
• Improved editor: You can now sort the name, type, and tags columns in the extended Variable Editor.
• Protocol search: The Variable selection window now explicitly shows used protocols (profinet/Modbus) and allows you to search by protocol.

UX Improvement: Smarter and More Widespread Expression Fields​

The editor for Expression Fields has been updated with a user-friendly experience (UX), and these fields are now available in more places within RobFlow.

Key capabilities:

• Visually highlighted Variables: Variables are now shown as easy-to-read visual blocks ("visually highlighted") within Expressions, simplifying reading of complex logic.
• HTML Payload Creation: HTML Nodes and the Generic Button Widget's HTML action now support Expression Fields, allowing you to use Variables to dynamically build HTML content.
• Variable-Driven Queries: The SQL Node now accepts an Expression field for the SQL Query itself, enabling you to use Variables to change what data you retrieve.
• String Support: The activation requirements for the Generic Button Widget can now use text (String) Variables.

Advanced Palletizing​

This update includes quality-of-life improvements to make creating pallet layouts faster and more flexible. Pallet positions can now update automatically, and your box grouping work is saved even if you change the layout.

Key capabilities:

• Dynamic positions: Pallet positions can be linked to dynamic Variables, meaning they automatically update whenever the Variable's value changes.
• Allowing for 1-layer**:** The requirement for a minimum of 2 layers has been removed, allowing you to technically use this for a grid with advanced layout options
• Improved UX with p****ersistent grouping: Box groups are now persistent: this means if you create a group but not assign boxes to it, navigate from in the sidebar to a different page and go back, the unused groups are persistent
• Improved UX with smart tooltip suggestions**:** Tooltip has been updated to suggest the expected length for a position.
• Streamlined Authoring: Unnecessary prompts to review sections after changing the Pallet Position have been removed, and adding a Palletizing Node no longer incorrectly refreshes the page.

Reference Groups and Coordinate System Updates​

The system for managing reference frames has been updated, ensuring linear (Cartesian) movements are calculated correctly when used inside Reference groups, and aligning the Workspace fields with the latest Reference Node.

Key capabilities:

• Intuitive behavior while removing points**:** We've improved how reference-group edits work to match physical intuition: removing a point from a reference Workspace will no longer unexpectedly move the Robot's target position. When a point is removed, the system automatically adjusts the stored values in the Node so the point's physical location remains exactly where it is.
• UI & UX improvements**:** Workspace reference editing has been updated to more intuitive UI as well as warning users of unintended

How to use it:

• In scenarios like machine tending, where a machine may shift over time, users recalibrate the Workspace. If a programmer later removes a point from that Workspace, they usually want to preserve the point's current real-world location, not recover an older pre-calibration state. This change ensures reference-group edits match physical intuition: changing a point's membership status will not unexpectedly move the Robot target in space.

Industrial protocols (TIA/UDT) enhancements + RobSafety exports/imports​

Integration with external systems like TIA (Totally Integrated Automation) and RobSafety is now more reliable and standardized.

Key capabilities:

• Clearer Variables: Variable descriptions are now included in the generated User Defined Data Type (UDT) file, appearing as helpful comments in TIA.
• Standardized Formatting: UDT files for Profinet Variables now use the correct standard encoding (UTF-8 with BOM and CRLF line endings).
• Stable Addressing: When removing a Profinet Variable with the lowest address (offset), placeholder bytes (padbytes) are automatically inserted. This prevents all other Variables from shifting their address positions.
• Safety Management: You can now import and export the safety configuration within RobSafety.

Performance, Connectivity, and Backup​

This release significantly improves performance, especially for Modbus, connection stability, and ensures that a full backup captures all your critical data.

Key capabilities:

• Network Efficiency: Variable changes during a Flow run are now sent instantly, only when needed (on-demand), instead of on a regular timer.
• Performance in general and for Modbus: Through dedicated backend changes in the backend event loop, we don’t expect any controller loss of connection anymore as well as improved closing & re-opening of connections via Modbus.
• Improved UX for lost Robot connection: If no messages are received over the Websocket for 2 seconds, the back-end connection is immediately flagged as broken, ensuring quick detection of connectivity loss.
• Complete Backup: A full backup now includes a complete copy of the SQL database, ensuring no data is missed and for easier full restore.

UX & UI Improvements for Robot Configuration​

The Robot Configuration UI and UX have been comprehensively updated.

Key capabilities:

• Reworked UX: Edits now auto-save (replacing the explicit button), and the per-section UI state is persistent when switching between sections. Import/Export is now in a kebab menu.
• Uniform UI across all tools (Modbus/TCP, SQL, CSV, etc.
• CSV Enhancements: Added a highly-requested bulk 'Add Variables' dialog and a Variable preview table with snapshot selection and download options.
• Protocol Improvements: Modbus/TCP now includes a live address-range probe, and SQL features a "connect-and-introspect" button.

Quality-of-Life Fixes​

Minor improvements have been made to the Flow editor experience.

Key capabilities:

• Editor Stability: Issues related to managing connections (edges) when adding or removing condition Nodes and split Nodes have been fixed.
• Resume Capability: Flows can now correctly resume execution after being paused because Robot movement was blocked by engaged brakes.

Bug Fixes​

This release addresses several key issues for reliability and a smoother authoring experience.

Key capabilities:

• Variable protection: You can no longer accidentally change read-only Variables during a Flow run, such as through a Generic Button or Set Variable Widget.
• Flow start: A bug that prevented Variables from resetting to their initial value when a Flow started has been fixed.
• Protocol stability: Corrected Profinet UDT file encoding (UTF-8 with BOM and CRLF line endings) and fixed an issue where removing a Variable could shift the memory addresses of subsequent Variables.
• Tool stability: The "used in" filter in the extended Variable editor now correctly shows Variables used in associated Subflows, and HTTP response content is no longer lost on re-mount.

• Redesigned UI: Ground-up overhaul with a centralized bottom action panel, moveable 3D visualizer, fully responsive layouts down to 512px, and modernized menus across the entire application.
• 6x Faster Load Times: Optimized rendering and intelligent Node caching deliver 6x faster initial Flow loads and 4x lower RAM consumption.
• SQL Query Node: Execute queries against PostgreSQL, MySQL/MariaDB, and Microsoft SQL Server directly from a Flow.
• HTTP Node: Perform HTTP requests natively within Flows to connect to REST APIs, webhooks, or ERP systems.
• CSV Node & Download Widget: Collect, transform, and export tabular data during Flow execution with a Dashboard download Widget for operators.
• Advanced Palletizing Update: Improved palletizing Node with bug fixes, Variable bindings to box groups, and faster configuration.
• Profinet & Modbus Variable Bindings: Bind Variables directly to Profinet I/O fields and Modbus registers with unified native bindings.
• Beta Features: Early access to Auto-Layout.

Features​

Redesigned User Interface​

RobFlow v7 delivers a ground-up UI overhaul focused on operator efficiency, spatial clarity, and responsive design. Every major interface element has been rethought to reduce clicks, improve orientation in complex Flows, and adapt to any screen size.

Key capabilities:

• Centralized bottom action panel: Play, Pause, Debug, Flow Config, Jogging, Run Single Node, Run & Skip Movement Until Node, Move Back to Trajectory, Resume from Current Location, Subflow Outputs, and Dashboard Config — all consolidated into one intuitive bottom panel.
• Moveable & expandable 3D visualizer: The Robot visualizer has been relocated to the left side of the screen and is now freely moveable and resizable, giving operators full control over their Workspace layout.
• Fully responsive layout (512px+): Every menu, button, and panel is now fully responsive. The previous “display too small” dialog has been removed; RobFlow now supports screens as narrow as 512px.
• Unified Robot state drawer: All Robot state indicators are combined into a single dynamic navigation drawer. Variables have been moved to a dedicated panel on the right side of the screen.
• Context menu node/Widget creation: Right-click (or long-press on mobile) anywhere on the canvas to add Nodes and Widgets directly from a context menu. Copy/paste now places content at the cursor location.
• Redesigned jogging panel: Split into dedicated Joint Movement and Cartesian Movement tabs with an enhanced speed indicator on the Move-to-Target and Run buttons.
• Smart Node interaction model: Collapsed Nodes stay collapsed when dragged. Expanded Nodes are dragged via a dedicated icon. Hold-to-action buttons (e.g., Debug) feature new animation indicators.
• Visual polish: Rounded menus throughout, marquee effect for long text, redesigned dot-grid view selector, HTML-capable Documentation Group descriptions, and refined expansion panel styling.

SQL Query Node​

You can now execute database queries directly from a Flow, enabling your Robot workflows to read from and write to production databases in real time. This is ideal for logging production data, querying BOM tables, or driving Flow logic from external systems.

Key capabilities:

• Multi-driver support: Connect to PostgreSQL, MySQL/MariaDB, and Microsoft SQL Server.
• Flow-integrated queries: Run SELECT, INSERT, UPDATE, and other SQL statements as part of your Flow logic.
• Production data logging: Automatically log cycle counts, quality results, or timestamps to an external database during Flow execution.

How to use it:

1. Add a SQL Query Node to your Flow.
2. Configure the database connection (host, port, credentials, database name).
3. Write your SQL query, optionally referencing RobFlow Variables in the query parameters.
4. Run the Flow — the query executes at the configured point in the workflow.

HTTP Node​

The new HTTP Node lets you perform HTTP requests natively within Flows, connecting your Robot workflows to REST APIs, webhooks, or MES/ERP systems without any external scripting.

Key capabilities:

• Native HTTP requests: Send GET, POST, PUT, and DELETE requests from within any Flow.
• API & webhook integration: Trigger webhooks, call REST endpoints, or communicate with MES/ERP systems as part of the robot’s workflow.
• Secure backend routing: Generic Button Widget HTTP requests are now routed securely through the backend.

How to use it:

1. Add an HTTP Node to your Flow.
2. Configure the request method, URL, headers, and body.
3. Optionally map response data to RobFlow Variables for use in downstream logic.

CSV Node & CSV Download Widget​

Collect, transform, and export tabular data during Flow execution. The companion CSV Download Widget enables operators to retrieve CSV files directly from Dashboard kiosks, making data access easy without leaving the operator interface.

Key capabilities:

• In-flow data collection: Build CSV datasets row by row during Flow execution.
• Dashboard download: Operators can download CSV files directly from the Dashboard using the new Download Widget.
• Data export: Export production logs, quality reports, or cycle data as CSV files.

How to use it:

1. Add a CSV Node to your Flow to define columns and append rows during execution.
2. Add the CSV Download Widget to your Dashboard.
3. Operators press the download button on the Dashboard to retrieve the latest CSV file.

Advanced Palletizing Node Update

The Advanced Palletizing Node has been significantly improved with new capabilities, a redesigned interface ported to the new v7 UI, and critical bug fixes for more reliable pallet building.

Key capabilities:

• Automated Grid Pattern Generation: Automatically generate grid-based pallet layer patterns instead of manually defining each box position, speeding up configuration for standard layouts.
• Box-to-Box Snapping: Snap boxes to adjacent positions when defining layouts for faster, more precise pattern creation.
• Robot position in pallet visualization: See the robot’s current position relative to the pallet directly in the 3D visualization, improving spatial awareness during teaching and testing.
• Box Group Global Variable Binding: Bind box group parameters (e.g., dimensions, count) to global Variables, allowing operators to switch between box configurations from the Dashboard or via external devices without modifying the Flow.
• “Next Group” Variable exposure: Access the next box group index as a Variable in your Flow logic, enabling dynamic decisions based on which box group is being processed next.
• Improved item selection & order UX: A more intuitive interface for selecting start/end items and defining the palletizing order within each layer.

Set Brakes Node​

Programmatically engage or release Robot brakes during Flow execution. Visual feedback with colored lock icons provides clear brake-state confirmation to operators.

How to use it:

1. Add a Set Brakes Node to your Flow.
2. Configure whether to engage or release brakes.
3. The Node executes at the configured point in your Flow, with visual status icons confirming the brake state.

Flow Mini Map​

A persistent overview mini map in the bottom-right corner provides spatial orientation in large Flows. This makes navigating complex workflows faster and more intuitive, especially for Flows with many branches or Nodes.

Profinet Variable Bindings​

You can now bind Integer, Float, Boolean, Input, and Output Variables directly to Profinet I/O fields. This replaces the legacy standalone Profinet Variable system with unified native bindings, making PLC integration more seamless and consistent.

Key capabilities:

• Unified bindings: Bind any supported Variable type directly to Profinet I/O fields from the Variable Editor.
• Native integration: No separate Profinet Variable configuration needed — Variables are managed alongside all other RobFlow Variables.
• Multi-type support: Integer, Float, Boolean, Input, and Output Variables are all supported.

Note: This replaces the previous standalone Profinet Variable system from v6. Existing Profinet Variables will need to be reconfigured as native bindings.

Modbus Variable Bindings​

Bind Integer and Boolean Variables directly to Modbus registers and coils. Flows automatically pause if a Modbus device connection is lost, preventing unsafe operation.

Key capabilities:

• Direct register binding: Map RobFlow Variables to Modbus holding registers and coils.
• Automatic safety pause: If the connection to a Modbus device is lost during Flow execution, the Flow automatically pauses to prevent unsafe operation.
• Unified Variable management: Modbus-bound Variables appear alongside all other Variables in the Variable Inspector.

Beta Features​

With this release, three Beta Features are available. In the Robot Configuration (under Update-Channel), you can switch between Stable and Beta mode to access these experimental features.

Important: There is no support for Beta features, and there might be breaking changes in features between Beta and Stable state.

Auto-Layout (Beta)​

Automatically reorganize Nodes in a Flow for visual clarity. Accessible via a dedicated button on the canvas toolbar. This is especially useful after importing complex Flows or when a Flow has grown organically over time.

Note: Disabled while a Flow is running. The layout algorithm may produce suboptimal results on very large or highly nested Flows.

Miscellaneous​

• Log download: Download complete system logs from the three-dot menu for faster remote debugging and support workflows.
• Prevent kiosk breakout: A new Dashboard Config toggle locks operators into kiosk mode, preventing unauthorized navigation away from the configured Dashboard.
• Node counter & performance hints: A live Node counter warns users when Flow complexity may impact performance, guiding them toward optimization or Subflow extraction.
• Advanced camera settings (RobVision): Configure exposure, auto-exposure, distance filters, and camera calibration parameters directly in the RobFlow UI with full Orbbec camera support.
• Network configuration: Complete peripheral port network configuration including default gateway and DNS server, with a connectivity indicator in the app bar.

Fixes​

• Resolved an issue where the Edit Variable Dialog could silently lose values under certain race conditions.
• Variables from Subflows now correctly appear in the extended Variable Editor.
• Fixed a recursive deadlock triggered when moving multiple Group Nodes simultaneously.
• Exported Flows now include all necessary Robot configuration: Tools, Workspaces, Modbus devices, and RobVision devices.
• Eliminated a backend race condition when setting a Tool and executing a Relative Movement in rapid succession.
• Database upsert timestamps are now correctly updated.
• Node execution state indicators no longer persist beyond their intended timeout.

Changed​

• “Constant” renamed to “Readonly”: The “constant” field on Variables has been renamed to “readonly.” Editing of readonly Variables is now permitted when a Flow is not running.
• Event Node → OEE Event Node: The Event Node has been renamed to OEE Event Node to better reflect its purpose. Existing Flows will be migrated automatically.
• Robot Config in exports: Flow and Subflow exports now include Robot Config data. On import, users are prompted to keep existing or overwrite per entity type.
• UI layout changes: The Flow action bar, Jogging panel, and Robot State indicators have been relocated. Operators accustomed to v6 layouts should review the new centralized bottom panel and right-side state drawer.

• RobMetrics OEE: Track Availability, Performance, and Quality metrics in RobCo Studio.
• Variable Inspector: Redesigned interface with search, tagging, and multi-select actions.
• Profinet Integration: Control Robots via Siemens PLCs with native Profinet support.
• Workspace Reference Manager: Automatically update poses after Workspace changes.
• Multi-Robot Dashboards: Monitor and control multiple Robots from one interface.
• RobVision Enhancements: Variable assignment, detection-only mode, and visual grasping pose definition.
• Beta Features: Early access to RobCalibration, RobSafety, Streaming Interface, ROS2 Interface and RobVision Label Picking & Depalletizing.

Features​

RobMetrics OEE (Overall Equipment Effectiveness)​

Introducing RobMetrics OEE, our new system for tracking Robot cell performance and effectiveness directly in RobCo Studio. By capturing and visualizing Availability, Performance, and Quality, it provides actionable insights into operational efficiency.

Key capabilities:

• Automatic metrics tracking: Most events (e.g., production, errors) are logged automatically; you only need to configure a few with the new Event Node in RobFlow.
• Event-driven design: Define events like Blocked, Starved, Good/Bad Counts, or Planned Downtime right in your Flows.
• Comprehensive visualization: See your OEE KPIs in RobCo Studio Dashboards, filter by time range, and export them as CSV.

How to use it: Configure your OEE events in RobFlow with the new Event Node and view your metrics in RobCo Studio under RobMetrics OEE.

Variable Inspector​

We’ve completely redesigned how Variables are managed in RobFlow to improve usability, reduce errors, and speed up Flow creation. The new Variable Inspector replaces the old table in the “Change Robot State” drawer with a powerful, dedicated interface.

Key capabilities:

• Tagging and grouping: New tags let you organize Variables and filter them easily (e.g., by use case, Flow, or type). You can also group Variables into folders.
• Expandable overlay: Manage Variables in a full-screen interface instead of the cramped drawer.
• Search and filter: Quickly find Variables by name, type, tags, unused status, or current Flow.
• Node association: View and edit Variables directly linked to specific Nodes.
• Simplified model: Flow Variables are removed—tags now serve as the unified way to organize and reference Variables.

This makes managing Variables across Flows faster, cleaner, and less error-prone.

Profinet Integration​

You can now control your RobCo Robot directly from a Siemens PLC via Profinet, with RobCo acting as a Profinet IO-Device (slave). This enables seamless PLC integration for industrial automation use cases.

Key capabilities:

• Robot control via PLC: Start, stop, and move the Robot directly from Siemens PLCs.
• Profinet Variables in RobFlow: Define and sync Boolean, Integer, and Float Variables in RobFlow for use in your PLC logic
• TIA Portal integration: Import the RobCo GSDML, datatypes, and function block for a fast setup.
• Tested environments: Siemens TIA Portal V18/V20 with PLC 1200/1500 series.

How to use it:

1. Import the RobCo GSDML into TIA Portal and add the Robot as a Profinet IO-Device.
2. Connect your PLC to the RobCo Control Unit and assign the correct Profinet device name.
3. Define Profinet Variables in RobFlow and export the .udt file for mapping in TIA Portal.
4. Use the included RobCo function block for reliable communication and state sync.

Note: Our Profinet implementation is tested only on Siemens PLCs. For details, refer to the RobCo Profinet User Manual (https://robco.studio/resources, Technical Data).

Workspace Reference Manager​

We’ve added a new Workspace Reference Manager to simplify adapting Flows after Workspace changes. By linking poses to a reference Workspace, you can automatically update all related poses without manually reteaching them.

Key capabilities:

• Define a Workspace by teaching 3 poses, creating a reference plane.
• Update the Workspace by teaching 3 new poses in the calibrated setup—linked poses update automatically.
• Assign movement Nodes to a Workspace using the Reference Node by dragging it over the Nodes to reference.
• Consistent referencing across multiple Flows for faster adjustments.

How to use it:

1. Create a Workspace in Robot Configuration or in the Reference Node.
2. Teach 3 poses to define the initial Workspace
3. If the Workspace changes, reteach 3 new poses.
4. Use the Reference Node to link movement Nodes to this Workspace.

Note: Available for Cartesian poses only (not joint poses).

This removes the need for manual reteaching after shifts or relocations, speeding up deployments and recovery.

Multi-Robot Dashboard Support via iFrame Widget​

You can now monitor and control multiple Robots from a single RobFlow Dashboard, improving visibility and reducing operator effort in multi-robot deployments.

Key capabilities:

• Embed multiple Dashboards: Use the new iframe Widget to embed additional RobFlow Dashboards or external URLs directly into a single view.
• Interactive control: Embedded Dashboards are fully interactive, allowing you to perform actions (e.g., Start/Stop) without switching tabs.
• New HTTP call action: Extend the generic button Widget with an on-click HTTP action, letting you trigger commands across multiple Robots with a single click.

How to use it:

1. Add the iframe Widget to your Dashboard and provide the URL of another robot’s Dashboard or relevant external page. Tip: Append ?kiosk to the end of a RobFlow Dashboard URL to display it without the app bar (plain Dashboard view).
2. Optionally configure the generic button to send http calls across multiple Robots.
3. Monitor and control all Robots from a single, unified interface.

This streamlines multi-robot operations, especially for larger cells or customers managing several Robots simultaneously.

RobVision Enhancements​

RobVision now gives you more control and flexibility when working with vision solutions:

Key improvements:

• Variable assignment: Assign vision data (e.g., object length, width, number of detections, next picking pose) to Variables for use in your Flow logic.
• Detection-only mode: Run vision detection without triggering Robot movement, letting you process detection results or handle Variables independently.
• UI for grasping pose definition: Define and adjust grasping poses directly on a visualized part for faster, more intuitive setup.

These updates make configuring and using RobVision solutions faster, clearer, and better integrated into your Flows.

Beta Features​

With this release, we’re making Beta Features available for the first time. In the Robot Configuration (under Update-Channel), you can now switch between:

• Stable – Default mode with fully supported features.
• Beta – Access to experimental features marked as Beta in the UI.

Important: There is no support for Beta features, and there might be breaking changes in features between Beta and Stable state.

RobCalib: Vision based Calibration (Beta)​

Use Vision-Based Robot Calibration to improve your robot’s absolute accuracy, especially for vision-driven use cases. This ensures your robot’s movements precisely match their intended positions, which is essential for reliable vision picking and precision tasks.

Key capabilities:

• Vision-based accuracy improvements: Use RobVision hardware to calibrate your Robot based on camera data, correcting for mechanical tolerances.
• Automated calibration workflow: Collect calibration samples in RobFlow, optimize Robot parameters, and validate results directly.
• Improved precision for vision tasks: Eliminate positional drift and improve accuracy for vision picking.
• Flexible recalibration: Recalibrate after collisions, hardware changes, or relocations.

How to use it:

1. Set up RobVision hardware and open Robot Calibration in RobFlow.
2. Collect ~80–100 samples with the guided calibration Flow.
3. Apply calibration, then verify it by running the detection test in the Validate tab.

For details, see the Robot Calibration Documentation (https://staging.robco.studio/resources, Technical Data).

RobSafety (Beta)​

RobSafety lets you configure new safety functions directly in RobFlow, giving you more control over safe Robot operation.

Key capabilities:

• Safe Home: Configure a home position with an allowed tolerance; a safe output is triggered when the Robot is in this position.
• Protective Stop: Assign each of the 4 safe inputs to:
  • Safe Stop 1
  • Safe Stop 2 (manual reset)
  • Safe Stop 2 (automatic reset)
• Safe Joint Limits:
  • Define safe joint position ranges per axis.
  • Set maximum joint speeds individually.
• Safety Space: Create a configurable keep-in box tied to the TCP.
• Relay Output: Use the dual-channel relay to:
  • Mirror the E-stop state.
  • Output whether the Robot is allowed to move (System Stop).

How to use it:

Access RobSafety in the Robot configuration to define limits, assign safe inputs/outputs, and activate safety spaces.

Streaming Interface (Joint & Cartesian) (Beta)​

The new Streaming Interface allows you to control your Robot in real time by streaming trajectories directly via UDP, enabling applications like external trajectory planners or dynamic motion control.

Key capabilities:

• Real-time control: Stream joint or Cartesian poses directly to the Robot at high frequency.
• HTTP API integration: Enable or stop streaming mode programmatically via new HTTP endpoints.
• UDP streaming: Send trajectories from a host PC to the Robot controller with low latency and receive real-time feedback.
• Flexible streaming modes:
  • Joint position or joint position & velocity
  • Cartesian poses in the global frame
  • Cartesian offsets relative to the tool frame

How to use it:

1. Connect your host PC to the Control Unit via Ethernet.
2. Enable streaming mode using the HTTP API.
3. Stream target poses via UDP using the provided Python utilities (cartesian or joint space).
4. Stop streaming via HTTP or directly from RobFlow.

For setup details and examples, see the Streaming Interface Documentation (including Python demos for streaming trajectories).

RobVision Label Picking & Depalletizing (Beta)​

RobVision now supports image-based training for vision models, allowing you to create picking and depalletizing solutions even when no CAD file is available.

Key capabilities:

• Image-based model training: Upload object or box images to RobCo Studio and label them
• Segmentation: Use AI-assisted segmentation to outline objects, verify or refine masks, and define orientations for accurate picking.
• Label Picking: Train detection models for flat or texture-based objects

How to use it:

1. Open RobVision in RobCo Studio and start the solution wizard.
2. Choose Label Picking (image-based object detection) or Depalletizing
3. Upload images, assign labels, and run the segmentation tool to create accurate masks.
4. Train and deploy your model, then configure the Solution in RobVision in RobFlow

This enhancement eliminates CAD dependency and accelerates setup for vision-based picking and depalletizing tasks.

ROS2 Interface (Beta)​

RobCo Robots now provide a ROS 2 interface, enabling integration with the Robot Operating System (currently supporting ROS 2 Jazzy Jalisco). This interface exposes low-level control of the Robot through ROS topics and controllers.

Key capabilities:

• Publish and subscribe to Robot state and command topics via robco\_ros2.
• Build custom control pipelines using ros2\_control.
• Generate URDFs for modular Robot configurations with provided macros.
• Stream joint commands to the Robot once streaming mode is enabled.

Important notes:

• Not installed by default, contact support@robco.de for access.
• Provides low-level control; some safety features may not be available. Always ensure the Workspace is clear of personnel before operating.

For setup instructions, see the ROS 2 Interface Documentation.

Miscellaneous​

• Allow Cartesian Pose Variables for all relative Poses in all Pattern Nodes (Stack, Grid, Pallet)
• Improved search function in Test mode (search for In- and Output and general text search)
• Removed Flow Variables
• Default names for Inputs and Outputs (banks and actual IO)
• Improved undo/redo functionality for more stable editing
• Auto-resume Flow when SAFE_STOP_2 is released, if a Flow was running before (can be enabled via feature-flag)

Fixes​

• Improved overall system performance and connection stability
• The Advanced Palletizing Node can now handle cases where the Robot and the pallet are not in the same plane
• improved state handling in SAFE_STOP states
• Generic Resume Event Nodes: also resume if paused not on trajectory

Advanced Palletizing Node V2​

Introducing the Advanced Palletizing Node, a newly developed intuitive interface for quickly deploying complex palletizing applications. Following a step-by-step guide, users can configure:

• Box dimensions
• Pallet dimensions
• Grasping poses
• Multiple layouts
• Various approach trajectories

RobVision V1​

RobVision is our AI-based computer vision solution that enables the Robot to recognize, understand, and act within its working environment, making the Robot more flexible and letting him act in non-structured environments. This allows the Robot to pick objects without the need to manually train individual movement sequences. The AI system recognizes the object and autonomously calculates the gripping position. The user's interaction with RobVision can be divided into three steps:

1. Providing the CAD file Through RobCo's cloud platform, RobCo.Studio, users can easily upload the CAD files and automatically initiate the training process.
2. Model & Camera Configuration in RobFlow On our no-code platform, RobFlow, there is a new RobVision page where the user can calibrate the camera, select different models for objects, and test the model's performance.
3. Integrating the RobVision solution in the Flow Editor in RobFlow In the Flow Editor, where the Robot's workflow is configured through various Nodes, the user has access to two new Nodes (Vision Trigger & Vision Execution Node). In the Trigger Node, a photo is taken, processed, and the object's position is calculated. In the Execution Node, the gripping operation is performed.

Run Flow but move Robot only from a specific Node on​

Start Robot movement from any specific Node by activating Testing Mode, selecting the desired Node, and clicking "Run Flow and skip movement until this Node is executed."

Note: Logic settings remain active; only movement Nodes, setOutput, and setModBusTCP Nodes are skipped to avoid unintended actions.

Robot Configuration check​

Enable "Robot Configuration Check" in the Change Robot State menu to be notified if Robot configurations change from a saved state.

Restore Flows & Subflows backup​

Quickly revert unintentional changes by selecting "Restore Flow Backup" in the Flow selection menu.

Syncing Variables to RobCo Studio​

Display real-time RobFlow Variable values, such as processed part counts or pallet status, directly in RobCo Studio. Enable "Sync to RobCo Studio" in the Variable Editor to view updates every 10 minutes in the RobFlow Variables Table within Fleet Management.

Miscellaneous​

• Move to target for Relative Movements: Test the Relative Movement with the Move to Target Button. The Robot will execute the relative movement from its current position
• Select Pose Variable in relative movement Nodes: You are now able to select a Pose Variable in the relative movement Node
• Testing Mode Improvements: when cycling through active Nodes and a Node is in a Subflow, center the Node within the Subflow panel
• Selecting current Robot Position as Variables: Magic Variables for current Cartesian Pose and current Joint Pose to use in setVariable Node and Expression Fields

Fixed​

• Propagate Variable name changes: When renaming a Variable within a Flow, all instances of that Variable in Expression fields must update automatically
• Editing input fields in Subflow Editor: Allow editing input fields in the change Robot state drawer while the Subflow Editor Popup is open
• Text in Generic Button Widget is now always centered
• Robot pauses if frontend loses connection in debug or "move back to trajectory" mode
• Evaluate Expression fields with newline characters correctly
• Change global speed in paused state
• Fixed pause/resume bugs
• Modbus fixes

Changed​

• Illuminate Tool Switch if its active on the jogging pop-up window
• The Cartesian Pose Variable Expression now has three separate fields for the three rotational dimensions
• Render generic button label as HTML to enable custom formatting
• Enhanced state conflict message

Features​

RobFlow Testing Mode​

With the new Testing Mode, we introduce new features that make debugging and adjusting workflows faster and more intuitive. You can highlight already executed Nodes, keeping track of exactly which parts of the Flow have already run and which not. You can also run a single Node in isolation to validate specific logic steps without triggering the rest of the Flow. A new search feature allows you to locate Nodes by Variable names, Node types, or movement types, helping you navigate large and complex Flows more easily. By reducing on-site teaching and troubleshooting, Testing Mode streamlines your workflow development process. Overall, this update offers greater visibility, quicker iteration cycles, and a smoother path to reliable Robot programming.

Path Movement Node for Curve Movements (Splines)​

With the new Path Movement Node, you can now define curved, non-linear movements by specifying arcs. This enhancement provides finer control over the robot’s trajectory, enabling tasks like deburring and polishing. By giving users the ability to teach precise path shapes, the Path Movement Node helps achieve smoother and more accurate results in complex motion applications.

Pose Variable Expression for Parametrization​

With Pose Variable Expressions, users can parametrize Robot poses by adding offsets or referencing other pose Variables. This includes changes like adjusting the y-coordinate by -100 mm or increasing Joint 2 by +10°, making it easier to adapt workflows to different part sizes or process requirements. You can also overwrite entire poses or just the orientation, and switch between Robot or tool coordinate systems for more precise control. These expression-based adjustments can be applied directly in the Flow Editor and updated via the Dashboard. As a result, operators adapt Robot motions in complex workflows without re-teaching every pose.

New Pausing Behaviour​

If you pause the Flow and move the Robot (for example, by jogging it to a different pose), you can now choose whether to continue from that new pose or return to the original trajectory before resuming.

RobCo SDK for using RobCo’s API​

We are introducing the new RobCo SDK, which provides well-documented interfaces and implementation templates for controlling the Robot using RobCo’s APIs. By setting Pose Variables via an HTTP API or streaming data through WebSockets, partners can instruct the Robot to wait for updated pose information and continue workflows automatically. A Python-based integration template demonstrates how to stream e.g. camera data and send commands to the API, enabling seamless pose adjustments without disrupting the no-code workflow. Detailed documentation is available to ensure partners can quickly set up and use these interfaces in their own projects.

Miscellaneous​

• Updated Relative Movement Node to be used in TCP Frame
• Ability to reset previously suppressed messages via Robot Config
• Show confirmation dialog when toggling an Output while in Free Motion
• Auto reverse trajectory option for Palletizing, Grid and Stack Nodes

Fixed​

• Breaking Change: Updated behaviour of stack/grid/palletizing Nodes with trigger externally and after completion
• In Robot Config, show current peripheral port config and add ability to set it to DHCP
• Prevent removing Subflow Node if removing Node/Edge in Subflow Editor Popup

Pose Database for Pose Variables (Cartesian & Joint)​

You can now save and load Pose Variables across different Flows, enabling consistent pose references at multiple Nodes. Additionally, the Expression fields allow you to overwrite a pose with another Pose Variable during runtime, creating dynamic pose adaptations as the Flow progresses. Setting and overwriting Pose Variables via our HTTP API is also possible, allowing you to set and edit Poses via an external device.

In any Node that includes movements, simply click the "Save Pose" button to store the current pose or select a previously saved pose. All saved poses are accessible in the Global Variable Table, where you can view and edit them.

Palletizing Configuration Widget (Beta)​

The new Palletizing Dashboard Widget enables you to adjust palletizing configurations based on box dimensions, without needing to modify the Flow in the Flow Editor. After initially teaching a pallet Node in the Flow Editor, you can select that Node in the Palletizing Widget, where the current box dimensions (height, width, length) will be displayed. You can then update the box dimensions and change the number of layers, with the pallet poses recalculated automatically—without the need for manual pose reteaching.

Tip: Combine the Palletizing Widget with Pose Variables and the Set Variable Widget (e.g., for adjusting pick-up positions based on new box dimensions) to increase parameterization options directly in the Dashboard.

Note: This is a Beta Version.

RobCo.Studio​

RobCo.Studio is our new cloud-based platform for Robot fleet management, monitor health metrics, and offline programming.

Visit RobCo.Studio to sign up using your company email. Once registered, you’ll have access to a range of powerful features.

• Fleet Management: Get a comprehensive overview of all registered Robots and easily monitor their health status. For better organisation, you can create groups and assign Robots and accounts as needed.
• Cloud RobFlow: Adapt and expand Robot workflows without needing to connect to the Control Unit. The integrated Visualizer allows you to view Robot movements directly within RobCo.Studio.
• RobFlow Tutorials: Explore our tutorial page, which features a series of videos that guide you through the various features and functionalities of RobFlow.
• Robot Calculator: Instantly receive price estimates for different Robot configurations.

Miscellaneous​

• Search for Nodes/Widgets in current language as well as in English
• Drag-and-Drop for sortable expansion fields
• Download full backup including incident report if the Control Unit is not connected to the internet or cannot submit
• Add cancel button to the login overlay, redirecting to the landing page
• Extend jogging speed config in Robot Config
• Enhanced Split and Join Node docs
• Improved overall Performance
• Improved Mobile Usage of RobFlow

Restore Variables from backup file​

You can now restore Variables from a backup file.

As you may know, pressing the “Full Backup” button in the RobFlow menu will download a backup folder which contains all Flows, Subflows, Dashboards, Plugins and Variables present on the Control Unit at that moment.

If you accidentally deleted Variables after this backup, you can easily restore them now. Just press the “Restore Variables from backup” button in the Variable menu, select the variable_storage.json file from your backup and restore.

Scale and shift Flow environment file for Robot Visualizer​

In addition to our last release 5.1, you can now upload and save environment files for each Flow. This gives you the opportunity to adjust the Robot Visualizer to different settings.

Also, you can adjust the scale and shift of the environment in case it does not exactly match reality.

Customizable import conflict handling for Flows/Subflows/Dashboards​

If you downloaded a Flow, Subflow or Dashboard and try to re-import it to the same Control Unit, RobFlow will ask if you want to overwrite the existing one or if you want to keep both - the original and the imported version.

That way it is easier for you to keep track of changes.

Miscellaneous​

• Allow editing output Variables while brakes engaged or safety stop active
• Delete Variable Confirmation Popup
• Read-only option for Modbus/TCP Coil and Holding Register Variables
• Allow jogging while Flow is in pause state
• Make orientation in Stack, Grid, Palletizing Nodes configurable for all Poses
• Add "Move to Home" functionality to Generic Button Widget
• Buttons for Flow/Subflow/Dashboard duplication
• Set Jogging speed via Robot Config
• Add ability to name joints
• Use Expression as label in Generic Button Widget (e.g. to show current value)
• Allow all Variables on the CU in Subflows
• Variables Display Widget: add option to always show the Flow Variables of the currently running Flow
• Set Variable Widget: hide predefined fields, make Widget smaller if fields are hidden
• When importing/exporting Flows, also automatically import/export the used Subflows

Fixes​

• Do not clear Expression field in Set Variable Node when changing the Variable
• Properly center all Flows and Subflows in the editors on load
• Subflow Editor popup moves if you open the side panels, to make sure they don't overlap
• Increase zoom window for Flows and Subflows
• Misc. layout fixes
• UI performance improvements

User-defined Variables​

You can now create, edit, delete and observe Variables in RobFlow.

Variables can be used for custom parameters (e.g. to count the production output or build custom conditions) or you can read/write periphery signals (e.g. to control a digital output or change a Modbus register of a PLC to interact with sensors, actors and other devices).

This gives you powerful options to build more professional and dynamic Flows which serve your needs.

Currently, the following Variable types are supported:

• Boolean
• Integer
• Float
• Input (Digital Input)
• Output (Digital Output)
• Modbus Holding Register
• Modbus Input Register
• Modbus Coil
• Modbus Discrete Input

Some types are read-only by design (Digital Input, Modbus Input Register, Modbus Discrete Input). That means their value cannot be changed by the user and they just hold the current value coming from a sensor, a PLC or any other device.

All other types are changeable by the user and contain an initial and a current value.

By default, these changeable types will be reset to their initial value on Flow start. You can further specify Variable settings to your needs though, such as making it a constant (= Variable cannot be changed after creation) or making it persistent (current value will not be reset on Flow start).

Variables can be either created globally (usable in all Flows and Subflows) or locally (for a specific Flow). You can create Variables in the respective Flow Variables and Global Variables Dropdown in the Change Robot State Menu.

Variable Node​

The Variable Node allows you to change Variables within a running Flow. You simply select the Variable to be changed and define the desired value that should be assigned to it.

The new value is defined by an Expression. That Expression could just be a hard-coded value or include more complex logic (e.g. calculation or comparison with other Variables). It allows you to write any kind of valid Python Expressions.

When writing an Expression, you can press # to open the Variable selector and select a Variable you want to use in your Expression. Press the info-icon to get further information on how to work with Expressions.

For Boolean values, you can also just use a switch to define the desired value.

Condition and Do Until Condition Nodes​

The generic Condition Node allows you to build complex, nested conditions based on user-defined Expressions.

Once an Expression evaluates to TRUE, it will continue the Flow in the respective output handle.

In contrast to the I/O Condition Node, you are not bound to one condition and a single input or output. With the Expression field you have full flexibility about how complex your condition should be.

The same applies for the new, generic Do Until Condition Node. It works exactly like the already existing Do until I/O Condition Node. The only difference is that the condition can now be defined by an Expression.

Expression support for other Nodes​

Apart from the Variable and Condition Nodes, Expressions can now be used in many other Nodes, see the full list:

This allows for much more flexibility and interaction as values are not hardcoded anymore but dynamically adjustable.

Define next item for Stack, Grid and Palletizing Node​

Stack, Grid and Palletizing Nodes now allow you to define which item should be approached next. All you need to do is to create a Variable for the item to be picked and to select it in the next item selector. This Variable could also be changed by an external device (e.g. a PC) via http-request or be directly bound to a Modbus/TCP register of a PLC to get the next-item value from there.

This gives you a lot of flexibility for your Flow logic, e.g. to pick items in a random order or to dynamically change the start item from the Dashboard. Note: to finish the Node, just set the Variable to a value outside the defined offset bounds.

Dashboard Widgets to show and edit Variables​

Variables can not only be used in the Flow Editor. They are also available on the Dashboard.

There is now one Widget to show the existing Global or Flow Variables and another Widget to let the user select and change a Variable.

Customizable Dashboard Widgets​

Dashboard Widgets can now be customized much more to tailor Dashboards to your needs.

In general, the color and size of all Widgets are now adjustable.

Furthermore, there are 2 new Button Widgets:

• Generic Button
• Custom Jogging Button

Generic Button Widget​

The Generic Button Widget allows the user to design a button and assign custom functionality to it, e.g. on-click actions or activation conditions.

On-click actions could be to start/stop/pause/resume a Flow or to set a Variable to a defined value. If desired, the user can define activation conditions when this functionality and layout should be applied (e.g. when a Flow is running and the Robot is moving).

Custom Jogging Button Widget​

The Custom Jogging Button allows the user to define its size, color and label and assign certain jogging functionality to it (e.g. to jog fast in z-direction).

Robot Visualizer​

RobFlow shows a visual representation of the connected Robot & module configuration. You can upload environment files to visualize the surroundings as well (e.g. conveyor belts, CNC machines etc.) When you move the Robot in real life, this visualization will move as well.

Authentication​

RobFlow now has an authentication mechanism. First time you open RobFlow after the update, it will ask you to set a password. Afterwards, you will have to log in with this password in order to be able to do the following:

• Open the Flow Editor
• Open the Subflow Editor
• Open the Dashboard Editor
• Open Robot Configuration
• Open protected Dashboards in Dashboard Viewer (see below)

Other parts of RobFlow are unprotected, e.g. the Robot Visualizer page.

Dashboards now have a Dashboard Config button in the top right corner. There you can define if the Dashboard should be protected or not. If it is protected, you will have to authenticate in order to display and use it.

You can change your password via the Robot Configuration panel. If you forget your password, please reach out to us and we can reset it for you.

The username is always “editor” and cannot be changed.

Minor Features​

Landing Page​

This release introduces a specific landing page. It shows button links to all different parts of RobFlow.

API Changes​

Before this release, the backend supported 4 different API versions: v2.0, v2.1, v2.2 and v2.3.

With this new release, all those API versions were removed, there is only one valid API version now: v3.0.

This means, if you are using the API directly, you will have to adjust your URL calls to the new version, e.g. http://<ip>/api/v3.0/<endpoint> . Please consult the API Documentation page which you can access via the top-right misc menu in RobFlow. Otherwise, refer to the API documentation file attached to the release announcement email.

Miscellaneous​

• Allow free motion when Robot is pausing
• Increase RoundRobin output count from 5 to 15
• Optionally teachable Point C for Grid and Palletizing Nodes (will improve accuracy)
• Reload Button for Modbus/TCP connections in Robot config
• Add kiosk mode button in Dashboard Viewer
• Modify peripheral IP via Robot Configuration
• Robot state updates (current joint angles, current pose), is now much faster (every 20ms instead of every 500ms)

Fixes​

• Fixed blurry text on textareas
• Decimal numbers can be inserted with comma and dot as delimiter
• Show Move to Home Button in Dashboard Widget
• Dashboard move to home: on tablet, fixed the keep pressed function
• Dashboard jogging Widget: on tablet, fixed the keep pressed function
• Tool Edit Menu should not be usable on Flow run
• Prevent pasting Nodes when in input fields
• Optimized reconnection mechanism for Modbus/TCP
• Pause running Flow on controller disconnection instead of stopping it

Home Position for Flow​

In the newly created Flow Config, you have the option to set a Home Position for that specific Flow. If it is set and the Robot is not exactly at that Home Position, you cannot start the Flow. Instead, you will see a “Move to Home” button which you have to keep pressed to slowly move the Robot to the desired Home Position.

If you see that the Robot would crash while moving to the Home Position, you just release the button and then move around the obstacle with either Free Motion or jogging.

Debug Flow Run​

The Debug Flow Run replaces the former Run Stepped mode. As long as you keep the Debug button pressed, the Flow will run as usual (incl. motion blending, parallel execution, etc.). Once you release the button or the mouse leaves the button-area, the Flow will pause.

This Debug button gives you an easy, fast and reliable way to test your program and immediately stop when necessary.

Report Incident Tool​

You can now report an incident directly via RobFlow to our technical support team. You can either press the “Report Incident” button in the side menu or the one next to an error in the message log. Filling out the form, you can give some background information or attach one or several files. When pressing submit, RobFlow will additionally attach the current Flow and an extract of the RobFlow and Robot Controller logs to give our support team further information to debug your problem.

Resume Node​

The Resume Node is able to resume a paused Flow when a defined I/O condition is met.

Interactive RobFlow Tutorial​

When first using RobFlow in your browser, you see an Interactive Tutorial explaining the most important elements of the RobFlow UI. By pressing Interactive Tutorial in the side menu, you can start the Tutorial as well.

Documentation Group​

With the Documentation Group, you can mark and describe a defined part of your Flow. That way, you can make big, complex Flows more understandable and give some background information. When a Node is at the edge of the Documentation Group, it will automatically resize to fully cover that Node.

Minor features​

Download full backup of RobFlow data​

Download a full backup of all Robflow-related data (Flows, Subflows, Tools, Modbus/TCP connections, …) from your Control Unit by pressing “Create Full Backup” in the side menu.

Transform a batch of selected Nodes into a new Subflow​

When selecting a couple of Nodes, you see a button to transform the selected Nodes into a Subflow. It will only transfer Nodes which are allowed in a Subflow. Nodes that are not allowed will stay in the main Flow. By adding a Subflow Start Node, you make the Subflow valid and can save it. Once saved and the popup closed, a Subflow Node containing your newly created Subflow is added to your current Flow.

Cut/copy/paste functionality​

In addition to the Duplicate Node shortcut, you can use the following shortcuts to cut, copy and paste Nodes within or across one or several Flows/Subflows:

• CTRL/CMD+x: Cuts selected Nodes
• CTRL/CMD+c: Copies selected Nodes
• CTRL/CMD+v: Pastes selected Nodes
• CTRL/CMD+SHIFT+z: Redoes action (additional shortcut to CTRL/CMD+y)

Flow Configuration​

For each Flow, you can save Flow Configuration to define the Flow Name, give a short description and create a Home Position, if desired. (See Home Position for Flow)

Miscellaneous​

• Extended documentation for Stack, Grid and Palletizing Nodes
• http API docs are now also accessible offline via URL “{ip-address of CU}/apidocs”
• Automatic Migration of Flows/Subflows after RobFlow update or Flow/Subflow import
• New movements and joint angles + poses in Stack, Grid and Palletizing Nodes initialised with current Robot pose / angles
• Redirect to currently executing Flow by default and highlight it in the Flow Selector
• Unified global acceleration and global velocity to global speed
• Added center of mass to payload
• Added mass and center of mass to tool configuration
• Updated APIs for Cartesian and joint movements: movements can now be sent as a batch which enables blending
• Ensure commands from RobFlow are received properly by Robot Controller (Protocol shift from UDP to TCP)
• Load and display current Node state if a Flow is currently running and a Frontend (re-)connects
• MoveToTarget Button behaves now as a dead man's switch, including showing the global speed status
• Stack/Grid/Palletizing:
  • Velocity, acceleration and blending radius can be defined for approach pose
  • motion blending is enabled for certain movements within the Node
  • Acceleration and velocity of movements within Item approach trajectory are no longer scaled by acceleration and velocity of the Node
• Generic message popup with "do not show again" functionality
• Modbus-connections are not opened/closed any more in each Modbus-Node, but only on Flow start/finish (v.4.3.3 Backend)

Fixes​

• Fixed computation of orientation for Relative Movements (Approach trajectory and Relative Movement Node)
• Join Node: wait until every input handle has been triggered at least once before proceeding
• Fixed display of current movement in Movement Nodes
• Automatically assign the name of the selected Subflow to the Subflow Node
• Securely disable Node dragging if Flow is running
• Wider pause/resume buttons to make them easily reachable after Flow-start
• Disable Sliders in Widgets on Dashboard Editor
• Fixed issues with movements created via gamepad

Parallel execution​

A Flow can now run several branches in parallel. It enables the user for example to send commands to peripheral devices while the Robot is executing some other tasks.

This can reduce the cycle time as you do not have to wait for the Robot to stop before you can control the periphery (e.g. a conveyor belt or an external axis).

To let branches run in parallel, you have several options:

• Event Nodes
• Split & Join Nodes

Event Nodes​

Event Nodes trigger the execution of a branch. All of those Event Nodes can run in parallel.

Start Node​

Will trigger a branch the moment you run a Flow. If you have several Start Nodes, all of them will start at the same time.

I/O Event Node​

Will start a new branch every time a given I/O event is triggered.

Periodic Event Node​

Will trigger a branch in the defined interval.

Split & Join Nodes​

Split Node can split one branch into multiple separate branches which will be executed in parallel while a Join Node will wait until all incoming parallel processes have finished

Configurable Tools & TCP​

In the Robot Configuration Menu, the user can now define Tools the Robot is using and thereby shift the TCP (Tool Center Point).

Tool Node​

With the Tool Node, the user can change the Tool which is currently used during Flow execution.

Tool Selector & Tool Display​

With the Tool Selector in the Change Robot State Drawer, the user can change the active Tool manually.

The Tool Display in the Current Robot State Drawer shows which Tool is currently active.

Cartesian Jogging with respect to the TCP​

In addition to jogging with respect to the base coordinate system, the user can now also switch to jogging within the TCP coordinate system.

Subflows​

With a Subflow you can bundle program logic into reusable snippets that can be used across all Flows. This will aid you in reducing redundancy and having a better overview.

Minor features​

Partial pallets with start / end selection​

In the Palletizing Node, it is now possible to build partial pallets and select start and end items completely based on the item grid. With the Layer Slider on the left, you can browse through the layers and select your desired start and end items.

Undo / Redo​

You can now undo (CTRL/CMD + z) / redo (CTRL/CMD + y) your changes in the Flow and Subflow Editor.

Comment Node​

With a Comment Node, you can add comments to your Flow.

Velocity Scaling​

The robot’s velocity can now be adjusted while a Flow is running.

Global Velocity / Acceleration stored within Flows​

When saving a Flow, RobFlow will also save the global velocity and acceleration set at that time. This is especially helpful when having Flows which require different velocity and acceleration settings.

Miscellaneous​

• The mini map in the Flow Editor was removed due to limited user benefit
• I/O banks and I/Os now now be assigned custom names
• An indicator showing the currently set payload was added to the top bar
• Increased text contrast for better readability
• The Control Unit can now access the internet when connecting a smartphone with USB tethering to it
• The UI performance & responsiveness especially with bigger Flows was improved
• Unexpected movements when turning on Free Motion while having set an invalid payload are now prevented and an error shown instead
• Robot Configuration can now be imported and exported
• Links to the Release Notes and API Documentation where added in the top bar menu
• Backups of Flows and Subflows are now stored on the Control Unit for disaster recovery
• Improved stand-still precision/performance of the Robot

Fixes​

• Fixed conflicts when reimporting the same Flow multiple times
• Disable move-to-target button if Free Motion is turned on
• Wait for Robot to be idle before execution of condition-matched branch in Do-Until-Condition Node
• Added several countermeasures for rare cases in which Flows got lost

Landmark alignment​

Nodes can now be part of a reference group.

During initial teaching the reference group is initialised by teaching a reference pose.

An additional reference pose can be set in the reference group and all cartesian movements within the group get shifted by the offset of the two reference poses.

This for example can be used to avoid having to re-teach all movements within a machine after the Robot has been moved.

Motion blending​

Movements can now be given a blending radius allowing the Robot to cut corners.

This can greatly improve cycle times and also reduces strain on motor components.

Movement performance​

Movement performance, accuracy and path consistency of the Robot was greatly improved.

Experimental(!) Gamepad support​

The Robot can now be jogged using any consumer gamepad (xbox, playstation etc.).

Simply connect the gamepad to your PC (not the CU!) and press “A” to enable it.

If the gamepad is connected successfully you will see an indicator in the navigation bar.

The gamepad can also be used to add waypoints to a currently selected movement Node by pressing “A”.

Controller Errors/Warnings are shown in Message Log​

Errors and warnings from the Robot are now shown in much greater detail in the message log in the navigation bar.

This makes troubleshooting much easier.

Minor features​

Joining of Flow branches​

Flow branches can now be joined into a single Node reducing code duplication and improving overview.

Shortcuts​

The following keyboard shortcuts were added for more efficient user experience:

• CTRL/CMD+d: Duplicates selected Nodes
• CTRL/CMD+s: Saves the Flow
• CTRL/CMD+i: Opens the Node library and focuses the filter input so you can immediately start typing

Embedded feedback form​

You can now directly provide feedback via a form available in the context menu in the navigation bar.

Move-To-Target Button​

Move-To-Target Buttons now automatically change to STOP Buttons during movement when clicked

->

Miscellaneous​

• The behaviour of Stack/Grid/Palletizing Nodes with “trigger externally” enabled was changed so that the Node now resets after the last item and the “After completion” output is only triggered once. This makes them more easy to use in endless loops
• Stack/Grid/Palletizing move towards Approach Point now with Point to Point strategy
• The interaction with the navigation Widget for controlling the brakes was simplified to reduce the number of clicks
• The delay Node now works for fractions smaller than 1 second
• Flows now pause (and can be resumed) instead of stopping if an error occurs
• Flow/Dashboard names are now added to the filename during export for better overview
• Message log is now persisted across reboots if not deleted manually
• Joint LEDs now reflect the current Robot state (Blue: braked, Red: error, White: operational)

Fixes​

• Fixed input validation in some Nodes that was not working correctly and did not highlight mistakes
• Fixed overlapping order some for overlays that caused content to be not visible
• Standardised naming of Pose/Position/Point
• Fixed loading of Flows and Dashboards that sometimes got stuck
• Fixed loading of multiple Flows/Dashboards with the same UUID which caused conflicts