Cloudflare built Pingora, a Rust‑based HTTP proxy that processes over a trillion daily requests, delivering lower latency, higher connection‑reuse, and up to 70% CPU and memory savings compared to Nginx, while adding extensible features and stronger memory safety.
This article explains the fundamentals of WebAssembly, its advantages, how to install Rust, set up a Rust project, compile it to a .wasm module with wasm‑bindgen, and seamlessly integrate the resulting WebAssembly code into a Vue 3 frontend application using canvas drawing examples.
The article details how moving a high‑throughput observability compute layer from Java to Rust—leveraging Rust’s ownership, zero‑cost async, and static binary deployment—cut memory usage by roughly 68%, CPU consumption by 40%, while outlining monitoring setup, concurrency model, and the steep learning‑curve challenges.
This tutorial explains how a Kotlin backend can efficiently convert PDF pages to high-resolution PNG images by integrating the native PDFium library through a Rust-based JNI adapter, covering performance benefits, workflow steps, and complete code examples for building and invoking the native module.
Windmill is an open‑source platform that converts scripts into interactive user interfaces and orchestrated workflows, offering automatic UI generation, multi‑language support, high‑performance Rust backend, and secure sandboxing, and can be self‑hosted via Docker Compose or Kubernetes for rapid internal tool development.
This article surveys twenty of the most talked‑about open‑source projects released by early‑2024 startups, spanning AI assistants, developer tools, Python package managers, blockchain platforms, and more, each highlighted with its GitHub URL, star count, and a brief functional description.
Fish Shell, the user-friendly command-line shell for Linux and macOS, is undergoing a major rewrite from C++ to Rust, achieving a near‑complete Rust codebase, extensive contributor activity, and performance improvements while addressing legacy toolchain challenges and enhancing modern functionality.
Researchers from Inria and Microsoft have devised a method to automatically translate a subset of C code, called Mini‑C, into memory‑safe Rust, using the KaRaMeL compiler framework, demonstrating comparable performance on cryptographic libraries while reducing vulnerability risks.
This article explains how Rust's memory safety, concurrency guarantees, explicit error handling, and modern tooling make it a safer and more maintainable alternative to C for developing Linux kernel modules.
The Fish Shell project migrated its entire codebase from C++ to Rust over two years, detailing the motivations, challenges, mistakes, and benefits of the transition, and outlining the future work still pending for this open‑source shell.
Looking ahead to 2025, this article predicts that Rust will become mainstream in Linux kernel development, emerging tools like jj and uv will reshape version control and Python packaging, while trends such as SBOM, Fair Source licensing, and server‑side WebAssembly are expected to stall, underscoring the resilient yet selective evolution of open‑source software.
This article outlines a Rust programming book that starts with fundamental syntax, variables, and memory management, then progressively explores ownership, lifetimes, error handling, concurrency, async programming, traits, macros, and practical examples, providing code snippets and core concepts for each topic.
This article walks through a Rust‑based implementation of classic Unix command‑line utilities—hello world, echo, cat, head, uniq, wc, find, grep, comm, ls, and more—showing project setup, Cargo usage, argument parsing with clap, error handling with Result, testing strategies, and code snippets for each tool.
This article builds a practical hardware‑mind model by benchmarking Rust code to show how cache layout, prefetching, cache associativity, false sharing, pipeline stalls, and data dependencies affect the performance of row‑major versus column‑major traversals, random accesses, and multithreaded loops, and it offers concrete fixes such as cache‑line alignment.
Limbo, Turso’s Rust‑based rewrite of SQLite, aims for full compatibility while adding memory safety, asynchronous I/O via io_uring, deterministic simulation testing, and WebAssembly compilation, delivering comparable or superior performance on large datasets and showcasing the challenges and benefits of re‑engineering a mature database engine.
This article walks you through creating a Rust function to convert integers to Roman numerals, refining the code, and then turning it into a library and publishing it as a crate on crates.io, covering Cargo configuration, README creation, testing, documentation, and release steps.
This article evaluates the startup speed, memory consumption, and request‑handling throughput of a Spring Boot application built as a GraalVM native binary, a regular JAR, and equivalent services written in Go and Rust, highlighting the trade‑offs of AOT compilation for backend development.
This article demystifies the relationship between Node.js's N‑API and the underlying Application Binary Interface (ABI), explaining their definitions, comparing their abstraction levels, cross‑platform compatibility, memory management, and performance, and provides concrete Rust code examples for both raw ABI and N‑API implementations.
Postfix type declarations, as seen in modern languages such as Go and Rust, place the type after the variable name—a style the author links to cultural naming conventions, arguing it highlights identifiers and can enhance readability after compilation, a practice historically validated by Pascal and Delphi.
Explore Rust's powerful multithreading model, covering core concepts like ownership, channels, Mutex and Arc, with practical examples for web servers, game development, data processing, and scientific simulations, plus interactive quizzes to reinforce your understanding.
The article benchmarks a Spring Boot 3 service as a GraalVM native image, a traditional JAR, and Go and Rust versions, showing the native binary starts in under a second with ~70 MB memory and 7 k requests/s, the JAR needs seconds and 200 MB, while Go and Rust use 10 MB and 3 MB respectively with throughput, illustrating native images’ fast startup and lower runtime footprint despite longer compilation.
The article compares Go’s stackful, green‑thread model with Rust’s stackless, future‑based approach, explaining how each runtime schedules tasks, the memory overhead of goroutine stacks (2 KiB minimum in Go 1.22), the challenges of async‑await integration, and why Rust’s performance gains come with a fragmented ecosystem.
Mako is a Rust‑based web bundler that offers zero‑config, production‑grade speed, hot‑module replacement, code‑splitting and module concatenation, and its architecture—spanning entry, compiler, load, parse, transform, dependency analysis, module creation, and plugin orchestration—is detailed with benchmarks and code examples.
This article explains how to design and implement a high‑performance custom network protocol in Rust, covering zero‑copy parsing, memory‑mapped packet pools, lock‑free event loops, and an efficient binary packet format to achieve ultra‑low latency and massive concurrency.
The author, a seasoned TypeScript developer, explains why they chose Rust over C/C++, outlines effective learning resources, and compares Rust’s compiler, type system, and memory management to JavaScript/TypeScript, highlighting the language’s performance, safety, and practical benefits for low‑level development.
This guide explains how Rust’s ownership model, zero‑cost abstractions, async/await, and built‑in safety features enable teams to build high‑performance, reliable backend services at scale, while sharing practical code examples and lessons learned from real‑world production deployments.
By rewriting the “得物商家客服” client’s backend in Rust and swapping Electron’s Chromium renderer for Tauri’s native WebView, the team cut binary size by 91%, halved memory use, reduced CPU load, improved startup, and documented challenges such as WebView2 installation, notification callbacks, and limited Tauri documentation.
This article walks through implementing probability‑density‑function (PDF) based importance sampling in a Rust ray‑tracing renderer, covering trait definitions, concrete PDF types for spheres, cosine distributions, hittable objects, quad geometry, material adjustments, and integration into the rendering loop to achieve faster convergence and higher image quality.
During a gray‑release, a Go‑Rust service repeatedly crashed when a dependent process was hot‑upgraded; the root cause was an unhandled SIGPIPE signal generated by the kernel on a broken TCP connection, which terminated the process without a core dump, and the article explains the kernel mechanics and the solution of ignoring SIGPIPE.
This article explains how to expose a lightweight, dependency‑free client API for a Rust‑based database by defining a simple TCP‑based JSON serialization protocol, detailing non‑functional and functional requirements, the Message and Command structures, and providing a concrete Ping command implementation in Rust.
Ben Dicken benchmarked a double‑nested loop of 10 000 × 100 000 iterations across dozens of languages, publishing the source code and fastest‑run results that show C, Zig and Rust consistently topping the performance chart, illustrated with an animated speed comparison.
This article compares Python’s abstract base classes with Rust’s traits, showing how familiar Python concepts map to Rust syntax through detailed code examples, covering method binding, trait implementation, operator overloading, and testing, helping developers transition between the two languages.
gitui is a Rust‑written terminal interface for Git that offers keyboard‑driven control, context‑aware help, full Git feature support, high performance on large repositories, easy installation, and extensive customization, making it a powerful productivity tool for developers of all levels.
This article explains how the Linux SIGPIPE signal is generated during broken TCP connections, why the default kernel handling can terminate Go services that call Rust code via cgo, and provides practical code examples to ignore SIGPIPE and avoid silent process exits.
Cloudflare abandoned Nginx for its own Rust‑written Pingora proxy to overcome performance, scalability, and feature limitations, achieving higher throughput, lower CPU and memory usage, better connection reuse, and enhanced security while supporting non‑standard HTTP use cases and enabling faster feature development.
This article explains how REVM, a Rust‑based, modular Ethereum Virtual Machine implementation, enables developers to create custom EVMs—such as Optimism‑compatible chains—by leveraging the EvmWiring trait, zero‑cost abstractions, and extensible design without forking the core protocol.
This tutorial walks you through creating a simple yet efficient Gzip compression tool in Rust, covering project setup, dependency configuration, full source code, command‑line parsing with clap, file handling, compression using flate2, performance measurement, and execution instructions.
Hydration in Leptos involves rendering the initial HTML on the server and then, on the client via WebAssembly, attaching event listeners and state management to enable fast page loads, SEO benefits, and interactive features, with example SSR code illustrating the process.
This guide explains the fundamentals of thread pools, how task scheduling works, and provides a step‑by‑step tutorial for building a custom, efficient thread‑pool implementation in Rust, complete with code examples and an exercise to test concurrent task execution.
This mini Rust challenge walks you through implementing and decoding the classic Rail Fence Cipher, explaining the zig‑zag encoding process, demonstrating the ciphertext layout, and providing a complete Rust solution with code examples to help you practice reading and writing Rust code.
This article explains how the SIGPIPE signal is generated in Linux, why it can cause Go‑Rust services to crash without a core dump, and how to prevent it by configuring the signal handler to ignore SIGPIPE.
This article explains how the Huolala mobile team built a stable symbol demangling system using the open‑source symbolic‑demangle tool, covering the concepts of name mangling, why symbolic was chosen, step‑by‑step adaptation for newer Swift versions, Linux Python‑wheel building, and practical troubleshooting tips.
In a candid interview at the Linux Foundation Open Source Summit, Linus Torvalds and Verizon open‑source lead Dirk Hohndel discuss the Linux kernel's release cadence, security patching, the delayed integration of Rust, and Torvalds' cautious view of AI's role in software development.
The article examines the Safe C++ proposal—a collaborative effort by Sean Baxter and Christian Mazakas to add Rust‑inspired ownership and borrowing checks to C++ through a safe standard library—while discussing its 18‑month development timeline, toolchain extensions, community reactions, and broader implications for memory‑safe programming.
WebAssembly (Wasm) is a portable binary format that runs near native speed in browsers, providing sandboxed security and modular deployment, though its ecosystem is still maturing; it shines in compute‑intensive tasks like scientific computing, gaming, and porting native code, and can be integrated with Rust via wasm‑bindgen and wasm‑pack to create npm‑compatible modules that outperform JavaScript on larger workloads, while requiring higher development effort.
Zed, the Rust‑based open‑source editor, now offers preview‑stage SSH remote processing, allowing language servers, tasks, and terminals to run on a remote machine while the UI stays local, bringing fast native performance and collaborative editing features that challenge VS Code’s dominance.
r-nacos, a lightweight Rust‑based implementation of Nacos, offers identical registration and configuration features with dramatically lower memory usage, and this guide shows how to install it via Docker, integrate it into the mall‑swarm microservice e‑commerce project, and leverage its admin, data migration, and monitoring tools.
This article compares Rust’s primary error‑handling techniques—unwrap, unwrap_or_else, the ? operator, expect, and pattern matching—explaining their safety trade‑offs, appropriate use cases, and providing concise code examples to help developers choose the right approach for robust Rust applications.
This guide explains how to set up a Rust toolchain, compile Rust code to WebAssembly, use wasm‑bindgen and wasm‑pack, write the necessary Rust and JavaScript glue code, and run the resulting Wasm module in a web page with a Web Worker, providing a complete workflow for front‑end developers.
This guide walks you through the complete workflow of writing Rust code, compiling it to WebAssembly, and integrating the resulting module with JavaScript and HTML to create a browser‑based demo that checks whether a number is even, while covering setup, tooling, and best‑practice tips.
Gosub is a newly launched, Rust‑written open‑source browser engine that offers modular, high‑performance HTML5 and CSS3 parsing, a rendering engine, JavaScript bridge, and WebAssembly support, inviting contributors to help build a flexible alternative to dominant browsers.
The article announces the official release of Node.js 23 with its promotion to LTS status, highlights its new require() support for native ES modules, stable -run command, enhanced test runner, and the discontinuation of 32‑bit Windows support, while also covering Rust 1.82's launch and a comprehensive set of web accessibility guidelines.
Released by a consortium of Chinese research institutions, Asterinas (星绽) OS is an open‑source, Rust‑written operating system that introduces a novel framekernel architecture, aiming to deliver industrial‑grade security comparable to micro‑kernels while preserving the performance of traditional macro‑kernels for cloud and data‑center workloads.
On October 22, the open‑source Asterinas system software stack, featuring the Rust‑based Asterinas OS and confidential computing components, was announced by leading Chinese research labs and enterprises to provide a high‑performance, memory‑safe operating system and trusted execution environment for cloud, AI, and data‑centric workloads.
This article explores Rust's powerful closure and iterator concepts, detailing their syntax, environment capture types, usage with the move keyword, and how to create and chain iterators for lazy, efficient data processing, complemented by practical code examples and exercises to solidify understanding.
IEEE Spectrum’s 2024 programming language rankings show Python retaining the top spot for nine years, Rust climbing into the top‑10, C slipping, while emerging languages like Apex and Solidity debut, highlighting shifts driven by AI, security concerns, and industry hiring trends.
This article analyzes Meituan's Recce solution for dynamic front‑end containers, detailing performance bottlenecks, architectural classifications, interpreter and language choices, UI framework design, rendering layer decisions, optimization techniques, and future directions to achieve native‑level speed while retaining dynamic capabilities.
This article explains DataFusion, a Rust‑written, Arrow‑based query engine that offers high performance, extensibility, and seamless integration with various data sources, detailing its architecture, execution model, Rust advantages, and practical usage examples for building modern data‑warehouse solutions.
Amid rising memory‑safety concerns highlighted by Chrome’s vulnerabilities and high‑profile attacks, the C++ community proposes a Safe C++ Extension to add memory‑safety features, while experts compare it to Rust and discuss challenges, adoption pressures, and DARPA’s AI‑driven code‑conversion efforts.
This article explores Rust’s origins, its superior memory safety and concurrency, demonstrates how replacing JavaScript‑based Vite with Rust‑based Rsbuild can cut build times from minutes to seconds, and delves into Rust’s ownership, borrowing, lifetimes, error handling, and its growing role in frontend tooling and frameworks.
Tauri 2.0 is a lightweight, high‑performance framework that lets developers build cross‑platform desktop and mobile apps using familiar web technologies for the UI while leveraging Rust, Swift, and Kotlin for native backend logic, offering a safer and more resource‑efficient alternative to Electron.
While Python dominates data analysis and machine learning with its ease of use, Rust offers memory safety and near‑C performance; this article examines their respective strengths, the challenges of rewriting the Python interpreter in Rust, and how combining both can boost library speed and reliability.
Cloudflare replaced NGINX with its self‑developed Rust proxy Pingora, detailing why the legacy architecture fell short, the design decisions behind building a new internal proxy, and how Pingora delivers significantly higher performance, efficiency, and security for trillions of daily requests.
This article explains how to construct a Retrieval‑Augmented Generation pipeline in Rust, covering knowledge‑base creation with Qdrant, model loading and embedding using the candle library, data ingestion, and integration of a Rust‑based inference service based on mistral.rs, while also discussing resource usage and common pitfalls.
This article explains how to construct a Retrieval‑Augmented Generation pipeline in Rust, covering knowledge‑base creation with Qdrant, model loading and embedding generation using candle, and integrating a Rust‑based inference service to answer queries with up‑to‑date external data.
This step‑by‑step tutorial shows how to create a low‑latency Rust and Actix‑Web media server, configure Docker, stream MP4 videos, and build a simple front‑end, enabling full control over media hosting and easy extensions such as authentication, database integration, transcoding, and CDN acceleration.
This article examines the concept of weak pointers and weak references in Go, Rust, Java, and C#, comparing their implementations, explaining their memory‑management semantics, presenting concrete code examples, and discussing the upcoming Go weak‑pointer proposal and practical scenarios such as caching and event handling.
This article explains Rust's panic! macro, covering how to invoke it, its default behavior, options for stack unwinding versus aborting, practical code examples, and how to use backtraces for debugging, while advising when to prefer Result for recoverable errors.
At RustConf, Miguel Ojeda highlighted the challenges and optimism surrounding the Rust for Linux project, explaining how unstable Rust features, developer hesitancy, and industry interest shape the effort to make Rust a safe, second language for kernel development.
An in‑depth guide compares Go and Rust across memory management, learning curve, concurrency, ecosystem, performance, developer experience, and real‑world use cases, helping developers decide which language best fits cloud‑native services, system programming, web development, game development, or DevOps tools.
The article analyses the design of Rust’s Mutex API, compares it with the classic C/POSIX mutex API, explores alternative Rust designs that mimic C, and demonstrates through concrete code examples why Rust’s guard‑based approach preserves safety while a C‑style API would re‑introduce data‑race hazards.
Blaze is a Rust‑implemented, DataFusion‑based vectorized execution engine created by Kuaishou to accelerate Spark SQL queries, delivering up to 60% faster computation, 30% average compute‑power gains in production, and extensive architectural innovations such as native engine, protobuf protocol, JNI bridge, and Spark extension, while being open‑source and compatible with Spark 3.0‑3.5.
This article explains Rust's Clone‑On‑Write (COW) feature, showing how it reduces unnecessary memory allocations, detailing its internal enum variants, typical use cases, performance benefits, limitations, and providing practical code examples for function return values and string concatenation.
This article introduces Tonic, a Rust gRPC framework, explains its core features, components, and provides detailed, code‑rich instructions for building both server and client applications, while highlighting performance, security, and ideal use‑cases for microservices.
This article introduces DataFusion, a high‑performance, Rust‑based query engine that leverages Apache Arrow’s columnar memory format to enable fast, extensible data processing across multiple storage formats and cloud sources, explains its architecture, execution model, and provides practical Rust code examples for custom extensions.
This guide shows how to add the bitflags crate to a Rust project, define a Permissions flag struct using the bitflags! macro, and perform common operations such as checking, inserting, and removing flags, while explaining the automatically derived traits and useful helper methods.
This article explains the structure of IPv4 addresses, walks through a Rust function that parses dotted‑decimal notation into a 32‑bit integer with range checks, and provides example code demonstrating usage and error handling.
The lead maintainer of the Rust for Linux project resigned, citing fatigue from non‑technical disputes, reigniting heated community debates over Rust’s suitability for kernel development, including concerns about API stability, missing C feature support, cultural collaboration issues, and whether to rewrite the kernel in Rust or continue retrofitting.
Rspack 1.0, the Rust‑implemented next‑generation JavaScript bundler compatible with webpack APIs, launches with major performance gains, broader plugin compatibility, smaller bundle sizes, Module Federation 2.0 support, and a roadmap that includes faster HMR, portable caches, and deeper TypeScript integration.
This article walks through the challenges of offering both asynchronous and synchronous interfaces for a Rust API client, evaluates naive copy‑paste solutions, explores runtime‑based wrappers and the maybe_async procedural macro, and finally presents a clean, feature‑flagged design that avoids code duplication and compile‑time overhead.
Xilem is an experimental Rust native UI framework that combines concepts from Flutter, SwiftUI, and Elm, featuring lightweight view objects, diff‑based updates, strong typing, componentization, memoization, and optional type erasure, with a core built on xilem_core and Masonry crates.
PXP is a collection of tools and libraries that combine Rust and PHP to create a fast, reliable superset of PHP with modern language features, a language server, static analyzer, formatter and linter, aiming to improve the overall PHP developer experience.
The article details Rust’s recent governance overhaul, introducing a new Leadership Council that replaces the core team, outlines its responsibilities, lists its inaugural members, and discusses the broader implications of the community’s shift away from a centralized leadership model.
This article explains the WSGI/ASGI ecosystem, compares uWSGI, Nginx, and uvicorn, and then introduces Granian—a Rust‑written ASGI server that supports WSGI, ASGI, and RSGI, offering superior performance, HTTP/2‑3 support, and easy integration for Python web applications.
This article explores Rust's macro_rules! system, demonstrating how to create reusable, flexible configuration structures with default values, deprecation handling, and custom validation, while providing step‑by‑step code examples and highlighting the benefits for maintainability and code reuse.
Learn how to create a fast, modular HTTP load balancer using Rust’s Pingora framework, covering its core advantages, step‑by‑step project setup, code walkthrough, testing, and advanced features like health checks, service discovery, SSL offloading, and traffic control.
The article examines DARPA's TRACTOR project, which aims to use large‑language‑model AI to automatically translate legacy C and C++ code into safe Rust, discusses the memory‑safety motivations, technical challenges, community reactions, and the broader push by US agencies to abandon unsafe languages.
This article presents a detailed case study of Ctrip's large‑scale desktop IT management solution, describing the challenges of handling tens of thousands of office PCs, the full‑link architecture built with Rust, Tauri, SpringBoot and Django, automated health monitoring, fault detection, remediation workflows, security measures, performance optimizations, and the measurable operational improvements achieved.
After three years of building the Wick framework with Rust and WebAssembly, the author shares practical insights on Rust's strengths—such as its borrow checker, type system, and Clippy linting—and its drawbacks, including tooling gaps, async friction, and refactoring challenges, to help developers decide if Rust is worth the investment.
This article explains how the Rust cfg_if crate simplifies conditional compilation by providing a macro that replaces nested #[cfg] attributes with clear if‑else or match structures, shows step‑by‑step usage, advanced patterns, and compares cfg_if to raw #[cfg] for readability and maintainability.
This article demonstrates how to quickly build and benchmark a Spring Boot 2.x application as a native binary, compares its startup time, memory usage, and request throughput with equivalent implementations in Go and Rust, and concludes that AOT‑processed Java offers impressive performance despite longer compilation times.
Rust 1.80 introduces LazyCell and LazyLock, synchronized lazy-initialization primitives that differ from OnceCell and OnceLock in thread safety and built‑in initialization, and this article explains their characteristics, trade‑offs, and provides concrete code examples to help developers select the appropriate type for their use case.
The article presents a comprehensive case study of Ctrip's full‑chain desktop operations system, detailing its architecture, cross‑platform Rust/Tauri agents, SpringBoot server, security measures, operational challenges, performance optimizations, and the measurable improvements in fault detection and repair across a massive corporate PC fleet.
This article compares the emerging system language Rust with the veteran web language PHP, examining their core features, performance, safety, learning curves, ecosystems, and deployment considerations to help developers choose the right tool for their specific project needs.
This article compares Python, Go, and Rust, outlining each language's strengths, weaknesses, and ideal use cases, and includes practical factorial code examples to help developers choose the most suitable language for their specific project requirements.
Blaze is Kuaishou's self‑developed native execution engine that leverages Rust, DataFusion, and SIMD vectorization to accelerate Spark workloads, offering a 30%+ compute boost, detailed architectural components, deep production‑grade optimizations, and a roadmap for broader adoption.
Mako is a lightning‑fast, zero‑configuration web bundler whose Rust core and parallel Node.js pool handle loading, parsing, transforming, dependency analysis, and asset generation across JavaScript/TypeScript, CSS, assets, and more, while offering HMR, code‑splitting, plugin extensibility, and production‑grade reliability.
This article explains how to set up Rust for Android development, covering installation, creating a demo project, using JNI to call Rust functions, building the shared library, integrating it into an Android app, and designing a scalable architecture with event dispatch and Protobuf.
Learn how to build high‑performance, secure gRPC services in Rust using the Tonic framework, covering its core components, advantages, installation steps, project setup, protobuf definition, code generation, server implementation, and client creation with detailed code examples.
The latest Linux 6.10 merge introduces Rust language support for the RISC‑V architecture and expands Qualcomm Snapdragon X Elite features such as DisplayPort and eDP, while also noting a brief autumn recruitment reminder.
