Rust web frameworks: development in 2023

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.

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. Making use of frameworks allows engineers to streamline the development process thus optimizing the time and operational costs of business executives.

At the same time, choosing a suitable Rust framework for a particular project often presents a challenge, as you need to consider not only the pros and cons in terms of a framework usage by the development team, but evaluate the technical aspects like the framework’s stability and performance readiness.

In this article, we review and compare the most popular 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.

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.

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.

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 typical Rust web development framework includes web services, web resources, and web APIs that support Rust engineers in the development process.

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.

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.

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.

Actix Web

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
• TLS encryption
• Static assets
• 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

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.

Axum

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.

To explain how frameworks help developers complete tasks and influence product development, let’s compare the two most popular Rust web frameworks to understand what features each framework supports and why they are important.

At Yalantis, we analyze frameworks and libraries to determine the best fit for each particular project. Recently, our Rust web development team needed to develop a complex distributed system for an e-mobility provider. For that purpose, we looked at Actix Web and Axum to evaluate if they possessed a set of essential features.

Below is an example of a comparison chart we made to understand which framework was the better fit.

Since one of the essential features we needed to implement was the ability to establish a Bluetooth connection, support for custom connection protocols became a decisive factor for our team. Because of this, we chose Axum.

As you can see, the majority of essential features were available with both options, proving that Axum and Actix Web are both rather stable and mature frameworks.

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.

Below are two less popular Rust frameworks we recommend looking at.

Gotham

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
• Routing support
• 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.

Tide

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:

• Routing support
• Template engine support
• Middleware
• Testing

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.

Why consider Rust web development with Yalantis?

At Yalantis, we are curious about cutting-edge technologies and ways of making software development easier for business executives and product owners. We believe that technologies like Rust are worth taming and are eager to share our knowledge and experience.

If you seek to find tech talents that are knowledgeable in the development of embedded and distributed systems, edge computing, and IoT, consider ramping up your team with our Rust web developers. Here are some facts about our Rust community and the opportunities you’ll be getting with us:

• We contribute to the growth of the Rust tech community by organizing a school for switchers (engineers working with Go and other programming languages)
• Our in-house Rust team has increased from two to 15 specialists in half a year
• We regularly organize online events for Rust developers to share our expertise and grow more tech talents and create a dedicated Rust community
• Our developers have expertise working with Rust compiler, writing dedicated Rust libraries, developing and setting up complex distributed and high-load systems

Our refined working processes and strong tech expertise make us a reliable outstaffing partner. Together we can achieve more!