mirror of
https://github.com/kamranahmedse/developer-roadmap.git
synced 2026-03-12 17:51:53 +08:00
Update rust roadmap content
This commit is contained in:
Kamran Ahmed
@@ -1,3 +1,3 @@
|
||||
# Criterion.rs
|
||||
|
||||
`Criterion.rs` is a statistics-driven micro-benchmarking library in Rust programming language. It provides you with a reliable way to analyze your code's performance over time with statistical methods. The library provides you with zero-cost setup. It delivers detailed, actionable feedback to help you understand what caused performance improvements or regressions. Additionally, it provides automatic outlier detection and can compare the performance of several algorithms or different versions of the same algorithm.
|
||||
`Criterion.rs` is a statistics-driven microbenchmarking library for Rust that provides reliable performance analysis over time. It offers detailed feedback, automatic outlier detection, and statistical methods to compare algorithm performance and track regressions with actionable insights.
|
||||
@@ -1,3 +1,3 @@
|
||||
# embedded-hal
|
||||
|
||||
"Embedded-hal" or "Embedded Hardware Abstraction Layer" is a notably robust and highly accommodating platform for the Rust embedded systems domain. It essentially allows for the creation of portable embedded drivers by providing generic device traits. These traits enable users to write hardware-agnostic code, which translates to enhanced efficiency and code reuse. By abstracting hardware specifics into a uniform API, "embedded hal" facilitates unified handling of different hardware abilities such as digital I/O, UART, I2C, and SPI communication, among others. This categorically makes it an invaluable tool in the Rust embedded space.
|
||||
`embedded-hal` (Hardware Abstraction Layer) provides generic traits for creating portable embedded drivers in Rust. Enables hardware-agnostic code by abstracting digital I/O, UART, I2C, SPI, and other communication protocols into a uniform API, promoting code reuse across different hardware platforms.
|
||||
@@ -1,3 +1,3 @@
|
||||
# fyrox
|
||||
|
||||
"Fyrox" is a modern, lightweight, highly optimized and fast 3D game engine specifically designed for Rust. Leveraging the safety and concurrency inherent in Rust lang, it offers a high level of performance and reliability in game development. Its lower level of abstraction allows more direct control over the hardware, making it more suitable for performance-critical parts of a game. These aspects combined with a robust feature set, such as support for common 3D formats and advanced lighting and shadowing techniques, make Fyrox an ideal choice for developing games in Rust.
|
||||
Fyrox is a modern, highly optimized 3D game engine designed specifically for Rust. Leverages Rust's safety and concurrency for high performance and reliability. Features advanced lighting, shadowing, support for common 3D formats, and low-level hardware control for performance-critical applications.
|
||||
@@ -1,3 +1,3 @@
|
||||
# ggez
|
||||
|
||||
`ggez` is a lightweight game framework for making 2D games using Rust programming language. It provides various facilities to make game development easier, such as drawing graphics, handling user input, manipulating audio, and handling game timing. It is inspired by libraries like Love2D and aims to present an easy and Rusty interface to the underlying Web platform. With `ggez`, developers can focus more on their game logic without worrying too much about the behind-the-scenes details.
|
||||
`ggez` is a lightweight 2D game framework for Rust inspired by Love2D. Provides facilities for graphics rendering, input handling, audio manipulation, and game timing with an easy, Rusty interface. Enables developers to focus on game logic without worrying about low-level implementation details.
|
||||
@@ -1,3 +1,3 @@
|
||||
# gtk-rs
|
||||
|
||||
`gtk-rs` is a group of Rust bindings for GTK+ 3 and other related libraries. This means you can write your GUI applications in Rust language with GTK+3, a cross-platform widget toolkit for creating graphical user interfaces. It includes bindings for GObject, Glib, and Cairo among others. Meanwhile, the number of bindings for different GTK libraries and components is continuously increasing. It's worth noting that gtk-rs projects are a set of open-source libraries dedicated to providing a Rust-friendly interface for GTK libraries (gtk, gdk, gdk-pixbuf, cairo, pango, etc). This allows developers to create software using Rust and GTK simultaneously.
|
||||
`gtk-rs` provides Rust bindings for GTK+3 and related libraries (GObject, Glib, Cairo, Pango) enabling cross-platform GUI application development. These open-source libraries offer a Rust-friendly interface for GTK components, allowing developers to create graphical applications using Rust with native GTK functionality.
|
||||
@@ -1,6 +1,6 @@
|
||||
# json-rust
|
||||
|
||||
`JSON` (JavaScript Object Notation) is a lightweight data-interchange format that is used to store and exchange data. In `Rust`, you can work with `JSON` data using the `serde` and `serde_json` libraries. The `serde` library provides a way for high-performance serialization, and `serde_json` is a `serde` format for handling `JSON` data. The library provides mechanisms for converting between `Rust` data structures and `JSON`. This includes the ability to parse `JSON` data from strings or files, serialize `Rust` data structures to `JSON`, and manipulate `JSON` values directly.
|
||||
JSON handling in Rust primarily uses `serde` and `serde_json` libraries for high-performance serialization/deserialization. These provide seamless conversion between Rust data structures and JSON, with parsing from strings/files, serialization to JSON, and direct manipulation of JSON values.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
# macroquad
|
||||
|
||||
Macroquad is a Rust library that offers a festive and straightforward way to prototype and develop games quickly. It is an ultra-efficient and flexible cross-platform game engine that specializes in 2D game development. Macroquad features a 2D rendering engine driven by the powerful metal-based miniquad, and includes support for inputs, random number generation, coroutine-based async programming, and sound. It is also portable across various platforms such as Windows, MacOS, Linux, WebAssembly, Android, and iOS.
|
||||
Macroquad is a simple, cross-platform 2D game engine for Rust focusing on rapid prototyping and development. Features efficient rendering via miniquad, input handling, coroutine-based async programming, and sound support. Portable across Windows, macOS, Linux, WebAssembly, Android, and iOS.
|
||||
@@ -1,6 +1,6 @@
|
||||
# Mocking and Property-based Testing
|
||||
|
||||
In Rust, **mocking** is a process that lets you create fake functions, objects, or behaviors to test different conditions and scenarios in your code. Rust does not natively support mocking, however, there are external libraries present to help you perform mocking. Some of the popular libraries for mocking in rust are `mockito`, `mockall`, and `mockall_double`. These libraries give you the ability to create mock structures with the same API as your original code and allow you to set predefined responses from functions or validate function calls, thus helping you test your rust code thoroughly.
|
||||
Mocking creates fake functions/objects for testing different scenarios. Rust uses external libraries like `mockito`, `mockall`, and `mockall_double` for mocking capabilities. Property-based testing generates test cases automatically to verify code behavior across a wide range of inputs.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
# nrf-hal
|
||||
|
||||
`nrf-hal` is a Rust Language Peripheral Access Crate for the Nordic Semiconductor nRF52 series and nRF91 series. It provides a high-level interface to the features and functionality available on these chips. It abstracts away the specifics of direct register access and allows for more robust and semantic interaction. It includes supports for GPIO, timers, RNG, RTC, TWIM+TWIS (I2C), SPIM+SPIS(SPI), temperature sensor and delay routines. It's an open-source project under the Apache license which means it's completely free to use and modify.
|
||||
`nrf-hal` is a Rust Peripheral Access Crate for Nordic Semiconductor nRF52 and nRF91 series chips. Provides high-level, semantic interfaces for GPIO, timers, RNG, RTC, I2C/SPI, temperature sensors, and delay routines. Open-source Apache licensed library abstracting direct register access.
|
||||
@@ -1,6 +1,6 @@
|
||||
# toml-rs
|
||||
# TOML Parsing
|
||||
|
||||
`toml-rs` is a library in Rust designed to parse and serialize TOML documents. TOML, which stands for Tom's Obvious, Minimal Language, is a straightforward and easy-to-read format often used for configuration files. The `toml-rs` library provides functionalities to convert between TOML documents and Rust structures. It heavily uses Rust's powerful trait system and type inference, to parse a TOML document into Rust's static types for further manipulation. Moreover, by making use of the 'serde' library, it enables automatic serialization and deserialization between TOML and Rust types.
|
||||
`toml-rs` parses and serializes TOML (Tom's Obvious, Minimal Language) configuration files in Rust. Uses serde for automatic serialization/deserialization between TOML and Rust types. Leverages Rust's trait system and type inference to convert TOML documents into statically-typed Rust structures.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# quinn
|
||||
|
||||
`Quinn` is a Rust networking library providing high-level access to the QUIC protocol. It is built on top of the `tokio` runtime and implements the QUIC transport protocol as specified by the IETF. It provides an async, futures-based API for working with QUIC connections and streams. It is designed to offer high performance with robustness and flexibility, supporting both client and server roles. The QUIC protocol itself is a multiplexed and secure transport protocol positioned as a modern alternative to TCP, offering better performance for many networking applications.
|
||||
`Quinn` is a high-performance QUIC protocol implementation for Rust built on Tokio. QUIC is a modern transport protocol offering better performance than TCP with multiplexing and security. Quinn provides async, futures-based API supporting both client and server roles for networking applications.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
# relm
|
||||
|
||||
`relm` is a declarative, event-driven framework for building GUIs in Rust. It is asynchronous and designed to handle complex user interfaces. `relm` uses `gtk-rs`, a wrapper for GTK+3, allowing for the creation of cross-platform GUI applications. Features in `relm` include Widget identification through name instead of Arc<Mutex<>>, asynchronicity framework using Futures, and seamless communication between widgets through the Model-View-Update architecture. The main focus of `relm` is to enable the creation of dynamic desktop applications with complex interactions, using the safe concurrency features of Rust.
|
||||
`relm` is a declarative, event-driven GUI framework for Rust built on `gtk-rs` and GTK+3. Uses Model-View-Update architecture with async Futures for complex UI interactions. Features widget identification by name, seamless inter-widget communication, and leverages Rust's safe concurrency for dynamic desktop applications.
|
||||
@@ -1,6 +1,6 @@
|
||||
# ring
|
||||
|
||||
`Ring` is a popular cryptography library in Rust providing a safe, fast and easy-to-use platform for handling a broad range of cryptographic operations. The library supports a variety of cryptographic primitives, including RSA, AES, SHA, and many others. `Ring` is focused on the implementation of TLS protocol and cryptographic algorithm fundamentals, hence it doesn't include functionalities like parsing or serialization. This library excels in eliminating many common pitfalls of crypto usage by asserting on compile-time and runtime checks. One key feature is its limitation to safe, reviewed cryptographic algorithms, which enables it to help prevent accidental usage of insecure ones.
|
||||
`ring` is a safe, fast cryptography library for Rust focused on TLS and core cryptographic primitives. It includes RSA, AES, SHA, and other algorithms with compile-time and runtime safety checks. Restricts usage to safe, reviewed algorithms to prevent common cryptographic pitfalls and insecure implementations.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
# rppal
|
||||
|
||||
`RPPAL` stands for Raspberry Pi Peripheral Access Library. It's a crate for Raspberry Pi that provides access to the GPIO, I2C, PWM, SPI, and UART peripherals. Developed in Rust, it also includes a comprehensive interrupt handling system, software-based PWM, and I2C/SPI buses. The library supports all models of Raspberry Pi that run a variant of Raspbian/Debian Stretch or newer. While it's primarily designed for the Raspberry Pi's official Linux-based Raspbian OS, parts of the library might work with other Linux distributions or operating systems on the Raspberry Pi.
|
||||
`RPPAL` (Raspberry Pi Peripheral Access Library) provides Rust access to Raspberry Pi GPIO, I2C, PWM, SPI, and UART peripherals. Features comprehensive interrupt handling, software-based PWM, and I2C/SPI buses. Supports all Raspberry Pi models running Raspbian/Debian Stretch or newer.
|
||||
@@ -1,6 +1,6 @@
|
||||
# rusqlite
|
||||
|
||||
`rusqlite` is a simple and ergonomic library for interacting with SQLite databases in Rust. It is designed to be uncomplicated and easy to fit into existing Rust software. With `rusqlite`, you can execute efficient high-level database operations with minimal SQL knowledge or effort. Built around the `sqlite3` C library, it offers a comprehensive API for executing queries and retrieving results. `rusqlite` also integrates seamlessly with the `serde` crate, allowing for easy, type-safe bidirectional mapping between SQL and Rust data structures.
|
||||
`rusqlite` is an ergonomic SQLite library for Rust built around the sqlite3 C library. It provides simple, efficient database operations with minimal SQL knowledge required. Features seamless `serde` integration for type-safe bidirectional mapping between SQL and Rust data structures.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
# rust-crypto
|
||||
|
||||
`Rust Crypto` is a set of cryptographic algorithms implemented in the Rust programming language. Users can utilize these algorithms for encryption, decryption, hashing, and digital signature applications, among others. Notable features in Rust Crypto include ciphers like AES and DES, hash functions like SHA and MD5, and digital signatures such as RSA. It is recognized for its speed and low memory usage, thus making it a suitable option for systems with limited resources.
|
||||
`rust-crypto` is a collection of cryptographic algorithms implemented in pure Rust including AES, DES ciphers, SHA, MD5 hash functions, and RSA digital signatures. Known for speed and low memory usage, making it suitable for resource-constrained systems requiring cryptographic functionality.
|
||||
@@ -1,3 +1,3 @@
|
||||
# rust-gdb
|
||||
|
||||
`Rust GDB` is a powerful tool used for debugging applications written in Rust programming language. It stands for the GNU Project debugger and has a wide range of features that are versatile for dealing with different tasks involved in debugging. With `Rust GDB`, you can carry out tasks such image inspection, trace execution, modify programs during runtime and break execution during specific conditions. It is usually used from the command line and supported on many Unix-like systems. It communicates directly with the processors and operating systems on a low level, making it a great tool for programmers looking to explore in-depth analysis of their Rust applications.
|
||||
`rust-gdb` is GDB (GNU Project debugger) enhanced for Rust debugging. It provides low-level debugging capabilities including breakpoints, execution tracing, runtime modification, and memory inspection. Designed for command-line debugging with deep system integration for comprehensive Rust application analysis.
|
||||
@@ -1,3 +1,3 @@
|
||||
# rust-lldb
|
||||
|
||||
`Rust LLDB` is a set of modifications made to the LLDB debugger by the Rust developers to enable it to understand Rust-specific data structures and concepts. It allows the developer to drill down into Rust-specific data structures in a meaningful way that the regular LLDB debugger wouldn't understand. Furthermore, `Rust LLDB` includes pretty-printers for many common Rust standard library types. It’s worth noting that Rust-enhanced LLDB doesn’t need to be installed separately, it comes bundled with the Rust compiler.
|
||||
`rust-lldb` is LLDB debugger enhanced with Rust-specific modifications for understanding Rust data structures and concepts. It includes pretty-printers for standard library types and comes bundled with the Rust compiler, providing better debugging experience for Rust applications.
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# smol
|
||||
|
||||
`smol` is a small, fast, and modern async runtime for Rust programming language. It is built on top of async-std and tokio. With very few lines of code, it allows users to perform tasks such as creating async functions, waiting on a future, creating a timer, among others. Although it is feature-rich, smol keeps its API minimal and clean, making it the go-to choice for many developers working with Rust. It supports async/.await natively and is highly efficient due to its superior scheduling capabilities.
|
||||
`smol` is a small, fast async runtime for Rust with minimal API and clean design. Built on async-std and Tokio, it supports async/await natively with efficient scheduling. Offers essential async functionality including timers, futures, and task management with superior performance in a lightweight package.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
# sodiumoxide
|
||||
|
||||
"Sodiumoxide" is a Rust binding to the networking and cryptography library, libsodium. It is designed to be easy to use and difficult to misuse. Sodiumoxide follows the design of NaCl for simplicity while allowing the performance benefits of libsodium. It provides cryptographic primitives in a safe, high-level, idiomatic Rust wrapper. It attempts to handle all possible errors, eliminating the possibility of a misuse, a significant advantage over using libsodium directly. Overall, sodiumoxide aims to make high-level cryptographic operations accessible without sacrificing safety or performance.
|
||||
`sodiumoxide` is a Rust binding to libsodium cryptography library, designed for easy use and misuse prevention. Provides safe, high-level, idiomatic Rust wrappers for cryptographic primitives with automatic error handling. Follows NaCl design principles for simplicity while offering libsodium performance benefits.
|
||||
@@ -1,3 +1,3 @@
|
||||
# structopt
|
||||
|
||||
`StructOpt` is a third-party library in Rust designed to parse command-line arguments by defining a struct. It brings together the capabilities of `clap` for command-line parsing with Rust's powerful type system. With `StructOpt`, you can define a struct for your command-line program where each field represents a flag, switch, option, or positional argument. This allows a highly declarative and expressive means of handling command-line inputs, including automatic help message generation, strongly-typed values, default values, validators, and more.
|
||||
`StructOpt` is a library for parsing command-line arguments by defining structs where fields represent flags, options, and arguments. Combines `clap`'s parsing power with Rust's type system for declarative CLI definition with automatic help generation, strong typing, and validation.
|
||||
@@ -1,3 +1,3 @@
|
||||
# termion
|
||||
|
||||
`Termion` is a pure Rust, bindless library for low-level handling, manipulating and reading information about terminals. This provides a full-featured solution for cross-terminal compatibility, allowing for features such as color support, input handling, and other terminal specific features. It's completely independent and does not require any third-party libraries or bindings in C, C++ or any other language. As such, `Termion` simplifies the process of writing cross-platform CLI applications or utilities in Rust, while maintaining a lean, zero-dependency codebase.
|
||||
`termion` is a pure Rust, zero-dependency library for low-level terminal manipulation and information handling. Provides cross-terminal compatibility with features like color support, input handling, and terminal-specific capabilities. Ideal for building cross-platform CLI applications without external bindings.
|
||||
@@ -1,3 +1,3 @@
|
||||
# wasm-bindgen
|
||||
|
||||
`wasm-bindgen` is a library and command line tool designed to facilitate high-level interactions between Rust and JavaScript. It provides a seamless way for the two languages to communicate with each other, permitting the call of JavaScript APIs directly from Rust and vice versa. `wasm-bindgen` achieves this by generating an interoperability layer that 'translates' between the semantics of JavaScript and Rust. It handles differences in memory representations and call semantics for complex data types, such as strings and objects, allowing developers to focus on implementing their applications without worrying about the low-level details.
|
||||
`wasm-bindgen` facilitates high-level interactions between Rust and JavaScript in WebAssembly. It generates bindings allowing seamless communication, JavaScript API calls from Rust, and vice versa. Handles memory representations and call semantics for complex data types like strings and objects.
|
||||
@@ -1,3 +1,3 @@
|
||||
# wasm-pack
|
||||
|
||||
`wasm-pack` is a command line tool aimed at assembling and packaging Rust crates that target WebAssembly. It helps to bridge the gap between WebAssembly (written in Rust) and JavaScript. It generates necessary files for publishing a package to `npm`. `wasm-pack` also helps to make sure your rust code is set up correctly to get compiled to `wasm`. The tool aims to seamlessly have packages that work out-of-the-box in most JavaScript environments. `wasm-pack` was designed with a focus on ergonomics, performance, and correctness so as to make a developer's life easier.
|
||||
`wasm-pack` is a command-line tool for assembling and packaging Rust crates targeting WebAssembly. It bridges Rust/WASM and JavaScript, generating necessary files for npm publishing. Ensures proper Rust-to-WASM compilation setup with focus on ergonomics, performance, and correctness.
|
||||
@@ -1,3 +1,3 @@
|
||||
# wasmer
|
||||
|
||||
Wasmer is a popular standalone WebAssembly (WASM) runtime that aims to run any WASM file on any platform swiftly. It's designed to be lightweight and simple to use. The project supports features of WASM like linear memory and tables, while also providing a friendly command line interface (CLI). It ships with a pluggable, modular system that allows for different compiling and runtime strategies. Wasmer can be integrated into different programming languages through its embedding API, which enables calling WASM functions directly as pure functions in the host language.
|
||||
Wasmer is a standalone WebAssembly runtime designed to run WASM files on any platform quickly and efficiently. Features a pluggable system with different compiling strategies, friendly CLI, and embedding APIs for calling WASM functions directly from various programming languages. Lightweight and modular.
|
||||
@@ -1,3 +1,3 @@
|
||||
# wgpu-rs
|
||||
|
||||
`wgpu-rs` is a Rust project designed to make graphics programming more accessible for the Rust language. It is a library that allows users to easily interact with the graphic hardware in their system in a safe and comfortable way. The library provides a high-level, idiomatic and convenient abstraction over wgpu-core while still allowing low-level direct control over the underlying API. Through this, it provides a unified way to access graphics and computing functionality across various backends including Vulkan, Metal, DirectX, and browser WebGPU.
|
||||
`wgpu-rs` provides safe, idiomatic Rust graphics programming by abstracting over wgpu-core. Offers high-level convenience with low-level control options. Provides unified access to graphics and compute functionality across Vulkan, Metal, DirectX, and WebGPU backends for cross-platform compatibility.
|
||||
|
||||
Reference in New Issue
Block a user