Kanzi 4.0.0 is not just a feature release — it is a wholesale rethinking of how developers and designers spend their time inside Kanzi Studio. From the ground up, Rightware has invested in making the day-to-day development loop faster, more visual, and dramatically less error-prone. The result is a release packed with workflow improvements that compound across every phase of a project: authoring, debugging, packaging, and deployment.
This roundup covers every major quality-of-life and tooling advancement in Kanzi 4.0.0, benchmarked against the previous production release, Kanzi 3.9.14.
The single biggest workflow change in 4.0.0.
In Kanzi 3.9.14 and all prior releases, configuring a rendering pipeline meant hand-authoring nested XML render pass hierarchies — a fragile, developer-only workflow that was difficult to read, nearly impossible to hand off, and painful to debug when something went wrong.
Kanzi 4.0.0 replaces that entirely with Prism Graphs: a node-based, visual rendering graph editor built directly into Kanzi Studio. Every render pass — scene rendering, bloom, shadow maps, post-processing, composition — is now a node in a directed graph. Connections between nodes are type-enforced. Parameters are live properties. Intermediate framebuffers are inspectable by clicking a node.
Key improvements over 3.9.14:
Visual pipeline authoring — no more XML render pass configuration
Live parameter editing — changes reflect immediately in the Preview viewport, no restart required
Intermediate target inspection — click any render target node to preview its framebuffer texture directly in the editor
Type-safe connections — the editor prevents incompatible node connections at authoring time, eliminating an entire class of runtime errors
Built-in effects — bloom, dynamic shadows (PCF), blur, and multi-pass rendering are all first-class graph patterns, not workarounds
For teams running embedded HMI programs across multiple sub-teams, Prism Graphs also provide a clear architectural contract: define a canonical graph once, share it across projects, and guarantee rendering consistency without per-project render pass archaeology.
Full details: Prism Graphs documentation
Coming to Kanzi — a first-class system for packaging and distributing project resources.
For years, sharing components between Kanzi projects meant manually copying resources, hunting down missing dependencies, and resolving namespace collisions by hand. Asset Packages solve this problem at the infrastructure level.
A Kanzi Asset Package (.kanzipackage) is a self-contained, versioned bundle of project resources — prefabs, materials, textures, animations, shaders, fonts, themes, data sources, and compiled engine plugins — with all transitive dependencies automatically resolved and included at pack time.
The Kanzi Package Manager (KPM) is the command-line and IDE-integrated toolchain that powers the full lifecycle:
# Pack a set of resources into a distributable package
kpm pack --project MyProject.kzproj --output my-components.kanzipackage
# Inspect a package before deploying
kpm list my-components.kanzipackage
# Deploy a package into a target project
kpm deploy my-components.kanzipackage --target TargetProject.kzproj
The Package Manager Kanzi Studio Plugin brings the same capability into the IDE, with a dedicated panel for point-and-click package composition, live dependency visualization, and one-click deployment into the currently open project.
Key improvements over 3.9.14 resource sharing workflows:
Automatic dependency resolution — no manual tracking of which textures back which materials
Namespace collision detection — KPM surfaces conflicts explicitly at deploy time with merge/override controls
Version tracking — every project knows exactly which package revision it is running
CI/CD ready — KPM is fully scriptable; integrate packaging into your build pipeline for automated regression testing of shared components
Full details: Asset Packages documentation
Finding problems at runtime just got significantly less painful.
Kanzi 3.9.14 offered basic runtime inspection through the Preview viewport, but diagnosing property values, node states, and binding evaluation on a running application still required a lot of guesswork and manual instrumentation. Kanzi 4.0.0 substantially raises the bar for in-editor runtime diagnostics.
In the Node Tree, an indicator next to a node now shows when a State Manager, Binding, Data Source Binding, or an Animation sets the values of some properties in that node. kanzi You can right-click the override indicator to navigate directly to the source driving that change.
Managing bindings in Kanzi Studio 4.0.0 is now more streamlined. You can now start creating a binding directly from a property and view all bindings that affect a property from the context menu of that property. kanzi Additionally, you can now add, edit, and remove identical bindings from multiple nodes at a time.
The Activity Browser, introduced in earlier releases to visualize which Activities are active at runtime, has been extended with richer state information. You can now see the full activity hierarchy, observe transition states in progress, and identify which Activity Host is managing a given sub-tree — all without pausing the running application.
The Preview performance overlay has been refined to expose more granular GPU timing data per render pass. For projects using Prism Graphs, individual graph node timings are now surfaced, making it possible to identify exactly which node in the rendering pipeline is responsible for a frame time spike without resorting to an external GPU profiler.
Managing visual consistency across large projects is no longer a manual exercise.
Kanzi 3.9.14 had a theming system, but applying a theme change across a large project — or exporting a theme for consumption by another project — was more involved than it needed to be.
Kanzi 4.0.0 introduces a refined theming workflow with improved theme export and theme application capabilities:
Theme export produces a self-contained theme artifact that can be consumed by other projects, including via Asset Packages
Theme switching via the C++ and Lua APIs is now more ergonomic, with a cleaner call surface for applying themes programmatically at runtime
Theme inheritance allows sub-themes to override only the tokens they need, inheriting all unspecified values from a parent theme — dramatically reducing duplication in multi-variant (e.g. trim level) projects
For automotive programs managing day/night mode, brand variant, and regional compliance variants across a single codebase, this means a single source of truth for design tokens that propagates cleanly to every downstream consumer.
Full details: Theming documentation
Building and navigating complex activity hierarchies just got more intuitive.
The Activity system is one of Kanzi's most powerful tools for structuring application UI — but in 3.9.14, working with deeply nested activity hierarchies inside Kanzi Studio could feel opaque, particularly when diagnosing why a specific activity was not activating as expected.
Kanzi 4.0.0 delivers several improvements here:
Activities can now be programmed directly using C++ Code Behind and Java Code Behind — a new pattern that attaches application logic code directly to an Activity node without requiring a standalone Kanzi Engine plugin. Code Behind brings the logic for an Activity's behavior physically closer to its declaration in the scene graph, making large projects significantly easier to navigate and reason about.
In Kanzi Studio, you can now take screenshots directly from the Preview window using the Screenshot button. kanzi This makes it easy to capture the current state of your application during development without needing external tools.
The Preview viewport has received visual updates to its debugging aids. The visualization of the Debug Objects has been updated kanzi, and the visualization of the Debug Grid has been updated kanzi as well, making it easier to understand layout and spatial relationships while iterating on your UI.
You can now enable an experimental selection outline in User Preferences under the Experimental tab. This provides a clearer visual indicator around selected nodes in the Preview.
Kanzi 4.0.0 includes several improvements to text and localization support. Kanzi now allows you to define a chain of fallback fonts for a font family — if a glyph is missing in the primary font, Kanzi uses the next font in the list to render that glyph. kanzi Additionally, Kanzi can now render text with fonts that contain emoji and other colored glyphs.
The Kanzi Studio localization plugin API has also been extended, making it easier for teams to build custom automation tooling around locale pack generation and validation as part of their CI pipeline.
Android is no longer a second-class platform in Kanzi.
Kanzi 3.9.14 supported Android primarily through the older appfw application framework. Kanzi 4.0.0 promotes the newer Kanzi Android framework (droidfw) as the recommended path for Android development, with expanded documentation, new tutorials, and a fully supported migration guide from appfw.
Key droidfw improvements in 4.0.0:
Jetpack Compose interoperability — a new example project demonstrates embedding Kanzi content alongside Jetpack Compose UI, enabling teams to blend Kanzi's rendering capabilities with Android's native UI toolkit
Java Code Behind — the same Code Behind pattern available for C++ is now available for Java, making it practical to write activity logic in Java without bridging to a native plugin
View adapter improvements — the Kanzi view and view adapter system has been refined with better lifecycle management, reducing the risk of rendering artifacts during Android activity transitions
| Area | Kanzi 3.9.14 | Kanzi 4.0.0 |
|---|---|---|
| Rendering pipeline authoring | Manual XML render pass configuration | Visual Prism Graph editor |
| Asset sharing | Manual copy + dependency hunting | KPM + .kanzipackage format |
| Runtime diagnostics | Basic Preview inspection | Live property values, binding failure messages, per-node GPU timing |
| Theming | Basic theme support | Export, inheritance, runtime API improvements |
| Activity logic | Engine plugins required | C++ and Java Code Behind |
| Transition authoring | Device deploy required to preview | In-editor transition preview |
| Layout precision | No guides | Rulers and guides in Preview viewport |
| Android integration | appfw primary path | droidfw promoted, Compose interop, Java Code Behind |
| RTL localization | Foundational support | Improved mirroring and mixed-direction rendering |
| Target Preview | Available, latency-sensitive | Lower latency, better connection stability |
Full documentation, tutorials, and migration guidance are available in the Kanzi 4.0.0 documentation:
All features described in this article are available now as part of Kanzi 4.0.0. Teams upgrading from Kanzi 3.9.14 should consult the migration guide before upgrading production projects, as the rendering pipeline changes introduced by Prism Graphs require projects using custom render pass configurations to be updated.