2024 was an important year for Rust. The ecosystem kept growing, the language made big improvements, and the community stayed very active. In this article, we’ll look at the main highlights—from the release of Rust 1.75 to exciting projects in AI, embedded systems, and WebAssembly. We’ll also cover major conference talks, new tools, key GitHub repositories, and the future direction of this fast-growing language.

Language and Toolchain Evolution

Rust 1.75 and Beyond

The year started with the release of Rust 1.75 (official blog post), which brought several small but helpful improvements. Later updates continued to refine features, stabilize ones that were still experimental, and respond to popular community requests. The main goal stayed the same: make Rust even easier and more efficient for developers.

Async Rust Improvements

In 2024, the async Rust ecosystem made significant strides, continuing to refine one of Rust's most impactful features. Developers focused on simplifying error handling, making asynchronous code easier to write, read, and debug. These improvements aimed to reduce boilerplate and provide cleaner syntax for handling asynchronous workflows, which are increasingly common in modern Rust applications.

There were also ongoing discussions about async fn in traits, a long-requested feature by the community. This enhancement aims to bring more power and flexibility to asynchronous trait methods, enabling cleaner and more ergonomic designs for async abstractions.

Additionally, async closures are now natively supported in Rust 1.85.0 nightly (more details here). This feature allows developers to define closures with the async keyword directly, simplifying scenarios where asynchronous behavior is embedded in functional patterns like map, filter, or iterator adapters.

Const Generics Progress

Work on const generics continued, helping with more advanced compile-time calculations and more expressive code—especially useful for array handling and other data structures. This feature opens up new possibilities for Rust’s compile-time capabilities.

Type System Refinements

Rust’s type system got better too. Some features that improve type inference and make complex generic code simpler were stabilized. Expect more enhancements in upcoming releases, making the language smoother and more enjoyable to use.

Ecosystem Growth and Key Projects

Rust for AI/ML

In 2024, Rust continued to establish itself as a key player in AI and Machine Learning (ML), offering a powerful combination of performance, memory safety, and low-level control. Its growing ecosystem proved valuable for building AI frameworks, deploying large language models (LLMs), and developing high-performance systems for real-time inference and retrieval-augmented generation (RAG).

A major milestone was Rust-GPU's transition from Embark Studios to the community, enabling wider collaboration and long-term sustainability for GPU-accelerated AI tasks. Frameworks like Candle and Burn led the way, with Candle excelling in lightweight AI model deployment and Burn offering a flexible, scalable architecture for training and serving neural networks. Meanwhile, tch-rs provided seamless PyTorch (LibTorch) bindings, and TensorFlow bindings continued to improve.

The rise of mistral.rs, an optimized LLM library, marked a turning point. It outperformed llama.cpp in inference efficiency and supported models such as Llama, Qwen, Mixtral, and Gemma, making it a preferred tool for chatbot development and multimodal AI applications.

In scientific computing, libraries like ndarray and nalgebra remained essential for tensor operations and linear algebra tasks. opencv-rust brought robust support for real-time image processing, while similari-rs delivered powerful object-tracking capabilities through algorithms like DeepSORT.

On the infrastructure side, Qdrant, a high-performance vector database, became integral for RAG workflows, powering recommendation systems and AI search engines. SurrealDB, a multimodel database, bridged the gap between database management and AI workflows, handling structured and unstructured data efficiently.

Rust's growing integration with WebAssembly (Wasm) extended AI deployment to edge devices, browsers, and mobile platforms. This made Rust a preferred choice not just for backend inference systems but also for lightweight, client-side AI tasks.

In 2024, Rust became more than an experimental language for AI—it emerged as a production-ready, scalable ecosystem. With frameworks like Candle, Burn, and mistral.rs, alongside libraries like ndarray, opencv-rust, and similari-rs, Rust provided the tools needed for cutting-edge AI research and deployment. Its unique blend of safety, speed, and versatility positions it to play an increasingly central role in the evolution of AI and ML technologies.

Embedded Systems: Safety and Performance at Scale

Rust continued to make waves in embedded systems with the stabilization of embedded-hal v1.0. More hardware vendors adopted Rust support, and tools for debugging and deployment became more reliable. The community explored new platforms and use cases, while experimental operating systems like Maestro OS demonstrated Rust's suitability for low-level systems programming. Additionally, efforts continued to expand Rust's role in embedded Linux kernels, with growing contributions from both independent developers and large corporations.

WebAssembly (Wasm) and Rust

The WebAssembly Ecosystem: WASM, WASI, and Tooling

In 2024, Rust continued to assert itself as a dominant force in web development and WebAssembly (Wasm), driving advancements in both frontend frameworks and server-side rendering (SSR) solutions. Tools like wasm-pack and wasm-bindgen continued to evolve, simplifying the process of packaging Rust libraries into WebAssembly modules and integrating them seamlessly with JavaScript applications. Meanwhile, WASI (WebAssembly System Interface) provided a standard interface for WebAssembly applications to interact with operating systems, expanding the scope of Wasm beyond browsers and into server-side and edge computing environments.

One of the key innovations of the year was the introduction of JCO (JavaScript Core Optimized), a native JavaScript-WebAssembly toolchain designed to streamline the integration of Wasm modules into JavaScript environments. JCO made it easier to build, deploy, and manage WebAssembly components in large-scale JavaScript applications, offering improved build speeds and enhanced performance optimizations.

Rust-Based Web Frameworks: Bridging Frontend and Backend

Rust’s web development ecosystem thrived, with frameworks like Dioxus, Leptos, and Yew gaining widespread adoption. These frameworks brought high-performance, ergonomic solutions to frontend development while seamlessly integrating with Rust-based web servers such as Axum and Actix Web for server-side rendering (SSR) and static site generation (SSG).

• Dioxus emerged as a robust React-like frontend framework, offering a declarative UI model, fine-grained reactivity, and cross-platform support (web, desktop, and mobile). A standout feature introduced this year was hot state reload, which allowed developers to preserve the application state across recompilations by leveraging a new Wasm binary patching mechanism.
• Yew, another React-inspired framework, continued to mature with enhancements in component lifecycle management and state management tools. Known for its efficient use of Rust's concurrency model and its integration with WebAssembly, Yew became a go-to choice for developers building complex single-page applications (SPAs) with minimal runtime overhead.
• Leptos, in contrast to Dioxus and Yew, took a signal-based approach to reactivity, minimizing unnecessary re-renders and improving performance in highly dynamic applications. Leptos offered built-in support for SSR (Server-Side Rendering), SSG (Static Site Generation), and even edge deployments, positioning itself as a powerful contender to JavaScript frameworks like Next.js and Nuxt.js.

Server-Side Rendering (SSR) and Full-Stack Rust

One of the most exciting trends in 2024 was the convergence of frontend frameworks (Dioxus, Yew, Leptos) with high-performance backend web servers (Axum, Actix Web). This integration enabled seamless Server-Side Rendering (SSR) workflows, reducing initial load times and improving SEO for Rust-powered web applications.

• Axum and Actix Web became the go-to choices for backend APIs and SSR workloads, providing low-latency routing, efficient state management, and deep integration with asynchronous Rust runtimes like Tokio.
• Frameworks like Leptos and Dioxus took full advantage of these backend capabilities, enabling developers to render components on the server, stream updates efficiently to clients, and reduce client-side JavaScript bloat.
• Hot-reload support across Dioxus and Leptos allowed developers to iterate quickly without the friction of full rebuilds, while Dioxus's experimental binary patch hot-reload pushed the boundaries of what’s possible in iterative web development.

The combination of these frameworks and backend services mirrored the experience developers have come to expect from tools like Next.js and Nuxt.js but with Rust's signature advantages: memory safety, high performance, and strong typing.

Full-Stack Rust Applications: WASM on the Edge

With WASI becoming more standardized and widely adopted, Rust-powered WebAssembly applications began to move beyond the browser. Platforms like Cloudflare Workers, AWS Lambda@Edge, and Fastly Compute@Edge provided native support for deploying Rust+Wasm modules directly to the edge, enabling low-latency applications and serverless deployments.

• Frameworks like Leptos and Dioxus started offering templates and integrations for edge deployments, allowing developers to build full-stack applications with minimal latency and maximum portability.
• The Qdrant vector database, optimized for AI and search workloads, and SurrealDB, a multimodel database with native Rust support, were frequently paired with WebAssembly applications, enabling data-driven edge architectures.

Cross-Platform Development

In 2024, Rust solidified its position as a powerful tool for cross-platform application development, bridging the gap between desktop, mobile, and web environments. Thanks to its combination of performance, security, and small binary sizes, Rust became a preferred backend and logic layer for applications targeting diverse platforms.

Tauri v2 emerged as a key player in this space, supporting desktop (Windows, macOS, Linux) and mobile platforms (iOS, Android) with ease. Tauri's architecture allows developers to pair Rust backends with frontend technologies like React, Leptos, or Dioxus, creating lightweight, performant applications with minimal resource consumption. Its focus on small binary sizes and security-first principles made it an appealing alternative to Electron for building modern cross-platform apps.

Frameworks like Dioxus and Xilem extended their support for cross-platform rendering, introducing Flutter-like capabilities with their own custom rendering engines. These engines ensured consistent performance and native-like experiences across different operating systems, enabling developers to build interfaces that felt at home on every platform.

For mobile development, tools like flutter-rust-bridge and Rinf provided streamlined ways to integrate Rust code into Flutter applications. These bridges allowed developers to write performance-critical components in Rust while leveraging Flutter's extensive UI toolkit for mobile interfaces. Similarly, uniffi-bindgen-react-native empowered developers to create React Native turbo-modules in Rust, seamlessly blending Rust's backend capabilities with React Native's mobile UI framework.

This convergence of frontend technologies, cross-platform rendering engines, and efficient Rust-powered backends unlocked new possibilities for developers. Whether targeting mobile, desktop, or embedded platforms, Rust delivered on its promise of safety, speed, and versatility, setting the stage for a future where cross-platform development feels seamless, consistent, and highly performant.

Game Development

In 2024, Rust solidified its position in game development, becoming a top choice for both indie and large-scale projects. Its ecosystem thrived, driven by advancements in game engines, physics libraries, and tooling, all emphasizing safety, concurrency, and performance.

The Bevy engine remained a standout, with versions 0.13.0, 0.14.0, and 0.15.0 introducing improvements to ECS performance, GPU resource management, and cross-platform support. Celebrating its 4th anniversary, Bevy also established the Bevy Foundation for long-term governance and growth.

For developers preferring a scene-based engine, Fyrox 0.34.0 delivered enhancements in physics simulations, scene graph performance, and editor usability, making it ideal for both prototyping and production.

Meanwhile, Godot's Rust integration continued to mature, offering stable bindings and an expanding plugin ecosystem for tasks like asset streaming and multiplayer networking.

Physics engines played a key role, with Rapier Physics excelling in collision detection and threaded simulations, while Avian Physics emerged as a lightweight option for 2D and 3D mobile projects.

Rust’s tooling ecosystem also improved, with better cross-platform build toolchains, enhanced profiling tools, and a growing library of community plugins and assets.

Community engagement flourished through game jams (e.g., itch.io), online forums (e.g., the Rust GameDev Working Group), and an active open-source culture, lowering barriers for newcomers.

By the end of the year, Rust was no longer just an experiment in game development but a production-ready choice, delivering cutting-edge performance, robust tooling, and a growing community ready to tackle the challenges of modern game development.

Web Servers in Rust: High-Performance, Asynchronous, and Scalable

In 2024, Rust maintained its reputation as one of the best languages for building high-performance, reliable, and secure web servers, with libraries and frameworks tailored to both small-scale microservices and large, distributed backend systems. The ecosystem thrived with a diverse range of web servers, ORMs, and async runtimes, with Actix Web and Axum standing out as the top choices for most developers.

Actix Web and Axum: The Titans of Rust Web Development

Actix Web and Axum, both built on the Tokio async runtime, dominated the Rust web server landscape. These two frameworks combine asynchronous execution, low-latency handling, and high scalability, making them suitable for everything from simple APIs to massive distributed systems.

• Actix Web is known for its exceptional speed and high throughput, consistently ranking as one of the fastest web frameworks in benchmarks.
• Axum shines with its deep integration into the Tower ecosystem, offering middleware compatibility and a clean, modular design.

Both frameworks benefit from Rust's strong typing and safety guarantees, significantly reducing the risk of runtime errors and undefined behavior in production systems.

Tokio: The Async Runtime Powering Rust Web Servers

At the heart of these web frameworks lies Tokio, Rust's flagship asynchronous runtime. Tokio's efficient task scheduling and concurrency model make it an ideal foundation for handling network-bound workloads, such as HTTP servers, database connections, and background tasks.

ORMs and Database Abstractions: Diesel and SeaORM

Backend web servers in Rust often pair with robust ORMs for database interaction:

• Diesel: A strongly-typed SQL query builder and ORM, emphasizing compile-time safety and performance.
• SeaORM: A modern async ORM built specifically for Rust's asynchronous ecosystem, integrating smoothly with Axum and Actix Web.

Other Notable Rust Web Servers

While Actix and Axum lead the pack, several other web frameworks continue to serve specific niches:

• Rocket: Known for its easy-to-use API and type-safe routing.
• Warp: A Tokion-based web framework emphasizing filter-based routing.
• Salvo: A newer framework built on Tokio and hyper, designed for scalability and flexibility.
• Poem: An elegant and expressive framework built on Tokio and Tower.

Tower Ecosystem: The Glue Behind Axum and Beyond

One of the reasons Axum excels is its seamless integration with the Tower ecosystem, a set of composable middleware and utilities designed for asynchronous Rust services. Tower provides reusable middleware components for:

• Authentication and authorization
• Request/response logging
• Load balancing
• Timeout management

Why Actix and Axum Are Leading the Pack

While frameworks like Rocket, Warp, and Salvo serve their respective audiences well, Actix Web and Axum continue to dominate because they offer:

1. Tokio Runtime Integration
2. Tower Middleware Compatibility
3. Performance Leadership
4. Scalability
5. Community and Ecosystem Support

Key Talks and Conferences

RustConf 2024

The biggest Rust conference this year, RustConf, covered advanced topics, community updates, and real-world Rust applications. Many talks focused on using Rust in performance-critical areas like web servers and scientific computing. (Most talks are not yet publicly available.)

Other Regional Rust Meetups and Conferences

Various regional and online Rust conferences and meetups took place in 2024, bringing developers together to share new projects, best practices, and common challenges. One highlight was Rust Nation UK.

Keynote Highlights

Speakers across different events stressed the importance of community collaboration, Rust’s ability to build reliable systems, and the exciting possibilities for future innovations in the Rust ecosystem.

Important GitHub Repositories & Tooling Updates

Cargo Enhancements

In 2024, the Rust package manager, cargo, gained new features to improve package management, dependency resolution, and build processes. These updates help make Rust development smoother and more efficient.

rust-analyzer

The popular language server, rust-analyzer, saw steady progress in its code completion, error diagnostics, and refactoring features. This tool continues to be a top choice for Rust developers who want powerful editing support.

tracing Library

The tracing library for structured logging and telemetry is becoming more vital as Rust applications grow in complexity. With new integrations and features, tracing offers deeper insights into performance and behavior, helping developers build more reliable systems.

Community and Outreach

Widespread Adoption

In 2024, Rust continued to gain traction in a wide range of industries. Its reputation for speed, memory safety, and strong concurrency features has led more companies to use and invest in Rust.

Inclusivity and Growth

The Rust community kept growing and stayed focused on creating a welcoming environment for everyone. Mentoring programs and other supportive resources have made it easier for new developers to learn and contribute.

Books and Tutorials

This year, there was a big increase in the number of books and tutorials about Rust. Both beginners and experienced developers now have more resources than ever to master the language.

Community and Industry Support

The Rust Foundation played a pivotal role in supporting the ecosystem.

• Google renewed its commitment with an additional $1M funding boost.
• The Rust Foundation Fellowship Program launched initiatives to nurture new contributors and empower community leaders.
• The Bevy Foundation was established to provide long-term governance for the Bevy game engine.

Looking Forward

In 2024, Rust made huge strides, with major progress across the language, tools, and ecosystem. As we head into the future, it’s clear that Rust will play an even bigger role in software development for many areas. Thanks to its focus on safety, performance, and a strong developer experience, Rust is likely to stay a key language that drives new ideas and widespread adoption.