Use the standard, customize it—HMI development with the HELIO SDK
by Christian Rudolph 31.03.2026
Article 6 min reading time
No-code accelerates the development of industrial user interfaces. But what happens when a project requires a control that isn’t included in the standard? With the HELIO SDK, you can develop your own controls, actions, and dynamic properties and integrate them into your usual configuration process. This way, the standard remains the foundation—and custom requirements don’t force you to program the entire HMI from scratch.
When the standard can’t cover everything
Industrial user interfaces must balance two requirements: they should be efficient to develop while clearly representing the specific characteristics of a machine. Many tasks are repetitive—navigation, status displays, user inputs, or messages. Others are closely tied to a specific process and require a custom solution.
In traditional development projects, this often leads to a fundamental decision: Either the team stays within the capabilities of a visualization system, or it develops the interface itself—with the corresponding effort required for design, programming, and long-term maintenance.
Yet the entire interface is rarely a special case. Often, only a specific diagram, a particular interaction, or a custom calculation logic is missing. This is exactly where the HELIO SDK comes in: It supplements the no-code environment by enabling targeted programming precisely where the project requires it.
Visual Design, Targeted Programming
With HELIO, user interfaces are created in a graphical development environment. Pre-built components, an integrated design system, and responsive layout relieve the team of many repetitive tasks. The SDK—short for Software Development Kit—extends this approach rather than replacing it.
Developers can create their own extensions, while the rest of the interface continues to be built and maintained in the HELIO Editor. Custom controls can be configured and edited there just like standard building blocks. This transforms a programmed custom solution into a building block for day-to-day project configuration.
This also changes the way teams collaborate: Not every customization to an interface has to end up in software development. The development team provides the necessary extensions; the project planning team implements them in the HMI.
Custom Modules with Familiar Tools
The HELIO SDK is based on TypeScript and React. Teams can use familiar tools such as Visual Studio Code for development. This allows existing knowledge from web development to be applied directly to industrial user interfaces.
Extension options include:
- Custom controls: User interface elements and visualizations for project-specific requirements.
- Custom actions: Individual functions for workflows and interactions within the HMI.
- Custom dynamic properties: Additional logic to adapt the behavior of components to the specific use case.
- Custom interfaces: Additional data connections for project-specific systems and communication requirements.
What matters here is not the amount of code you write yourself. The key is to implement the custom components as precisely as possible and leave the remaining tasks to the platform. A special diagram requires custom development—but a complete navigation system certainly does not.
Case Study: Böllhoff—Displaying Process Data Appropriately
The HMI from Böllhoff Automation GmbH demonstrates how this approach works in practice. The company develops assembly solutions for automated fastening technology. A central element of the user interface is joint point management, which was implemented using HELIO’s standard building blocks.
Only for the display of force-displacement curves was a control specifically tailored to this use case developed using the HELIO SDK. It integrates seamlessly into the existing HELIO library and can be configured using the familiar project configuration process.
This way, the standard remains the foundation, while process-specific visualization is added as needed. Not the entire interface is custom-developed, but only the component required for the specific operating task.
Practical Example: Kosme—Extensions for an Entire Machine Series
Kosme, a Krones Group company, develops machines for bottle labeling with its Flectra series. The high cycle speeds place special demands on operation: Label rolls must be replenished in a timely manner, and products being discharged must be kept under close watch. At the same time, operators need clearly structured access to extensive expert settings.
To meet these requirements, several specialized custom controls were developed using the HELIO SDK. One example is the modular machine overview shown in the image: It graphically depicts the arrangement of the dispenser modules around the central bottle conveyor and links them to a display showing the production speed. Instead of having to deduce the spatial arrangement from individual parameter lists, operators receive a direct overview of the labeling machine’s configuration.
The overview can be flexibly adapted to different machine configurations. The extensions developed for this purpose are available to all project engineers and integrate seamlessly into the existing Control Library. This allows different configuration levels of the Flectra series to be implemented using a common extension framework.
The operating concept is complemented by a light and dark theme based on the Krones Group’s design system, to which all controls automatically adapt. In this way, the new generation of HMIs combines reusable functions with a consistent, ergonomic appearance. Clearly structured interfaces support efficient operation—even for more complex processes.
This example illustrates the benefits of a common extension base: Specialized solutions are not limited to a single project but become building blocks for additional machine variants.
Extend without changing the software core
Custom functions are only helpful in the long term if they do not hinder further development. The SDK enables extensions without requiring changes to the HELIO Core. HMI Project also uses this approach for customer-specific solutions.
The separation between the platform and the extension creates a clear foundation for maintenance: The platform provides the common base, while the extension defines the individual scope of functionality. This allows for more targeted organization of versioning, maintenance, and necessary adjustments than when making changes to the software core.
This does not replace the responsibility for in-house developed components. An extension must also be tested, documented, and reviewed whenever changes are made. The advantage is that this effort is concentrated in a clearly defined area.
Conclusion: Customization Where It Counts
Efficient HMI development does not require the highest possible proportion of in-house development. It requires a robust foundation and the freedom to extend it in the right places.
The HELIO SDK combines the advantages of no-code configuration with the capabilities of professional software development. Standard tasks remain within the editor, while specific requirements are implemented as custom modules. The result is customized user interfaces without having to start from scratch for every project.
☑ Combine no-code configuration with custom development
☑ Add your own controls, actions, dynamic properties, and interfaces
☑ Use TypeScript, React, and familiar development tools
☑ Leave the HELIO Core unchanged
☑ Build project-specific solutions as reusable building blocks
Learn more
HELIO SDK and extension options
More HELIO Case Studies
Test HELIO
Christian Rudolph Management
