The popularity of Rust is demonstrated year after year, as Rust is regularly named one of the most loved languages among developers. This year was the seventh consecutive year in which the Stack Overflow Developer Survey highlighted growing interest in Rust.
Rust adoption among enterprise companies is also gaining momentum. The technology is used under the hood of globally recognized software projects including Cloudflare and Dropbox.
Among the reasons to use Rust in production are its high performance, memory safety, and capabilities for building software that is unlikely to fail in production. Rust has a supportive and highly active developer community, which enables the dynamic evolution of the language. We talked about the Rust technology market in detail in one of our previous articles.
Read also:The state of the Rust market in 2022
The advent of Rust web frameworks and libraries has become an important step in the language’s evolution, making Rust a promising technology for web development. In this article, we review the most popular and reliable Rust web development frameworks so far and analyze when they are applicable. But first, let’s have a look at the peculiarities of using Rust for web development.
Rust for web development: state of adoption
The Rust ecosystem has been greatly expanding over the past few years. New open-source libraries and technology resources, forums filled with lively debates between engineers, and community reports on the technology’s growth prove the momentum behind Rust adoption.
At the same time, hesitations remain about making Rust part of a product’s tech stack. Rust libraries are still rather basic and immature, and implementing Rust requires employing top-notch engineers.
Small and medium-sized companies are the most likely to be using Rust in production. But bold decisions about using Rust for web applications are also being made by globally recognized companies.
So what is the current state of Rust adoption?
Rust evolution and uses
Rust was introduced in 2010, which makes it a relatively new programming language compared to the more conventional Python and C++. However, what’s significant is not the age of the language but the velocity of its development and adoption.
Rust appeared in response to the growing need to create complex software in a wise way and, along with that, decrease the time for its production. What is really impressive about Rust is how the development community picked up the language and gave it a boost.
The results of the Rust Survey 2021 confirm that every effort invested in adopting Rust for web development has paid off. Although 47 percent of respondents admitted getting started with Rust was challenging, 82 percent claimed they were able to achieve their goals with Rust and 90 percent said they are likely to use it in the future.
The adoption of Rust by huge tech companies is also inspiring:
Mozilla was the first company associated with Rust. Graydon Hoare, the inventor of Rust, worked at Mozilla Research, and the company soon invested in the language and became its loyal supporter. When writing Stylo, the CSS engine in Firefox, developers were able to replace about 160,000 lines of C++ code with only 85,000 lines of Rust code.
Dropbox, a popular file hosting service, has written some of its core file storage components in Rust. The language is also used to develop some features of the brand’s file syncing engine.
Cloudflare, a content delivery network and provider of web security services, leverages Rust because the language offers WebAssembly support. They also used Rust to create Pingora, an in-house HTTP proxy that serves over one trillion requests a day.
Discord, a social platform for instant messaging and voice communication, switched from Go to Rust to avoid the latency spikes they used to experience with the Read States service.
Benefits of using Rust for web development
The pace of the Rust ecosystem’s growth and the benefits Rust offers for web development have made it a fit for various projects and businesses. In particular, Rust is gaining popularity for developing distributed and embedded systems, IoT connectivity, edge computing, and low-latency web services.
The main reasons to choose Rust for web development are as follows:
Rust doesn’t use virtual machines or a garbage collector, which allows for achieving better runtimes compared to Java and C++.
Rust has async support, which positively influences the speed of development.
Using Rust in production allows for achieving low latency.
Implementing Rust helps you effectively use server capacity, allowing you to potentially decrease operating costs.
Rust is able to overcome issues related to memory safety and memory leaks.
The language is secure and bug-free. For instance, it has easy error handling and does not experience the undefined behavior issue present in other languages.
Being a general-purpose language, Rust has been enriched with a number of different frameworks. They allow engineers to create web apps of varying scale and complexity while preserving a high development speed.
What’s special about Rust web frameworks?
As a rule, the advent of frameworks testifies to the maturity of a programming language, making it more reliable and suitable for large-scale projects. Along with that, frameworks showcase the trust in and commitment to a language among the tech community.
A Rust framework is a set of tools and resources that allow software engineers to create web applications in the Rust programming language. In other words, a Rust web development framework includes web services, web resources, and web APIs that support Rust engineers in the development process.
Frontend development with Rust and Wasm
Rust is usually referred to as a backend programming language, but it can be applied on the front end using WebAssembly (Wasm).
WebAssembly is a binary-code format that allows developers to execute code in web browsers. Wasm is also referred to as a virtual machine that makes it possible to run heavy tasks (for example, image processing) on the client, enabling a high level of performance.
A combination of Rust and Wasm may be applied when a complex programming task needs to be executed in the browser. An example of such a task is the server-side rendering of images in Figma, a popular web-based UI design tool. Although Figma uses WebAssembly with C++, Rust is also part of the tech stack in production.
Currently, there are more than 20 open-source resources, including libraries and frameworks, that support Rust developers on the front end and back end. At Yalantis, we use Rust mostly for server-side development. Therefore, in reviewing frameworks, we’ll focus on backend Rust web programming.
How to choose a Rust backend framework
A good Rust framework is able to optimize the time web engineers spend on development and cover essential technical needs such as system security and the ability to cope with high loads.
When choosing between Rust web frameworks, there are several factors to take into account:
Ease of use refers to how intuitive and comprehensive a framework is. This includes the way information is organized (for example, if components are intuitive enough) as well as the overall logic and structure of the framework. Ease of use directly impacts the speed of web development, which is why it’s one of the key criteria to consider.
Project size indicates how difficult it may be to integrate a framework. If a project is small and the functionality to develop is basic and lightweight, there are many frameworks to choose from. Once a project has a complex architecture with many technologies, it becomes more challenging and important to find a framework that can fulfill all the needs.
Documentation proves the maturity of a framework and allows us to evaluate it from a technical perspective.
What’s also really important for a Rust engineer is the number of examples available within a framework. When looking at an example, a developer is able to understand the code quickly and can avoid spending lots of time reading the documentation, so the speed of development increases. This is always good news for the client.
Framework security. This criterion includes overall framework stability, which depends on the frequency of updates released by framework creators. Sticking to frameworks that receive regular updates avoids code vulnerabilities that can result in severe security issues in production. It’s important to choose frameworks that support transport layer security (TLS) in its current version as well as security certificates.
Framework flexibility refers to the range of features available with a framework. This includes, for example, API support (REST, GraphQL, GRPC), HTTP version support, async streams support, and runtime support (for example, Tokio or async-std).
Community support includes overall engagement of developers in subject matter discussions, the input each member brings to the community, reactions to bugs reported, and fixes aimed at the framework’s evolution.
This list can be extended with factors including framework ergonomics, ecosystem completeness (the abundance of libraries and web resources on the framework), and more. At the same time, the final choice of framework is usually based on technical characteristics.
Read also: How to create a RESTful API
What is the best Rust web framework?
Some Rust frameworks are production-ready and stable, while others are not. In this part, we review three Rust web frameworks we’ve evaluated at Yalantis and applied to our projects. All of them are suitable for web solutions of different scales and complexity and are worth paying attention to.
One of the most popular Rust frameworks is Actix Web. It’s known for using the most recent stable build of Rust, and thus being a stable solution for Rust web development.
Features of Actix Web:
Compatibility with Tokio, one of the most popular Rust runtimes
Support for the WebSockets protocol
Ability to handle high loads using multipart streams
Streaming and pipelining
Support for the newest HTTP versions (HTTP/1.x and HTTP/2)
Being a Rust API framework, Actix Web supports routing, testing, and middleware. It also has automatic server reloading. The framework has the highest benchmark performance among competing solutions. So far, the only limitation Actix could present is that it doesn’t support hyper, the most tested and reliable HTTP stack in Rust.
Rocket is another Rust web server framework that has been getting much support from the dev community in the past few years. In the six years since its release, Rocket has proved to be effective for both developing small and large-scale projects.
The Rocket framework offers a number of useful features that accelerate Rust web development by bringing various benefits to engineers.
Support for async streams
No boilerplate, meaning all code generated by Rocket is produced automatically, saving developers’ time
Built-in templating support
Availability of a testing library
Type-safe design, which means the framework offers enhanced capabilities for eliminating potential server issues
All of this makes Rocket a fast and secure framework that also focuses on the performance, flexibility, and usability of web apps. It is a universal and multi-purpose solution that easily adapts to developers’ needs. The only limitation is that Rocket only runs on the nightly version of Rust, which makes it unavailable to projects using other Rust versions.
Although Axum is one of the most downloaded frameworks for Rust web development, it’s not publicly mentioned as often as Actix Web and Rocket. Despite that, Axum is a reliable framework in the Rust ecosystem.
Axum’s high-level features make it a fit for a wide range of projects:
Minimal boilerplate with responses
Simple and predictable error handling
Request routing with a macro-free API
Declarative request parsing
Tower and tower-HTTP ecosystem allows for making the system modular and supports adding additional modules to the framework
Axum is part of the Tokio project and is built on top of hyper, which was also developed by the Tokio team. The Tokio project has a huge ecosystem and community.
Promising Rust frameworks to look at in the future
As a rule, new frameworks come along to address issues that have appeared in more mature frameworks and offer ingenious solutions to project limitations that may appear (in terms of hardware, performance, or power). However, the fact that new frameworks are not fully tested and may lack some essential features makes them risky to use in production.
At Yalantis, we give priority to frameworks that have already proven to be stable in production. At the same time, we believe that when working with a dynamic language like Rust, it’s important to stay up to date on newly appearing resources.
Below are two less popular Rust frameworks we recommend looking at.
Gotham promotes stable, secure, and fast web development with Rust. It is statically typed, which means the application is always correctly expressed at compile time.
Gotham supports the following features:
Async support with Tokio and hyper, an HTTP implementation written in and for Rust
Type-safe data requests support
Middleware, state sharing, and testing support
Gotham is a young project and has not been tested very well, but it has a promising future due to its intuitive nature and support for vital features. Among the drawbacks of Gotham is the fact that it does not have database support. Also, the lack of macros requires programmers to write a lot of boilerplate code, which can affect the speed of development.
Read also:How to choose a database
Tide is similar to Sinatra for Ruby and Flask for Python. It’s a minimal HTTP server framework that promotes rapid web app development in asynchronous versions. Tide is an intuitive and easy-to-use framework that's worth considering for simple projects.
Tide provides basic features like auth, log, and listener and has some extended functionality:
Template engine support
Tide’s main restriction remains Tokio incompatibility. So far, the framework only supports async-std, which narrows its use to small and medium-sized projects. At the same time, Tide’s basic capabilities are perfect for deploying and programming a simple web app.
Each of the frameworks mentioned above is good for different purposes. Some are more intuitive and easier to build with from scratch. Others are more complex but support a lot of features that are important for projects with particular technologies.
Rust has become a popular technology for backend development thanks to its security, speed, and performance. Coding in Rust has become more efficient with the advent of Rust web development frameworks. The variety of frameworks available for Rust testifies to its growing maturity.
To decide on the best web framework, Rust engineers usually evaluate options from the perspective of technical tasks they can solve. The more features a framework has, the broader its field of application.
With the choice of frameworks being the prerogative of web engineers, partnering with a reliable service provider is a crucial challenge business executives face. To avoid getting lost among the options on the market, we recommend sticking to objective criteria for choosing a software development provider and making your choice wisely.
Need a reliable software engineering partner?
We can give you a hand at any stage of the development process