MarGib – The World Behind the Keyboard: Freya 0.4: A new chapter in Rust GUI – what do Skia and animations change in 2026?

Freya 0.4: A new chapter in Rust GUI – what do Skia and animations change in 2026?

MarGib October 20, 2026

🌐 🇵🇱 Polski · 🇬🇧 EN

Freya 0.4 brings significant changes for Rust developers: a new Skia rendering engine, a built-in animation API, and more efficient state management. Is this enough to challenge egui or Slint? We check how the new version performs in practice and who it will be the best choice for.

Freya 0.4 framework user interface with animations and Rust code — Freya 0.4 – modern GUI for Rust with animations and the Skia engine

What's new in Freya 0.4?

Freya 0.4 is a new release of the declarative GUI framework for Rust, heavily inspired by React. This time, the creators focused on three things: performance, developer experience, and better operating system support. Let's see how these promises look in practice.

New rendering engine: Skia instead of webrender

The most important change under the hood is saying goodbye to webrender in favor of the Skia engine – the same one that powers Chromium, among others. What does this mean for developers?

Higher performance – Skia handles 2D graphics excellently, making the interface feel noticeably smoother, especially on macOS and Linux.
Greater stability – webrender could be temperamental on some Linux distributions (e.g., causing graphical glitches under Wayland). Skia solves these issues.
Future-proof – Google is behind the development of Skia, which guarantees long-term and stable support.

Switching to a new engine also has its price. Skia requires installing additional system libraries (like libskia-dev on Linux), which may be a minor barrier for beginners at the start.

Animations and state management: a step toward modern UIs

Version 0.4 introduces a built-in animation API – a feature the community has been asking for most loudly. Thanks to the new Animation trait, you can easily bring the interface to life by creating smooth transitions:

fade-in/fade-out effects,
smooth movement and scaling of elements,
animated switches or lists.

You can find implementation examples in the official documentation, which shows, among other things, how to animate a simple button.

Another big thing is improved state management based on so-called signals (a concept known from SolidJS). Signals allow you to update only those parts of the screen that have actually changed, without rebuilding the entire UI tree. The library also includes new hooks:

use_animation – for controlling motion,
use_memo – for memoizing heavy calculations,
use_effect – for handling side effects.

Thanks to this, Freya becomes a natural environment for anyone with experience in modern frontend development.

Built-in components and API improvements

Instead of writing everything from scratch, version 0.4 provides a set of ready-to-use, frequently used components:

Dropdown (dropdown menu),
Slider (slider for selecting values),
Tooltip (tooltips).

API typing has also been improved, which means less fighting with the Rust compiler. A simple interface with a button now looks exceptionally clean:

use freya::prelude::*;

fn app() -> Element {
    let mut count = use_signal(|| 0);

    rsx! {
        rect {
            height: "100%",
            width: "100%",
            main_align: "center",
            cross_align: "center",
            Button {
                onpress: move |_| count += 1,
                label { "Kliknięć: {count}" }
            }
        }
    }
}

The code is readable, and the declarative style makes switching from React or SolidJS almost painless.

Freya vs. the competition – how does it stack up?

The Rust GUI ecosystem is slowly maturing, and Freya has to face several strong rivals. Let's see how it compares to them.

Freya vs. egui

egui operates in immediate mode (the interface is redrawn every frame). This is a brilliant solution for simple developer tools or game panels, but it can be inefficient for large, classic desktop applications.

egui pros: Excellent documentation, a huge and mature community, and seamless WebAssembly support.
Freya pros: Modern, declarative API, built-in animations, and better performance with complex layouts.

If you are building a classic windowed application and care about a nice, smooth look – Freya wins. egui remains the king of quick diagnostic panels and internal tools.

Freya vs. Slint

Slint is a mature declarative project that strongly targets embedded devices and IoT. It uses its own interface description language, which strongly resembles the QML format known from Qt.

Slint pros: Excellent support for embedded platforms, stability, and readiness for commercial use.
Freya pros: No need to learn a new UI description language (everything is written in Rust), flexible animations.

For a classic desktop, Freya may turn out to be more pleasant to code in. Slint, on the other hand, is an unrivaled choice when you are targeting touchscreens of microcontrollers or need full commercial support.

Freya vs. Iced

Iced is inspired by the Elm architecture. Like Freya, it renders the view only when the state changes, but it does so in a more traditional, minimalist way.

Iced pros: Clear architecture, stable support for the web, and a growing ecosystem.
Freya pros: Reactive signals, easier work with dynamic animations, and a richer set of ready-made controls.

Iced is captivating in its simplicity, but if your application needs to look modern and react dynamically to user actions, Freya provides much better tools.

Freya vs. Tauri

Tauri is in a completely different category – it is a bridge between Rust and web technologies (HTML/CSS/JS). The UI runs here inside a system Webview.

Tauri pros: Ability to use any web framework (React, Vue, Svelte), huge community, and project maturity.
Freya pros: Fully native rendering without browser overhead, no need to mix Rust with JavaScript.

If you want to stick to pure Rust and care about maximum performance without running a browser engine in the background, Freya is a great direction. Tauri remains unrivaled when you want to port an existing web application to the desktop.

Who is Freya 0.4 for?

The new release of Freya will be appreciated primarily by developers who:

want to create smooth, aesthetic desktop applications without using web technologies,
value reactive state management (signals) and a declarative coding style,
need a built-in, easy-to-use animation system.

On the other hand, it is worth looking for other solutions if:

stable support for the browser or embedded systems is key for you,
you are looking for the simplest and most stable API possible without unnecessary bells and whistles,
you just want to wrap your web application in a lightweight desktop client.

Platform support and system requirements

The framework performs quite well on the most popular systems:

Windows – stable operation and better DPI scaling support,
Linux – elimination of rendering issues under Wayland,
macOS – smooth performance thanks to optimization for system rendering.

Technical requirements are not high, although you need to keep a few things in mind:

an up-to-date version of the Rust compiler,
system dependencies such as Skia libraries (especially on Linux) or appropriate build tools (Visual Studio / Xcode),
a graphics card supporting OpenGL 3.3 or newer, or Vulkan.

Detailed environment configuration instructions can be found in the getting started documentation.

Documentation and community – is the project production-ready?

Although the project is relatively young, the documentation looks promising. We can find there, among others:

A beginner's guide that walks you through setting up your first project step-by-step,
An animation guide explaining how the new API works,
A section dedicated to state management using signals.

The community around the project is growing, although it is still intimate compared to the giants:

several thousand stars on GitHub,
an active Discord server with a helpful support channel,
responsive creators who quickly address reported bugs.

If you are looking for technology with an established market position, with hundreds of ready-made solutions on Stack Overflow, Freya may still require some patience. However, if you like a modern approach to UI and want to have a real impact on the library's development, this is a great time to join the project.

Future plans – what's next?

The project's development plans look promising. Among the announced novelties are:

Subsequent minor releases:
- experimental WebAssembly (WASM) support,
- tools for easier interface debugging and hot reloading,
- new components, such as data tables or tree views.
Stable version (1.0):
- API freeze and a guarantee of no breaking changes,
- support for mobile systems (Android and iOS),
- deeper integration with the Tauri ecosystem.

The biggest challenge for the creators will now be:

further optimization for very complex views,
attracting new contributors to the project,
expanding the base of practical examples and tutorials.

Summary – is it worth giving version 0.4 a chance?

The Freya 0.4 release shows that native GUI in Rust doesn't have to be clunky or difficult to design. The new Skia engine, built-in animations, and reactive signals make creating windowed applications simply enjoyable. Although the project is still maturing and lacks full browser or mobile device support, it already represents a very strong proposition for desktop developers.

If you like modern design patterns and want to write smooth applications in pure Rust, Freya 0.4 is definitely worth testing. If, however, your priority is absolute stability or cross-platform support including the web, egui or Slint remain safer choices at this moment.

We are rooting for further development – if the creators manage to deliver support for WASM and mobile systems, Freya has a huge chance to become one of the most important players in the Rust world.

If you are interested in modern tools written in this language, also check out our article on UV – an ultra-fast package manager for Python written in Rust.