“You get what you pay for” isn’t always true. When designing a graphical user interface (GUI) and producing a human-machine interface (HMI), the goal is always to get more than you pay for. Microcontroller unit-based systems (MCUs) are less complex and expensive than systems on chips (SoCs) because they offer less functionality. This doesn’t always mean sacrificing quality to cut costs, though, and it’s entirely possible to deliver a smartphone-caliber GUI on inexpensive hardware.

Microcontroller units keep bill of materials (BOM) costs low, offer relatively small sizes and have lower requirements for power and resources. Despite the relative simplicity of MCUs compared to SoCs (and sometimes because of it), product teams can still achieve excellent user interface (UI), user experience (UX) and graphics with MCUs.

Considerations and Challenges

The most relevant focus is typically on delivering an attractive, shiny, modern GUI on an MCU. Because MCUs are simpler from an architectural standpoint than an SoC, they offer fewer internal resources. The challenge lies in making the most of the limited resources of an MCU to develop a useful HMI. Identifying and overcoming obstacles is made possible by thoughtful requirements gathering and mapping those requirements to the available MCU resources.

The costs of engineering, production and maintenance are key considerations at the start of the requirements gathering phase, as well as throughout the entire GUI development process. The microcontroller itself is a significant part of the BOM cost, but answering the following questions will help teams navigate the complexity of an embedded GUI:

  • How many unique GUI screens and screen templates do we need?
  • How many images do we need—and in which file types?
  • Which languages and fonts do we need for internationalization?
  • Which animations or transitions do we need to support?
  • What kind of display are we working with (in terms of width, height, pixels and color depth)?
  • Do we need to provide updates or over-the-air (OTA) programming?
  • How and where will we store the application, assets and data?

With this list, you can derive a list of requirements for your GUI which must then be mapped onto the available resources of the MCU.

Solving the memory problems that plague MCU-based GUI designs can be a challenge. The balance between assets mapped to Flash and RAM consumed at runtime will impact asset management and GUI performance. Flash memory is great for content that doesn’t need to be refreshed, like your code and constant data. RAM is ideal for dynamic content, especially content that must be accessed, read and written frequently. Unfortunately, RAM is more expensive and requires continuous power supply.

Performance and access speed are vital to the overall quality of the UI and UX. Altia’s DeepScreen code generation architecture helps right-size frame buffers and control the color format of the graphical assets to reduce memory bandwidth. Altia DeepScreen supports hardware layers when available on the hardware, so it’s possible to make updates on dynamic content layers while keeping other layer graphics static—further reducing the system load like dynamic memory footprint.

Automatic code generation solutions like Altia DeepScreen offer advantages over hand-coding, which often becomes a nightmare when maintaining a GUI.

Benefits of Using Altia with Microcontroller Unit GUIs

Teams can use Altia’s GUI editor and model-based development process to improve collaboration. Once the design looks good, code generation brings it to life almost instantly. Beyond the improved collaboration, this yields three primary benefits:

  1. Code Size Optimization – Getting the code as small as possible helps stay within the confines of an MCU’s limited memory resources. For example, reducing memory helps draw less power to make the battery life as long as possible.
  2. Production Costs and Maintenance Costs – Easing the requirements for memory and power helps keep the BOM cost low. Easier printed circuit board (PCB) layouts might reduce costs when working with suppliers.
  3. Speed Optimization – A slow GUI is a bad GUI, and high latency can devastate UX. The combination of well-balanced GUI software with highly performant code and optimized graphical assets is the key to making a great first impression on customers and users.

These are three top reasons teams trust Altia to help them develop revolutionary GUIs. For example, the team at Tandem Diabetes Care developed software to deliver a full-color touchscreen GUI that runs for a week on a small rechargeable battery. The team at Cypress (now Infineon) successfully brought rich graphics to automotive displays with HMI code generation support for MCUs. Deploying GUIs for microcontroller unit-based GUIs is part of Altia’s DNA. This is why our solution is a top choice for embedded GUIs for displays of all sorts—from cost-efficient MCUs to cutting edge, high-power SoCs—all with a common design solution.

Why Altia for Embedded GUIs on Microcontroller Units?

Altia is a concept-to-code graphics solution with everything you need to design, develop and deploy GUIs on MCUs. You can use your favorite graphics tool to create artwork. Then use Altia’s GUI development software to bring your user interface to life on a bare-metal deployment or any MCU-compatible operating system (like FreeRTOS) with only a few clicks. The model-based workflow is straightforward enough to allow for quick prototyping, ongoing user testing and fast iterations to improve UX.

MCU-Minded Architecture

Because Altia’s code generator puts out optimized code, everything is lightweight enough for your microcontroller unit. You can even test performance during development because Altia DeepScreen automatically generates code. Our DeepScreen solution is specifically architected to make the most of the features of selected hardware (including those resource-constrained MCUs), making all this hardware (and more) work smarter.


We continue to extend the range of code generation support to different types of MCUs to provide options for overcoming a chip shortage or other supply chain challenges. If you need to make a pivot or even create a GUI to work across multiple hardware configurations, DeepScreen gives you the flexibility to do so. Your GUI model is portable enough to go from microcontroller unit to microprocessor unit or vice versa for a new or next-generation product.


The Altia Tool Chain is compatible with the range of MCU-based embedded graphics applications. The mission is to deliver the best-performing GUI possible on the lowest-cost hardware. That said, the software editor and code generator are advanced enough to provide advanced graphics with sophisticated graphics while 3D GPUs make their way into cost-efficient, smaller MPUs or when a state-of-the-art SoC is firing a GUI application.

Altia is in the business of helping companies get high-impact GUIs onto processers with just about any level of power. Many product teams come to us because they’ve never considered MCU-based GUIs or have never selected hardware. In those cases, our Kickstart Services help teams select hardware and optimize graphics accordingly.

Altia’s software and services are designed to support every step of the product journey, from concept to production. Reach out today to learn more or get started.