AWTK: A Cross-Platform Embedded GUI Engine Written in C

What AWTK Is and the Range of Platforms It Supports

AWTK stands for Toolkit AnyWhere. It is an open-source GUI engine written in C, developed by ZLG, a Chinese embedded systems company. The engine is the built-in GUI layer of ZLG's AWorksOS IoT operating system, and it has been extended to run on a wider set of targets.

The README lists the following platforms as supported: ZLG AWorksOS, Windows, Linux, macOS, embedded Linux, Android, iOS, HarmonyOS, Web, and embedded raw systems. The raw systems target means AWTK can run on bare-metal hardware without an operating system, provided the LCD and input drivers are adapted. The README also notes that porting to different RTOS platforms is straightforward.

AWTK exposes its own cross-platform utility library that applications can use independently. This library covers lists, arrays, strings (UTF-8 and wide-character), event emitters, values, objects, a file system abstraction, mutex, threads, formula evaluation, and string parsing. Applications built with AWTK can use this library to handle data structures and concurrency in a way that compiles on all supported platforms without platform-specific ifdefs.

Rendering Architecture and Hardware Acceleration

AWTK uses dirty-rectangle tracking to redraw only the changed portions of the display each frame, which reduces the amount of work per render cycle on slow hardware. For platforms with sufficient memory, the engine supports a triple-framebuffer configuration that allows the UI to run at the maximum frame rate the display hardware supports.

UI description files and theme files are stored in binary formats rather than text, which the README states allows them to be parsed faster at runtime. For platforms with GPU support, AWTK integrates with OpenGL, DirectX, Vulkan, and Metal. For embedded platforms that have 2D hardware acceleration but not a full GPU, AWTK supports NXP's PXP and STM32's DMA2D interfaces, with an extension point for adapting to other acceleration peripherals.

A custom LCD interface can be implemented through AWTK's extension system, which is important for embedded targets where the display controller is not a standard GPU but requires direct register control. The engine also supports skia and cairo as pluggable vector rendering backends.

Build System and Getting Started

The repository root contains both a CMakeLists.txt for CMake-based builds and an SConstruct file for SCons-based builds. A build_with_cmake.sh shell script provides a starting point for CMake builds on Linux and macOS. The awtk-cmake.md file at the root documents the CMake integration.

The examples/ directory contains a cmake_find_awtk/ subdirectory that demonstrates how to find and link AWTK from a CMake project. The demos/ and tests/ directories contain demonstration applications and unit tests respectively.

For teams that cannot reach the Alibaba ACR registry or the GitHub mirror, the README also mentions a stable version archive available via Baidu Pan. A mirrored repository is maintained at gitee.com/zlgopen/awtk for users in China who have limited access to GitHub.

Stability Tooling: Static Analysis, Memory Checking, and Unit Tests

The README describes several layers of code quality enforcement. Static analysis is performed using cppcheck and Facebook's Infer tool. Dynamic memory checking uses Valgrind. The repository's tests/ directory is backed by approximately 20,000 lines of unit test code, according to the README.

AWTK also supports event recording and playback for stress testing, which allows a recorded sequence of user interactions to be replayed repeatedly to find rendering bugs or memory leaks under load. The engine supports Appium for fully automated UI testing, which is the same test automation framework used in mobile app testing.

The valgrind/ directory at the repository root contains Valgrind suppression files, indicating that the project maintains Valgrind runs as part of its quality process. The staticcheck/ directory likely holds static analysis configuration. Manual code review and manual testing are also listed in the README as part of the stability process.

Language Bindings Generated from an IDL

AWTK is written in C, but the README states that bindings for other languages are generated using an IDL (Interface Definition Language). The generated bindings are described as targeting not just mechanical C API mapping but idiomatic code in the target language.

The README lists the following language bindings as currently supported: C, Go, C++, Lua, Java, Python, JavaScript on JerryScript, JavaScript on Node.js, and JavaScript on QuickJS. Three separate JavaScript targets are notable: JerryScript is a lightweight JS engine for microcontrollers, QuickJS is an embeddable JS engine for POSIX systems, and Node.js covers server-side or desktop use cases.

For embedded targets where memory is constrained, the JerryScript binding allows UI logic to be written in JavaScript even on devices with very limited RAM. The IDL-based approach means that when new C APIs are added to the core, bindings for all supported languages can be regenerated rather than manually maintained.

MVVM Framework and the AWTK Designer Tool

AWTK includes a separate MVVM framework available at github.com/zlgopen/awtk-mvvm. The README describes it as approximately 5,000 lines of code with high performance, low memory usage, support for C and JavaScript, and the property that it can be ported to other GUI frameworks if needed. Developers using MVVM do not need to learn AWTK's native widget API.

For UI design, ZLG provides a visual designer called AWTK Designer, available for download at awtk.zlg.cn after registration. The README describes it as a drag-and-drop WYSIWYG tool that eliminates the need to write XML layout files by hand. It supports quick preview and one-click resource packaging. The designer itself is developed using AWTK, which demonstrates the toolkit's capability for desktop application development.

AWTK's UI is described using a declarative language where features like widget animation, window animation, and image display can be enabled with a single line. The UI layout files and theme files are stored in binary format at runtime but are authored in a text-based description format.

Comparison with LVGL: Embedded-Only versus Full-Stack GUI

LVGL (Light and Versatile Graphics Library) is a widely used open-source C GUI library for embedded systems, available under the MIT licence. LVGL targets microcontrollers from the smallest MCUs up to more capable embedded processors, and it is known for its small memory footprint.

AWTK and LVGL overlap significantly in the embedded space. Both are written in C, both support bare-metal and RTOS targets, and both are actively maintained. The difference is in the scope of targets and the tooling ecosystem. AWTK extends from low-end embedded hardware all the way to Android, iOS, HarmonyOS, and Web, while LVGL does not target full mobile operating systems or browser environments as first-class platforms.

AWTK also includes the AWTK Designer, language bindings generated from an IDL, and the MVVM framework, which makes it a more complete vertical stack for teams that need to share UI logic across embedded and mobile or desktop targets. LVGL's strength is its MIT licence, its very low minimum memory footprint, and its large community of users in the MCU space. AWTK carries a more complex build configuration in exchange for broader target coverage.

Licence, Maintenance, and How to Follow Development

The last push to the repository was on 2026-09-23, five days before this review. The project is actively developed. There are no GitHub releases; the README notes that stable version packs are available via Baidu Pan.

The licence presents a discrepancy. The repository metadata reports LGPL-2.1, while section 10 of the README states that open-source code is freely available for commercial purposes under Apache License 2.0. Before integrating AWTK into a commercial project, the LICENSE file at the repository root should be read directly to determine the actual terms.

The README links to a Joint Ecology Building Plan (docs/awtk_ecology.md) for developers who want to contribute to the ecosystem. The repository also has companion repositories for specific platforms: awtk-web, awtk-android, awtk-ios, and awtk-harmonyos-next are all linked from the README. The CONTRIBUTING.md file at the root provides guidelines for code contributions.

Editorial conclusion

Embedded developers and IoT teams targeting a wide range of hardware from low-end Cortex-M3 to high-end processors will find AWTK a production-tested foundation with hardware acceleration integration. Teams that only need a desktop application GUI will find lighter alternatives without the embedded constraints. Before integrating, verify the actual licence by reading the LICENSE file directly: the repository metadata reports LGPL-2.1 while the README section on open-source commercial use cites Apache License 2.0.

Frequently asked questions

Official sources

1. Issues
2. License: LGPL-2.1
3. README
4. zlgopen/awtk on GitHub