February 10, 2022 by The Slint Team

SixtyFPS becomes Slint

We're renaming SixtyFPS to Slint

Why change?

In Spring 2020, we started SixtyFPS to create a new GUI framework for Desktop and Embedded devices.

In almost two years we've made thirteen releases, won many users, built a community of contributors, signed a few customers, and collected 3k GitHub Stars 🤣.

We chose the name SixtyFPS because we wanted to convey our goal of achieving fluid animations always. This is commonly associated with a refresh rate of 60 frames per second.

Many onlookers take this name literally: Whenever our project shows up on social media, we get comments about our name: that it appears outdated considering that nowadays screens often run at higher refresh rates.

We considered changing the name and decided to discuss this in the open source community to collect ideas. We opened a discussion on GitHub and received many great suggestions.

@karoofish suggested slant, which became the highest voted suggestion and we liked it a lot. We ran this with some friends, including some native speakers, and some suggested that it can have a slightly negative meaning in some context. All we needed was a little iteration.

Our new name derives from Straightforward, Lightweight, Native Toolkit, which are our design goals. Slint.

A huge thank you to everybody who got involved, especially @karoofish!

What's Slint?

For those who have never heard of SixtyFPS Slint before, it's a GUI toolkit implemented in the Rust programming language.

At its core is the declarative Slint mark-up language, which represents the entire user interface. The Slint language took some inspiration from Qt's QML. This was natural, since we were coming from that ecosystem. We decided to build it with strong typing from the ground up, a designer-friendly unit system and full tooling support. Write the user interface in Slint markup and the business logic in a "real" programming language.

You can use Slint with different programming languages, like Rust, C++, and JavaScript. We've designed our APIs for those languages to be intuitive and idiomatic, not just some automatically generated bindings. We've designed the toolkit so that we can add Python, Go or other languages to the mix.

Our own compiler parses the Slint language and compiles straight to native Rust or C++ code, with native performance and efficient memory layout. You can also load .slint files dynamically at run-time with our run-time interpreter.

Our tooling includes a Language Server Protocol implementation that integrates into various IDEs and editors. It provides auto completion, semantic syntax-highlighting, and a cool live-preview, as demonstrated in the following video clip.

Slint version 0.2.0

The purpose of the 0.2.0 release is to reflect this name change.

We also took the opportunity to make some important changes to our API, that we've collected since the 0.1.0 release last year thanks to your feedback.

Here's how you can upgrade your application:

• Make sure that you meet our updated tooling requirements: Rust 1.56 or later. If you're using C++, a compiler that supports C++ 20.
• If you're using Rust, change your Cargo.toml to depend on slint instead of sixtyfps. If you're using C++, change your CMakeLists.txt to find the Slint package and link against the Slint::Slint target.
• In your application code, rename all occurrences of the sixtyfps module/namespace with slint. For API changes, see our Rust (+ Interpreter) and C++ migration guides.

In this release we also threw in a new feature: You can now integrate custom OpenGL code before or after the rendering of a Slint scene. The new OpenGL Underlay example shows how to do that in Rust and C++.

New website and design

You may have noticed that the location of our website, the design, and the logo have changed. We took the opportunity to refresh our branding, with help from Benedikt Wisbauer. We also moved the organization on GitHub.

You can find our new GitHub repository here: github.com/slint-ui/slint.

We hope that you can connect with our new name, branding, and our latest release. 🚀❤️

If you're curious about our old website, it's still available on the internet archive.

Comments

Slint is a Rust-based toolkit for creating reactive and fluent user interfaces across a range of targets, from embedded devices with limited resources to powerful mobile devices and desktop machines. Supporting Android, Windows, Mac, Linux, and bare-metal systems, Slint features an easy-to-learn domain-specific language (DSL) that compiles into native code, optimizing for the target device's capabilities. It facilitates collaboration between designers and developers on shared projects and supports business logic development in Rust, C++, JavaScript, or Python.