Filter content by
We're excited to introduce Slint version 1.2, which includes a wide range of new features while maintaining full backwards compatibility. This release continues our commitment to empowering developers with efficient tools for UI development. Let's take a look at the highlights.
We're thrilled to announce the release of Slint version 1.1, a powerful user interface library that simplifies the development of desktop and embedded applications. This release brings a host of exciting new features and enhancements, as well as an additional licensing option. In this blog post, we'll explore the key updates.
We're excited to announce a new feature of the upcoming release of Slint version 1.1: translation infrastructure. In this blog post, we'll provide an overview of Slint's translation capabilities and explain why we chose Gettext as the underlying technology. We also value your feedback and suggestions to help us improve this feature further.
We're thrilled to announce version 1.0 of Slint, a comprehensive toolkit to build native user interfaces for desktop and embedded devices, implemented in Rust. This is a major milestone, the result of three years of work by 50 contributors. Compared to the previous release, version 1.0 introduces only minor API cleanups and bug fixes. For full details refer to the ChangeLog.
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 🚀.
This is the second part of our series about changes to the Slint language. See the earlier blog post for the first part.
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 added a
compat mandatory feature (enabled by default) to help with
keeping our crates backwards compatible.
We're renaming SixtyFPS to Slint
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
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.
We’re Olivier & Simon - two enthusiastic software engineers who enjoy developing software for product teams. Today we’d like to introduce you to our new venture.