Embedded GUI

Real-Time Industrial Grade GUI Solutions

GUIX embedded GUI is Express Logic’s advanced, Industrial Grade GUI solution designed specifically for deeply embedded, real-time, and IoT applications. Express Logic also provides a full-featured WYSIWYG desktop design tool named GUIX Studio, which allows developers to design their GUI on the desktop and generate GUIX embedded GUI code that can then be exported to the target.

GUIX is fully integrated with THREADX RTOS and is available for many of the same processors supported by THREADX. All of this combined with an extremely small footprint, fast execution, and superior ease-of-use, make GUIX the ideal choice for the most demanding embedded IoT applications requiring a user interface.

Create Elegant User Interfaces

GUIX and GUIX Studio provide all the features necessary to create uniquely elegant user interfaces. The standard GUIX package includes various sample user interfaces, including a medical device reference, a smart watch reference, a home automation reference, an industrial control reference, an automotive reference, and various sprite and animation examples. Please click on the reference examples shown below.

Home Automation
White Goods

Each GUIX reference has a corresponding GUIX Studio project that defines all the graphical elements of the reference design. Changing a reference design is easy. Simply open the corresponding GUIX project, make the desired changes, save the project, and then select Project Generate All Output Files to generate the C code for GUIX. Then simply rebuild the target application and run to observe the modified reference design.


GUIX has a remarkably small minimal footprint of 13.2KB of FLASH and 4KB RAM for basic support, not including the memory required for a canvas.

For a display with internal GRAM and self-refresh technology, no canvas memory is required. However, to improve drawing performance, or for a display configuration that does not utilize GRAM local to the display, a canvas memory area is defined by the application.

Canvas memory requirements are a function of the canvas size as well as the color depth, and are defined by the formula:

Canvas RAM (bytes) = (x * y * (bpp/8))

Where “x” and “y” are the dimensions of the canvas (display).

Most applications also utilize graphical resources, which are not included in the core GUIX library storage requirements. These resources include fonts, graphical icons (pixelmaps), and static strings. This data can be stored in the const memory section (i.e. FLASH).

The size of this memory area is dependent on a number of factors, including the number and size of unique fonts used, the number and size of the graphical icons used, the output color format, and whether or not each resource is using compressed data, since GUIX supports RLE compression of both font and pixelmap data. The storage requirements for each resource are displayed within the GUIX Studio application, allowing the user to track and monitor the amount of flash memory that will be consumed by the application resources.

Like THREADX, the size of GUIX automatically scales based on the services actually used by the application. This virtually eliminates the need for complicated configuration and build parameters, making things easier for the developer.

Fast execution

GUIX is written exclusively in C and is designed for speed. GUIX has minimal internal function call layering.

In addition, GUIX provides optimized clipping, drawing, and event handling. All of this and a general performance-oriented design philosophy help GUIX achieve the fastest possible performance.

Pre-certified by TUV to many safety standards

GUIX has been certified by SGS-TUV Saar for use in safety-critical systems, according to IEC-61508 SIL 4, IEC-62304 SW Safety Class C,

ISO 26262 ASIL D and EN 50128. The certification confirms that GUIX can be used in the development of safety-related software for the highest safety integrity levels of IEC-61508, IEC-62304, ISO 26262 and EN 50128 for the “Functional Safety of electrical, electronic, and programmable electronic safety-related systems.” SGS-TUV Saar, formed through a joint venture of Germany’s SGS-Group and TUV Saarland, has become the leading accredited, independent company for testing, auditing, verifying and certifying embedded software for safety-related systems worldwide. The industrial safety standard IEC 61508, and all standards that are derived from it, including IEC-62304, ISO 26262 and EN 50128, are used to assure the functional safety of electrical, electronic, and programmable electronic safety-related medical devices, process control systems, industrial machinery, automobiles and railway control systems.


Simple, easy-to-use

GUIX is very simple to use and GUIX Studio makes it even easier by allowing developers to visually design

on the desktop and generate C code that runs on the actual target. Applications can then add their own custom event handling and drawing functions to complete their GUI.

Using the GUIX API is straightforward. The GUIX API is both intuitive and highly functional. The API names are made of real words and not the “alphabet soup” and/or the highly abbreviated names that are so common in other file system products. All GUIX APIs have a leading gx_ and follow a noun-verb naming convention. Furthermore, there is a functional consistency throughout the API. For example, all APIs that initialize a widget control block are named < widget_type>_create, and the create function parameters for each widget type are always defined in the same order.

Comprehensive set of built-in widgets

GUIX provides a rich set of built-in widgets, including:
  • Accordion Menu
  • Button
  • Checkbox
  • Circular Gauge
  • Drop Down List
  • Horizontal List
  • Horizontal Scrollbar Window
  • Icon
  • Icon Button
  • Line Chart
  • Menu
  • Multi Line Text Button
  • Multi Line Text Input
  • Multi Line Text View
  • Numeric Pixelmap Prompt
  • Numeric Prompt
  • Numeric Scroll Wheel
  • Pixelmap Button
  • Pixelmap Prompt
  • Pixelmap Slider
  • Pixelmap Sprite
  • Progress Bar
  • Prompt
  • Radial Progress Bar
  • Radio Button
  • Scroll Wheel
  • Single Line Text Input
  • Slider
  • String Scroll Wheel
  • Text Button
  • Tree View
  • Vertical List
  • Vertical Scrollbar


It’s easy for the application to create its own customer widgets as well.

Complete low-level drawing API

GUIX provides a robust canvas drawing API, allowing the application to render complex graphical shapes.

All functions support anti-aliasing on high color depth targets, and all shapes can be filled our outlined, including solid and pixelmap pattern fills. All drawing primitives support brush alpha when running at 16 bpp and higher color depth. Drawing functions include:

  • Arc Draw
  • Circle Draw
  • Line Draw
  • Pie Draw
  • Pixelmap Blend
  • Pixelmap Tile
  • Polygon Draw
  • Text Draw
  • Chord Draw
  • Ellipse Draw
  • Pixel Draw
  • Pixelmap Draw
  • Pixelmap Rotate
  • Rectangle Draw
  • Text Blend

Default free fonts and easy to add more

GUIX provides a free set of TrueType fonts. Developers can add additional TrueType fonts as desired.

The GUIX font format supports 8bpp anti-aliasing, 4bpp anti-aliasing, and 1bpp monochrome fonts. For the most resource-constrained applications, GUIX pre-renders the TrueType fonts to a compressed bitmap format using our GUIX Studio desktop tool.

Custom JPG and PNG decoder implementation

Custom JPG and PNG decoder implementation

JPG and PNG file decoder implementation. This implementation supports color space conversion, dithering, and runtime creation of GUIX-compatible pixelmap format images.

Extensive display and touchscreen support

GUIX provides generic display drivers for nearly all color formats, including 1bpp monochrome, 8 bpp palette, 8 bpp 3:3:2 format,

16 bpp 565 rgb format, 16 bpp 4:4:4:4 format, 32 bpp x:r:g:b format, and 32 bpp a:r:g:b format. In addition, GUIX is integrated with many of the most popular LCD controllers and hardware accelerators (ST ChromeArt, Renesas Synergy, etc.).

GUIX fully supports touchscreen (including gesture support), pen, and virtual keyboard input devices.

GUIX Studio desktop WYSIWYG tool

GUIX Studio provides a complete WYSIWYG screen design environment which allows the user to drag-and-drop graphical elements used to build the GUI screens.

GUIX Studio automatically generates C code compatible with the GUIX library, ready to be compiled and run on the target. Developers can produce pre-rendered fonts for use within an application using the integrated GUIX Studio font generation tool. Fonts can be generated in monochrome or anti-aliased formats, and are optimized to save space on the target. Fonts can include any set of characters, including Unicode characters for multi-lingual applications.

GUIX Studio facilitates the import of graphics from PNG or JPG files with conversion to compressed GUIX Pixelmaps for use on the target system. Many of the GUIX widget types are designed to incorporate user graphics for a custom look and feel. In addition, GUIX Studio allows customization of the default colors and drawing styles used by the GUIX widgets, allowing developers to tune the appearance of GUIX very easily. Generation and maintenance of application strings is another built-in facility of GUIX Studio. This enables developers to design an application using one language for developing, and quickly and easily add support for additional languages after the product is released. A complete GUIX application can be executed on a PC desktop within the GUIX Studio environment, allowing a quick and easy generation and demonstration of GUI concepts, testing of screen flows, and observation of screen transitions and animations. When completed, a design can be exported as target-ready C data structures, ready to be compiled and linked with the GUIX and THREADX libraries.

GUIX and GUIX Studio support multiple resource themes, allowing an application to be easily reskinned at run-time. Fonts, colors, and pixelmaps can be changed at run-time with one simple API.

Learn more about GUIX Studio.

Complete Win32 simulation

GUIX runs on a Windows PC, using exactly the same drawing library that runs on the target board. With GUIX, you can build

and run a GUI application on the PC, and use the same application code on your target for debugging, rapid prototyping, demonstration, and WYSIWYG target operation.

Advanced technology

GUIX's advanced technology incorporates:


  • Alpha blending
  • Anti-Aliasing
  • Automatic scaling
  • Bitmap compression
  • Canvas blending
  • Custom widget support
  • Deferred drawing support
  • Dithering support
  • Endian neutral programming
  • Hardware accelerator support
  • Multilingual support and UTF-8 encoding
  • Multiple display and canvas support
  • Optimized clipping, drawing, and event handling
  • Runtime JPEG and PNG decoder
  • Skinning and Themes
  • Supports monochrome through 32-bit true-color with alpha graphics formats
  • Transitions, Sprites, and Animation support
  • Win32 simulation
  • Window management including Viewports and Z-order maintenance

Fastest time-to-market

GUIX is easy to install, learn, use, debug, verify, certify and maintain. GUIX Studio also helps making

embedded GUI design and implementation easier. As a result, GUIX is one of the most popular GUI solutions for embedded IoT devices.

Our consistent time-to-market advantage is built on:

  1. Quality Documentation – please review our GUIX User Guide and see for yourself!
  2. Complete Source Code Availability
  3. Easy-to-use API
  4. Comprehensive and Advanced Feature Set

Royalty free

GUIX is licensed royalty-free, for the lowest possible manufacturing cost. There are five basic types

of licenses as well as the ability to create a custom license for unique situations. Please see the GUIX licensing page for more information.

Full, highest-quality source code

From the very beginning, GUIX was designed to be an Industrial Grade GUI solution distributed with full C source code.

Throughout the years, GUIX source code has set the bar in quality and ease of understanding. In addition, the convention of having one function per file provides for easy source navigation. The following is an example of the GUIX gx_canvas_alpha_set.c function:

Supports most popular architectures

GUIX runs on most popular 32/64-bit microprocessors, out-of-the-box, fully tested and fully supported, including the following:

Advanced Architectures:

  • Analog Devices: SHARC, Blackfin, CM4xx
  • Andes Core: RISC-V
  • Ambiqmicro: Apollo MCUs
  • ARM: ARM7, ARM9, ARM11, Cortex-M0/M3/M4/M7/A15/A5/A7/A8/A9/A5x 64-bi/A7x 64-bit/R4/R5, TrustZone ARMv8-M
  • Cadence: Xtensa, Diamond
  • CEVA: PSoC, PSoC 4, PSoC 5, PSoC 6, FM0+, FM3, MF4, WICED WiFi
  • Cypress: RISC-V
  • EnSilica: eSi-RISC
  • Infineon: XMC1000, XMC4000, TriCore
  • Intel & Intel FPGA: x36/Pentium, XScale, NIOS II, Cyclone, Arria 10
  • Microchip: AVR32, ARM7, ARM9, Cortex-M3/M4/M7, SAM3/4/7/9/A/C/D/E/G/L/SV, PIC24/PIC32
  • Microsemi: RISC-V
  • NXP: LPC, ARM7, ARM9, PowerPC, 68K, i.MX, ColdFire, Kinetis Cortex-M3/M4
  • Renesas: SH, HS, V850, RX, RZ, Synergy
  • Silicon Labs: EFM32
  • Synopsys: ARC 600, 700, ARC EM, ARC HS
  • ST: STM32, ARM7, ARM9, Cortex-M3/M4/M7
  • Tl: C5xxx, C6xxx, Stellaris, Sitara, Tiva-C
  • Wave Computing: MIPS32 4K, 24K, 34K, 1004K, MIPS64 5K, microAptiv, interAptiv, proAptiv, M-Class
  • Xilinx: MicroBlaze, PowerPC 405, ZYNQ, ZYNQ UltraSCALE
** Please note that all timing and size figures listed are estimates and may be different on your development platform

Subscribe to our news