Abiodun Solomon I’m a software developer that is curious about modern technologies. I love contributing to the growth of knowledge for the betterment of humanity.

The current state of Rust web frameworks

6 min read 1741

The current state of Rust web frameworks

Editor’s note: This post was updated on 15 January 2022 to add Dioxus to the list of frontend web frameworks and update our considerations about the maturity of some of the mentioned frameworks. 

Introduction

Rust is one of the most popular language for developers due to its open-source, fast, reliable, and high-performance features. When building a new API in Rust, it is important to consider the benefits and drawbacks of web frameworks for both frontend and backend development.

In this article, we will discuss what a web framework is and provide recommendations for which current frameworks to use for Rust in frontend and backend development.

What is a web framework?

A web framework is a software tool that supports the development of web applications; a web framework can range from a small codebase for micro apps to a large codebase for enterprise apps, and everything in between.

The most extensive web frameworks provide libraries of support for databases, templating, sessions, migration, and other utilities to speed up the development process. More simplistic frameworks focus more acutely on frontend management for static content rendering. Whatever your project needs, web frameworks can provide the web services, web resources, and web APIs that development teams need to help bring their ideas to life.

When choosing the appropriate web framework for your project, your development team should consider the relative importance of the following:

  • Security
  • Flexibility
  • Community growth
  • Project size

Depending on your project’s priorities, different web frameworks will help you address the your most pressing development requirements. In this article, we will specifically discuss frameworks built with Rust.

What are the benefits of using a web framework?

Web frameworks make web development and building desktop applications easier for developers. By standardizing the building process and automating common activities and tasks, web frameworks can save developers time and even promote reusing code to increase efficiency.

In the following sections, we will review web frameworks in Rust as they pertain to both frontend and backend development. We will then assess each framework’s phase in terms of stability, production-readiness, and project size.

We made a custom demo for .
No really. Click here to check it out.

Frontend web frameworks and Wasm

WebAssembly (Wasm) is a relatively new type of coding in low-level languages that can be run in modern web browsers. It supports C/C++, C#, Go, and Rust, with a target compilation for byte code so it can be run on the web with nearly-native performance. Wasm output is run alongside JavaScript and can be published to npm and other packages.

Rust uses a tool called wasm-pack to assemble and package crates that target Wasm. Learn more about getting started with Wasm and Rust here.

The following are some of the frontend web frameworks designed for Rust (Wasm):

  1. stdweb
  2. Yew
  3. Percy
  4. Seed
  5. Smithy
  6. Sauron
  7. Dioxus
  8. Iced
  9. Tauri

We’ll cover each of these in the next sections.

stdweb

stdweb is a frontend standard library that gives Rust the power to communicate directly with JavaScript web APIs. It was crafted to give developers the power to create full-fledged JavaScript apps in Rust by providing easy API binding between the languages to improve speed and performance.

stdweb support closures, arbitrary structure, and the standard components of web APIs, including DOM, events, and windows. Here’s a link to a few sample projects to get a grasp of how it works.

Overview

  • Stable: yes
  • Production-ready: no
  • Project size: small

Yew

Yew is an improved version of stdweb. It is a components-based framework similar to React and Elm, with support for multi-threading, component-based patterns, and other features similar to stdweb.

Overview

  • Stable: yes
  • Production-ready: no
  • Project size: small, medium, and large

Percy

Percy is a toolkit developed for building single-page apps (SPAs) and managing UI, including optimization for specific browsers and screen sizes (desktop, mobile). Percy is still a work in progress; improvements are needed for better structure, optimal boilerplate, and general bug fixes.

Overview

  • Stable: no
  • Production-ready: no
  • Project size: small, medium, and large

Seed

Seed is a frontend framework for creating performance-driven and reliable web apps that also has an Elm-like architecture. It has minimal configuration and boilerplate, and has clear documentation that makes it easy for anyone to start with.

Overview

  • Stable: yes
  • Production-ready: no
  • Project size: small, medium, and large

Smithy

Smithy is written in native Rust code, which makes for an easy learning curve for developers. It has support for interpolation and sub-components, events, state management, interaction with JavaScript, the smd! macro (inspired by React’s JSX), and server support for deployment.

Overview

  • Stable: yes
  • Production-ready: yes
  • Project size: small, medium, and large

Sauron

Sauron is a micro frontend framework that was inspired by The Elm Architecture. It has support for events, state management, and components. Sauron uses a library called html2sauron to convert HTML into Sauron view code for rendering optimization.

Overview

  • Stable: no
  • Production-ready: no
  • Project size: small

Dioxus

Dioxus is a UI library elegantly designed to be React-like — it’s built around a virtual DOM to support building cross-platform apps for web, mobile and desktop. It has support for component-based architecture, concurrency and async, props, an inbuilt error handler, state management, and more.

Overview

  • Stable: No
  • Production-ready: No
  • Project size: small, medium, and large

Iced

Iced is a GUI library for cross-platform development. It’s structured in Elm style and supports reactive programming, inbuilt widgets, and async, while also having a modular/reusable component-based architecture with type-safety and simplicity.

Overview

  • Stable: No
  • Production-ready: No
  • Project size: small or medium

Tauri

Tauri is a Rust library built as a light JavaScript framework for building desktop applications with the integration of any frontend technology that renders HTML, CSS, and JS into your web-view for its UI.

Overview

  • Stable: Yes
  • Production-ready: No
  • Project size: small or medium

For the best documentation and impressive support for interpolation with JavaScript, I suggest your selection should be determined by your specific use-case, library stability, and the listed production-readiness for each framework above.

Backend web frameworks

Backend development refers to the server-side operation of a web app. It also describes the core operations of an app that usually control and handle its data and actions, such as submitting a form or logging into a web account. Backend development focuses primarily on data management, and the database, scripting, automation, and architecture necessary to handle it.

Some of the most common features of a typical backend development framework includes:

  • Database management
  • Session
  • Templating
  • Object-relational mapping (ORM)
  • Migrations

Rust provides various web frameworks for backend development, including a combination of tools, helpers, and libraries from different vendors that are each designed to provide a way to build, test, and run apps with efficiency, security, and flexibility. We’ll explore the following backend frameworks in the next sections:

Rocket

Rocket is a popular web framework that makes it easy for developers to write fast web apps without skimping on security, flexibility, or function. It has support for testing libraries, cookies, streams, routes, templates, databases, ORMs, boilerplates, and more. Rocket also has a large and active developer community.

Overview

  • Stable: no
  • Production-ready: no
  • Project size: small, medium, large

Actix

Like Rocket, Actix is another powerful backend web framework. Actix features an architectural pattern based on Rust’s actor system and is well-equipped for building writing services and micro apps. It has support for routing, middleware, testing, WebSockets, databasea, and automatic server reloading, and can be hosted on NGINX. Actix can be used to build a full-scale web app and API.

Overview

  • Stable: yes
  • Production-ready: no
  • Project size: small or medium

Gotham

Gotham is a flexible web framework built for stable Rust that promotes “stability, safety, security and speed.” It is statically typed, thereby ensuring that application is always correctly expressed at compile time. Gotham provides async support with the help of Tokio and hyper.

Gotham supports routing, extractors (type-safe data requests), middleware, state sharing, and testing. Gotham does not have structure, boilerplate, or database support.

Overview

  • Stable: yes
  • Production-ready: no
  • Project size: small, medium, large

Rouille

Rouille is a micro web framework that employs a linear request and response design via a listening socket that parses HTTP requests. It is built to be easy-to-learn for Rust users. Rouille has support for requests through CGI, input (request header and body), content encoding, proxy, sessions, and WebSockets.

Overview

  • Stable: yes
  • Production-ready: no
  • Project size: small, medium

Nickels

Nickels is a minimal, lightweight framework for web apps written in Rust. Its API is inspired by the popular Express framework for JavaScript. It provides flexible routing, middleware, JSON handling, custom error handler, templating, and boilerplate.

Overview

  • Stable: yes
  • Production-ready: yes
  • Project-size: small, medium

Thruster

Thruster is a fast and reliable Rust web framework inspired by the layering and design of Koa and Express.js. It is SSL-ready, secure, intuitive, and testable. Thruster is built to accommodate async/await and provides support for middleware, error handling, databases, and testing.

Overview:

  • Stable: no
  • Production-ready: no
  • Project-size: small

Iron

Iron is a web framework for Rust that is built in hyper with a focus on concurrency, extensibility, and minimal excess. It can scale horizontally across multiple machines, or run multiple threads on a more powerful machine. Because it was designed to be extensible and pluggable, Iron primarily addresses middleware, plugins, and modifiers (third-party extensions) as its main components.

Iron provides support for routing, JSON body parsing, URL encoded data parsing, sessions, and static files.

Overview

  • Stable: no
  • Production-ready: no
  • Project-size: small

Tide

Tide is a minimal framework similar to Express.js (Node), Sinatra (Ruby), and Flask (Python) for rapid development that promotes building web apps in asynchronous versions.

Tide provides support for routing, auth, listener, log, template engines, middleware, testing and other utilities.

Overview

  • Stable: yes
  • Production-ready: yes
  • Project-size: small, medium, large

Dropshot

Dropshot is a simple and lightweight server-side library for creating REST APIs. It has support for openAPI specs, async, and logging.

Overview

  • Stable: no
  • Production-ready: no
  • Project-size: small, medium

For building advanced web apps, I recommend Rocket, Actix, and Tide (for asynchronous support) to roll your backend. They are all also accepted in the Rust community and each provides a large support library.

Conclusion

When choosing the correct web framework for your frontend or backend development project, it is important to consider the following: is the framework stable? Is it production-ready? It is right for the size of your project?

Depending on your answers, you will be on your way to using web frameworks to improve efficiency, speed, and productivity in Rust.

LogRocket: Full visibility into production Rust apps

Debugging Rust applications can be difficult, especially when users experience issues that are difficult to reproduce. If you’re interested in monitoring and tracking performance of your Rust apps, automatically surfacing errors, and tracking slow network requests and load time, try LogRocket.

LogRocket is like a DVR for web and mobile apps, recording literally everything that happens on your Rust app. Instead of guessing why problems happen, you can aggregate and report on what state your application was in when an issue occurred. LogRocket also monitors your app’s performance, reporting metrics like client CPU load, client memory usage, and more.

Modernize how you debug your Rust apps — .

Abiodun Solomon I’m a software developer that is curious about modern technologies. I love contributing to the growth of knowledge for the betterment of humanity.

11 Replies to “The current state of Rust web frameworks”

  1. Yeah, you’re missing Warp, it’s the Tokio equivalent to Tide. Warp and Tide are both quite good, it just depends on whether you favor async-std or tokio.

    Also, I think Iced deserves a mention here, since it can compile to WebAssembly and WebGPU, in addition to platform-native Metal, Vulkan, and OpenGL. Also, people are even experimenting pairing Iced with cargo-mobile, which is also exciting!

  2. How can you say Rocket is production-ready when it can’t even compile with stable Rust? In my environment, I will have to wait until there’s a release that can run on stable Rust. Hopefully it’s coming soon with Rocket v0.5.

  3. > Rocket is a popular, mature web framework
    Latest Release: 0.5.0

    As long as it hasn’t reached 1.0, you can’t really call it mature, now can you? It’s an admission from the developers themselves that they have not implemented everything on the roadmap yet.

  4. Sauron isn’t outdated. It is still being actively developed. Seed is effectively dead, and Yew’s syntax and performance are vastly inferior to it. By far the best frontend web framework at the moment.

  5. Why do you say that? By Github stats, both Sauron and Seed went on life support six months ago, like Stdweb and Percy did a year ago. Only Yew is maintaining its velocity and only Smithy looks dead.

Leave a Reply