Today we published version 0.3.4 of Slint following semver as usual. We do patch level releases all the time, but only announce those in our weekly updates. This release is special to us as it this will be the last release before Slint 1.0.

This year was eventful and interesting for us at Slint. In this blog post, we'd like to go through our highlights of 2022 🚀.

In this part, we're going to talk about the placement of elements, their sizing, and side effects during property evaluation.

In this blog post, I want to explore both directions of integration between Rust and C++ and present some tools we use in Slint.

In the past year we've added various small features to the language, while maintaining stability and backwards compatibility. Meanwhile, we've collected feedback from our users and gained experience by implementing some designs ourselves. We gathered various ideas to improve the language itself and we think that now is a good time to implement these: Since we're still at version 0.x and need to make these changes before we reach version 1.0.

We're proud to announce the release of Slint version 0.3.0, with many new features and APIs. Let's look at the highlights:

Today we're releasing Slint version 0.2.5, with new features and some bug fixes. This release maintains backwards source compatibility. Applications developed with previous releases in the 0.2.x series will continue to run with version 0.2.5. Let's look at the highlights:

We're delighted to announce that we've secured funding for SixtyFPS GmbH, the company behind Slint. We've raised a six-digit seed funding to expand our team: For product development, sales, and business development.

Our vision with Slint as a cross-platform native UI toolkit is to provide user interfaces for any device. Initially we focused on running on desktop-class machines and embedded devices that support OpenGL ES. A few months ago we started porting Slint to microcontrollers (MCUs), and this blog post describes how we achieved that.

We're proud to announce that we have joined the Rust Foundation as a Silver member.

We added a compat mandatory feature (enabled by default) to help with keeping our crates backwards compatible.

Today we're releasing SixtyFPS version 0.1.6, which contains new features and some bug fixes. Let's look at the highlights:

The year 2021 was fruitful yet busy for us at SixtyFPS.

Ever written a quick (shell) script to automate a small task at some point? Then that script grew over the years and perhaps ended up in the hands of way more users than you originally anticipated?

If you were lucky enough to experience this, maybe you wondered: Wouldn't it be nice to have a GUI for that script?

Today we're releasing SixtyFPS version 0.1.3, and Cargo UI version 0.2. This blog post highlights some of the new features in these releases.

Today we're releasing SixtyFPS version 0.1.2, which contains important bug fixes and some new features. This blog post highlights some of theses new features since the last release, 0.1.1. This release maintains backwards source compatibility. Applications developed with previous releases in the 0.1.x series will continue to run with version 0.1.2.

We're proud to announce the SixtyFPS 0.1 series. The 0.1 series, to us, signifies that our toolkit is graduating from "lab mode" to "development mode". We are now confident that our toolkit can be used in products. Based on semantic versioning principles, all 0.1.x releases will maintain compatibility.

Every day at SixtyFPS, we build Rust code using the cargo command line tool.

Since we are a developing a GUI library in Rust, we were curious what a GUI for cargo could look like. So we started a side-project called cargo-ui, which provides a simple GUI on top of the cargo command line tool.

Our GUI Toolkit, SixtyFPS, supports multiple programming languages with a shared runtime library. One of these is C++, with a modern API and documentation. To generate that documentation, we looked around for different tools that the C++ community provides. In this article we discuss three of the many tools that are out there: Hyde, Standardese, and the combination of Doxygen + Breathe + Exhale + Sphinx.

We have just released SixtyFPS v0.0.6, with many new features, including a Language Server Protocol (LSP) implementation for integration into popular IDEs.

With SixtyFPS, we are creating a GUI toolkit. We chose Rust as the implementation language for our runtime library, and we want to make the same library usable from different programming languages. We believe programmers in all languages need to build GUIs - powered by the same runtime library. Rust, with its Foreign Function Interface (FFI) is an excellent choice.
In this article we look at how to expose an idiomatic C++ API from our Rust library.

SixtyFPS is a new UI toolkit we are creating for applications running our desktop and embedded. Our first blog post was introducing the project. In summary, SixtyFPS is composed of a markup language that makes it easy to describe the user interface, which is then compiled to optimized C++. In this blog post, we are going to teach the basics of SixtyFPS and how to use it from C++ to create a small game. This is basically a port to C++ of our previous blog post that was targeting Rust.

SixtyFPS is a new project aiming at making a UI toolkit. The previous blog post was introducing the project. This blog post explains, through a small tutorial, how to use SixtyFPS to create a small game.