The mobile machinery market is in transition. Machine intelligence is growing, regulations are tightening, and requirements regarding autonomy and IoT features are increasing
exponentially. At the same time, OEMs are struggling with a chronic talent shortage: there is a severe lack of experienced software developers.

In this equation, traditional, rigid software development has become a bottleneck.

Many equipment manufacturers are used to the fact that choosing a control system means
simultaneously committing to a heavy licensing model and a specific, closed ecosystem. In
today’s competitive landscape, however, the real risk is not choosing the wrong controller —
it’s choosing a development model that slows you down. At Exertus, we believe in a diQerent
approach. We call it the principle of Freedom to Create.

Strategic reality: your software environment should accelerate your competitiveness —not tax it.

We have developed the Guitu programming environment specifically to answer the challenges that slow down machine builders’ time-to-market. Guitu is not just a tool; it is a strategic choice to free up resources, reduce dependency, and accelerate innovation.

Here are three technical and business reasons why Guitu is displacing traditional
development environments in the toolkits of agile OEMs.

1. No license trap – a genuinely flexible development environment

One of the industry’s biggest misconceptions is that a credible control system requires
running inside an expensive, commercial license ecosystem or similar proprietary platforms.
Although standards have their place, heavy license ecosystems often lock customers into
closed development models, where runtime licenses, development seats, and version
dependencies eat into margins and introduce cost uncertainty.

Strategic statement: recurring runtime licenses are not a technical necessity — they are a business model choice.

Exertus’s philosophy is the opposite. We do not want to tie the customer to recurring license
fees, but rather provide the tools to get the machine working cost-eQectively and
independently. Guitu is a license-free development environment. This means you invest in
your own IPR and your product’s features, rather than paying a recurring “tax” for using the
hardware you already bought.

This freedom also allows for the utilization of a broader Firmware layer without having to start from scratch. We oQer a comprehensive library of features upon which application logic is quick to build. Strategically, this translates into faster development cycles, better cost control, and long-term flexibility in architectural decisions.

Strategic statement: independence at the software layer directly translates into stronger margins and long-term architectural control.

2. The seamless union of C-code and graphical programming

The resource shortage in software development often stems from tools requiring expertise
that is too specific. Graphical tools are easy but limited; pure code is eQicient but requires
deep programming expertise.

Guitu solves this by combining both worlds.

• Graphical programming: System engineers and electrical designers can build the
machine’s basic logic, I/O management, and sequences visually using block diagrams.
• C-code: Demanding algorithms, complex calculations, and specific control loops can
be coded directly in C and embedded as part of the graphical model.

In many traditional environments — including commercial license-based control systems and proprietary hardware-bound ecosystems — graphical logic is primary, while deep
customization through native C integration may be constrained, structured diQerently, or
dependent on ecosystem-specific frameworks.

Strategic statement: hybrid C + graphical development protects both usability and highperformance control without compromise.

This hybrid model removes silos between teams. It allows “hardcore coders” to focus on
demanding algorithms, while application experts drive the machine’s functionality forward
independently.

From a strategic perspective, this flexibility reduces dependency on narrowly specialized
talent and makes development teams more resilient. Projects move forward even when
resources are limited. The result is a scalable toolchain that supports everything from simple
logic to the advanced computation required by autonomous and connected functions —
without forcing a compromise between usability and performance.

3. Real-time simulation and earlier validation
In the traditional model, software testing only begins once the physical prototype is ready.
Validation happens in the workshop, where iterations are slow, expensive, and often
disruptive. If there is an error in the logic, it is noticed only during commissioning — or, at
worst, in the field.

Guitu is designed to fundamentally shift this dynamic. Together with Exertus’s Vento
simulation environment, Guitu enables software validation virtually even before a single cable has been connected. You can run code, test interfaces, and simulate fault situations in realtime directly from your desktop.

While some commercial license-based environments oQer simulation capabilities, they are
often limited to logic validation or require additional licensing layers and configuration steps. Guitu and Vento are designed as an integrated workflow from the outset.

Strategic statement: moving validation from the workshop to the desktop shortens feedback loops and reduces total project risk.

This moves validation from the workshop to the desktop — where iterations are faster,
cheaper, and safer. Errors are detected earlier in the development cycle, when fixing them
requires less eQort and causes less disruption. Teams can experiment, optimize control logic, and validate edge cases without risking hardware damage or costly downtime.
Strategically, this approach reduces overall project risk. It shortens feedback loops, improves software quality before physical integration, and enables more predictable project timelines. By the time the software is deployed to the physical machine, it has already been validated in a controlled, repeatable environment.

Summary: Choose speed, independence, and strategic flexibility

In a conservative industry, it is safe to choose what everyone else is using. But if your goal is to build the market’s highest-performing mobile machine — and deliver it to market in
significantly less time — you cannot rely on development models that inherently slow you
down.

Strategic statement: your development environment is not just a tool choice — it is a business model decision.

The real competitive advantage lies in choosing a development model that maximizes
independence, accelerates iteration, and protects your margins.

Exertus and Guitu oQer more than a programming environment. They represent a strategic
shift: fewer license constraints, greater architectural freedom, earlier validation, and a faster
route from idea to finished product.

Want to see how Guitu adapts to your machine’s needs? Contact our experts, and let’s see
how we can enhance your software development — and help you reach the market faster.

Contact us form or contact sales: sales@exertus.fi