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.
Quickwit is a Rust‑based distributed search engine that enables sub‑second queries directly on cloud object storage, and its documentation details the architecture, core concepts, installation, data ingestion, log management, tracing, deployment options, configuration, and operational best practices.
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.
genai is a Rust library that unifies the APIs of major large language models, offering a lightweight, native solution with simple chat‑focused examples, demonstrated through a dual‑model Rust program, and outlines future expansions such as additional model support, multimodal capabilities, and performance optimizations.
Mako, an ultra-fast, production-grade frontend build tool written in Rust, launched open-source in June 2024, offers dramatic speed gains across various projects, detailed benchmarks, and easy onboarding via npm, while inviting community contributions and providing experimental SSU support for even faster development cycles.
This article reports that C++ has overtaken C to rank second in the latest TIOBE index, outlines the historical evolution of C++ across three phases, highlights the recent record climbs of Go and Rust, and notes the broader usage of these languages despite the presence of promotional material.
Learn how to create native Python extension modules using Rust, set up the required tools, write and build the Rust code, and run Python scripts from a Rust binary, enabling you to combine Rust's performance and safety with Python's flexibility.
The MoonWebTeam Frontend Tech Monthly curates the latest front‑end frameworks, performance optimization case studies, AI innovations, domain‑driven design insights, and practical best‑practice techniques, offering developers a comprehensive snapshot of cutting‑edge web development trends.
SlashData’s 26th Developer Nation survey, covering over 10,000 developers from 135 countries, shows JavaScript remains the most popular language, Python overtakes Java for second place, and emerging languages like Rust and Go experience rapid growth, while new developers face distinct adoption challenges.
This article introduces the five most popular Rust web frameworks—Actix Web, Rocket, Warp, Axum, and Poem—detailing their core features, typical use‑cases, and providing concise "hello world" code samples to help developers choose the right tool for their projects.
This article provides a comprehensive analysis of TiDB's PointGet operator, detailing its execution flow in the TiKV storage layer, including protobuf interfaces, read‑through lock handling, snapshot creation, MVCC logic, and the integration of the Titan plugin for large values.
This article compares Zed IDE and RustRover, highlighting their key features, pros and cons, and recommending suitable scenarios for each to help Rust developers select the most appropriate development environment.
Zed, a Rust‑based open‑source editor, promises developers higher speed, GPU acceleration, built‑in AI assistance, collaborative CRDT buffers, and seamless integration with tools like GitHub Copilot, positioning itself as a compelling alternative to VS Code and Sublime Text.
Learn how to create a simple, high‑performance Rust microservice using Actix‑web, Serde, and SQLite, covering environment setup, project structure, core code for CRUD operations, and testing commands, while highlighting Rust’s memory safety, speed, and low runtime overhead.
This guide shows how to use free AI translation tools—Immersive Translate and OpenAI Translator—together with the Higress cloud‑native AI‑proxy plugin, configuring Docker, model mappings, and custom dictionaries to efficiently translate computer‑science textbooks like Rust and Crafting Interpreters, while comparing machine and human translations.
This article introduces the Rust‑based Tauri framework for building cross‑platform desktop applications, explains its architecture of a web front‑end paired with a Rust back‑end, showcases sample code, and evaluates its strengths and weaknesses from a developer’s perspective.
This article explains how the size of a Rust‑based Android dynamic library, initially 495 KB, was dramatically reduced to 95 KB through compiler optimization levels, link‑time optimization, panic handling changes, stripping unused sections, and custom linker scripts, providing practical tips for mobile developers.
This article details how the author reduced the size of a Rust‑based Android JNI dynamic library from 495 KB to 95 KB by adjusting compiler optimization levels, enabling LTO, switching panic handling to abort, removing unused strings, applying panic_immediate_abort, and crafting a custom linker script, while providing code snippets and size comparison tables.
A high‑school student independently created the Rust‑written programming language Key Lang, showcasing features like reference‑free syntax, concise loops, enhanced match, and native memory handling, shared via B‑site video and GitHub, while the project sparked heated community debate over code quality and originality.
This article introduces how to use NAPI‑RS for developing, debugging, and publishing Node.js extensions in Rust, covering Rust’s growing role in frontend tooling, project setup with @napi‑rs/cli, exposing functions and objects to JavaScript, handling callbacks, asynchronous calls, and CI/CD build and release processes.
This article explains Rust’s owned `String` type, showing how to create strings, grow and modify them with various methods, and convert between `String` and `str` while highlighting ownership and borrowing concepts essential for safe memory management.
Zed, the Rust‑based collaborative code editor originally for macOS, was open‑sourced in January 2024 and within three months added Linux support by tackling GPUI framework issues, Wayland window handling, and distribution fragmentation, while planning future features like audio calls and drag‑and‑drop.
The article introduces oss_pipe, a Rust‑based file migration utility designed for large‑scale object storage transfers, compares it with existing Java and Go tools, highlights Rust’s memory safety and performance advantages, outlines its core features, and presents benchmark results demonstrating multi‑gigabit throughput and efficient resource usage.
This article explains how to use Cloudflare's open‑source Pingora Rust framework to implement a Kubernetes ingress gateway, covering objectives, architecture, code examples for an ingress watcher and router control, deployment steps, and custom configuration integration.
This article delves into Rust’s Vec type, explaining its internal structure—including pointer, length, and capacity—detailing essential methods such as push, pop, len, capacity, and iter, and provides practical code examples that illustrate creation, manipulation, iteration, and performance considerations.
Explore Rust arrays in depth—from declaration syntax and element access to iteration, mutable updates, built‑in methods, multidimensional structures, and a practical fixed‑size stack implementation—highlighting their performance‑focused design and safety guarantees for system programming.
Learn how to define, initialize, access, destructure, and apply Rust tuples—including function returns, pattern matching, and limitations—through clear explanations and code examples that illustrate their flexibility and best-use scenarios for safer, more efficient Rust programming.
This comprehensive guide explores Rust’s signed and unsigned integer types, detailing their ranges, appropriate use cases, performance considerations, and provides practical code examples for type selection, conversions, arithmetic, and bitwise operations to help developers write efficient, safe Rust code.
The article uses Rust benchmarks to show how cache layout, prefetching, associativity, false sharing, pipeline stalls, and loop data dependencies impact performance, and demonstrates practical optimizations such as row‑major traversal, proper alignment, avoiding dependent loops, and leveraging sequential access to achieve near‑optimal speed.
While Rust’s safety and performance promise significant productivity gains over C++ for low‑latency trading systems, steep learning curves, scarce talent, and lower salaries hinder its adoption in finance, with industry leaders noting both its advantages and the challenges of transitioning legacy codebases.
This tutorial demonstrates how to train a MNIST digit‑recognition model using the Rust‑based Burn framework on top of the cross‑platform wgpu API, covering model export from PyTorch to ONNX, code generation, data loading, training loops, and performance comparison across CPU, GPU, and other backends.
This guide explains what a Rust REPL is, how to install the evcxr_repl tool using Rustup and Cargo, and demonstrates running the REPL, experimenting with variable declarations, external crates, data types, and error handling, while noting its limitations for larger projects.
Rust, a modern systems programming language, offers memory safety without a garbage collector, a powerful ownership model, zero‑cost abstractions, robust error handling, and safe concurrency primitives, making it ideal for high‑performance, reliable software development, as demonstrated through detailed examples and explanations.
The article shows how row‑major vs column‑major traversal, random access, cache‑set conflicts, false sharing, branch‑prediction failures, and loop‑carried data dependencies each degrade performance by tying Rust (and C++) code patterns to CPU cache behavior, prefetching, pipeline stalls, and vectorization limits, demonstrated through runnable benchmarks.
Elon Musk’s AI startup xAI has open‑sourced its 314‑billion‑parameter Grok‑1 model, detailing its Rust‑based, JAX‑powered architecture, extensive parameter count, training data limits, licensing terms, hardware requirements, and community reactions, offering developers unprecedented access to a competitive large‑language‑model framework.
Cloudflare has open‑sourced Pingora, a Rust‑based asynchronous multi‑threaded framework for building high‑performance HTTP/1, HTTP/2, gRPC and websocket proxies, highlighting its key features, massive traffic handling, zero‑downtime reloads, observability integrations, and the motivations behind replacing Nginx with Rust.
r-nacos is a Rust‑based Nacos server that offers the same client‑SDK compatibility as the official Java version while delivering dramatically faster startup, minimal memory footprint, higher performance, and stable operation, making it ideal for development, testing, and lightweight production environments.
This article examines how Xline performs safe cluster membership changes, comparing Joint Consensus and single‑step approaches, and provides a detailed source‑code walkthrough of leader and follower handling, configuration commits, node addition, removal, and the integration with the Curp protocol.
Microsoft confirms its continued commitment to C# while actively recruiting Rust architects to rewrite core cloud services, highlighting Rust's performance and memory‑safety benefits, industry demand, budget considerations, and the broader trend of major tech firms investing in Rust.
This article provides a balanced comparison of Rust and Go, examining their shared strengths such as memory safety and compiled binaries, while detailing key differences in performance, simplicity, feature richness, concurrency, safety, and scalability to help developers choose the right language for their needs.
Ubuntu kernel engineer Andrea Righi created scx_rustland, a Rust‑written Linux scheduler that runs in user space and can be hot‑plugged at runtime via eBPF, showcasing the flexibility, safety, and potential for micro‑kernel designs while allowing workload‑specific optimizations.
The White House’s ONCD report urges developers to replace C and C++ with memory‑safe languages like Rust, Go, and Java, citing alarming vulnerability statistics and a strategic shift that moves software‑security responsibility from individuals to large organizations and the federal government.
The 2023 Rust Survey shows modest growth in Rust usage worldwide, highlights China's 6% developer share, details tool preferences, uncovers concerns over complexity and performance, and outlines the community's top priorities for language improvements and ecosystem support.
An Ubuntu kernel engineer built a Rust scheduler using eBPF, achieving twice the frame rate in a game while only modestly increasing compile time, sparking debate on Rust versus C for kernel components and the future of dynamic, BPF‑driven scheduling in Linux.
This article describes how a frontend developer built a lightweight Tauri desktop application in Rust to automatically watch and complete video‑learning courses, covering the problem background, technology selection, requirement analysis, Rust basics, Tauri project setup, frontend‑backend communication, screen‑color detection, mouse automation, permission configuration, CI/CD build, and final reflections.
This article compares Electron and the newer Tauri framework, highlighting Electron's large binary size and Tauri's Rust‑backed, lightweight approach that lets web developers build native desktop applications with familiar JavaScript, HTML, and CSS.
This article explains the sidecar concept, compares it with SDK approaches, and provides detailed Kubernetes examples—including a log‑collection sidecar, a request‑forwarding sidecar, and an HTTP‑intercepting sidecar—complete with YAML manifests and Rust and Scala code to demonstrate implementation and deployment.
Google has pledged a $1 million grant to improve Rust and C++ interoperability, launching an Interop Initiative that aims to enhance ABI compatibility, tooling, and wrapper libraries while promoting Rust’s memory‑safety benefits across Android and other Google products.
Microsoft is accelerating the migration of its Windows core and Microsoft 365 services from C# to Rust, hiring senior architects to lead the Substrate platform team and promising massive performance and size gains for cloud‑scale systems.
