This article explains the concept of memory safety, details Rust’s unique ownership and borrowing mechanisms that enforce safety at compile time, compares them with the inherent risks of manual memory management in C and C++, and highlights why Rust is increasingly favored for secure system development.
This article details how the TikTok e‑commerce frontend team tackled high‑concurrency and multi‑instance challenges in their Electron‑based IM client by incrementally redesigning the architecture, introducing a Rust‑based SDK, validating performance through POCs, and ultimately achieving significant stability and latency improvements.
An extensive Rust developer roadmap breaks the learning journey into ten comprehensive sections—from introductory concepts and language basics to ownership, error handling, concurrency, modules, macros, traits, and the broader ecosystem—providing a structured guide for mastering Rust’s core features and libraries.
Switching from Java to Rust can shrink binaries from dozens of megabytes to a few kilobytes, cut memory use and latency dramatically, and provide safer, built‑in concurrency and async support, while Java remains attractive for its low learning curve and massive library ecosystem, prompting developers to wrap Rust crates for Java‑like productivity as they adopt Rust long‑term.
This article reviews the major developments in front‑end technology during 2023, covering the rise of large‑model AI applications, updates to JavaScript, TypeScript, CSS, the evolution of major frameworks like React, Vue, Svelte and Angular, the emergence of new tools such as Qwik, Htmx, Bun, Rust‑based build tools, low‑code engines, cross‑platform advances with HarmonyOS, and provides outlooks for 2024.
The 2023 frontend review highlights TypeScript’s size and speed gains, ECMAScript 2023 features, evolving frameworks like React, Vue, Svelte, Angular and emerging Qwik, while Rust tooling, Bun, browser changes, AI‑driven low‑code, and WASM progress set the stage for 2024’s LLM‑powered, Rust‑centric, cross‑platform development.
This article surveys recent frontend and AI developments, explaining R&D efficiency, showcasing a Rust-powered frontend scaffolding tool, outlining six basic AI agent types for enterprise use, defining AIGC, and presenting practical CSS color‑adaptation and Antd style‑override techniques.
This article benchmarks several Rust web frameworks—including Actix, Axum, Rocket, Tide, Gotham, Nickel, Ntex, and Poem—using a simple "Hello World" test on a MacBook Pro, measuring request throughput, resource usage, and implementation difficulty across different concurrency levels.
Discord’s rapid growth forced a series of massive database migrations—from MongoDB to Cassandra in 2017, then to ScyllaDB in 2023—detailing the motivations, requirements, data‑model design, performance challenges, migration tooling, and the resulting operational improvements.
Cloudflare's top architects explain why they replaced Nginx with the Rust‑based Pingora proxy, detailing architectural limits of Nginx, design decisions, performance gains, resource efficiency, and new capabilities that make Pingora faster, more efficient, and safer for massive internet traffic.
CStore is a Rust‑implemented native graph storage engine designed for large‑scale graph analysis, supporting petabyte‑level data, offering array‑plus‑linked‑list storage, multi‑level indexing, efficient compaction, and providing detailed build instructions and future roadmap for open‑source development.
This article explains how Cloudflare replaced NGINX with Pingora, a Rust‑written HTTP proxy that processes over a trillion daily requests, offering superior performance, efficiency, and security through a multithreaded design, custom HTTP library, and programmable request lifecycle.
This article compares Go and Rust across performance, concurrency, memory safety, development speed, and developer experience, highlighting each language's strengths and weaknesses to help developers decide which language best fits their specific project requirements in 2024.
A seasoned Java engineer shares his journey transitioning to Rust, highlighting Rust’s advantages for CLI tools, superior resource utilization, easier concurrency and async programming, while also acknowledging Java’s strengths in rapid feature delivery, mature ecosystem, and ease of learning, and discussing practical migration considerations.
At a recent open‑source summit in Japan, Linus Torvalds discussed the upcoming Linux 6.7 release, the growing role of Rust in the kernel, maintainer fatigue, and how artificial intelligence may assist developers while highlighting the social challenges of open‑source collaboration.
This article surveys various error and exception handling mechanisms in C, C++, Java, Go, Rust and other languages, comparing global error codes, return values, error stacks, and OS-level support, and evaluates their advantages and drawbacks for modern software development.
This article compares Rust and Go across performance, concurrency, memory safety, development speed, and developer experience, highlighting each language's strengths and weaknesses to help developers choose the most suitable language for their 2024 projects.
This article explains how to create, compile, and integrate a Rust‑based WebAssembly component for accelerating 3D model vertex merging in the browser, covering tool installation, code examples, data transfer techniques, performance tuning with hashing, and compatibility adjustments for both webpack and Vite.
The article explains how Cloudflare built the Rust‑based Pingora reverse proxy to overcome Nginx's architectural limits, achieve higher performance, better connection reuse, lower CPU/memory usage, and stronger safety, while supporting new features for its edge platform.
Tencent’s newly open‑sourced TQUIC, a high‑performance, lightweight, cross‑platform QUIC library written in Rust, offers fast transmission, high performance, extensive congestion‑control algorithms, multi‑path support, and strong security, and has already boosted core services such as video, advertising, gaming, and cloud CDN, demonstrating its broad scenario value and robust architecture.
Tencent has open‑sourced TQUIC, a Rust‑based, high‑performance, lightweight cross‑platform QUIC library that supports multiple congestion‑control algorithms, multi‑path networking, and memory‑safe operation, delivering 2‑30% faster transmission and up to 20% higher processing speed while improving latency‑sensitive services such as video, gaming, advertising, and e‑commerce.
The article summarizes recent releases across UI toolkits and core platforms, covering Slint 1.3's Android support, Flutter 3.16's Impeller preview, Rust 1.74's Cargo enhancements, Notion's AI‑driven Q&A feature, and multiple Linux kernel updates addressing security and bug fixes.
Looking back over ten years, the author revisits earlier blog posts and shares personal insights and judgments about the Go and Rust programming languages, concluding that choices often outweigh effort in shaping one’s technical path.
Cloudflare abandoned Nginx for its home‑grown Rust‑based proxy Pingora, detailing architectural limits of Nginx, design choices, multithreaded scheduling, connection‑reuse improvements, and how these changes deliver faster, more efficient, and safer traffic handling at massive scale.
Microsoft announced a series of initiatives—including tighter CodeQL‑GitHub Copilot integration, a $1 million donation to the Rust Foundation, and a $10 million investment in Rust tooling—to promote memory‑safe programming and accelerate AI‑driven automation, signaling a strategic shift toward more secure software development.
This article investigates whether WebAssembly truly outperforms JavaScript by compiling Rust to wasm and comparing execution times of Fibonacci and convex‑hull algorithms, revealing that data copying and serialization overhead can make wasm slower in realistic front‑end scenarios.
Vivo introduced BlueOS, a fully self‑developed operating system built with Rust and integrated AI large‑model capabilities, highlighting three core traits—greater intelligence, smoother performance, and enhanced security—while targeting smart‑watch devices and providing a dedicated SDK and IDE for developers.
The article chronicles the technical background, challenges, and design decisions behind building a Rust-powered web bundler, comparing it with existing tools like Webpack, Vite, Rollup, and esbuild, and outlines future directions for improving plugin APIs, AST reuse, and build performance.
On October 28 2023, the 18th China Linux Kernel Developers Conference gathered nearly 500 developers in Shenzhen, livestreamed to over 180,000 viewers, featured keynote talks on kernel scheduling, AI‑driven evolution, Rust integration, and cloud‑hardware co‑design, and offered sub‑forums on memory, virtualization, I/O, and eBPF, with all materials now publicly available.
WebAssembly (Wasm) is a fast, binary bytecode format that lets browsers execute near‑native code written in languages like C, C++ or Rust, offering superior performance for CPU‑intensive tasks such as games and data processing, and can be integrated into front‑end projects via fetch, instantiateStreaming, and toolchains like Emscripten or wasm‑pack.
The article explains how Cloudflare built Pingora, a Rust‑based, cloud‑native reverse proxy that surpasses NGINX in performance, efficiency, and safety by redesigning the worker model, improving connection reuse, and leveraging multithreading and Tokio, while also offering greater extensibility for future services.
This article explains how Cloudflare built Pingora, a Rust‑based HTTP proxy that outperforms NGINX in scalability, connection reuse, and security, detailing the architectural limits of NGINX, design decisions behind Pingora, and the measurable performance and efficiency gains achieved in production.
Cloudflare’s new Rust‑based Pingora proxy outperforms Nginx by improving connection reuse, cutting CPU and memory usage, and enhancing security, offering a faster, more efficient, and feature‑rich solution for handling trillions of HTTP requests across its global network.
This article compares Rust and Go across performance, language features, concurrency, memory safety, ecosystem, learning curve, and real‑world use cases to help backend developers choose the most suitable language for their projects.
Rspress 1.0, an open‑source static site generator from ByteDance’s Web Infra team, leverages the Rust‑based Rspack bundler and MDX support to deliver fast build times, customizable themes, internationalization, multi‑version docs, plugin extensibility, and built‑in features such as search, preview, and view‑transition animations.
Google reports that its ongoing migration of Android's native components from C++ to Rust has reduced memory‑related security bugs, with Rust now powering about 21% of new native code in Android 13 and being used to rewrite critical security modules such as the protected virtual machine firmware.
Hugging Face has released Candle, a Rust‑written machine‑learning framework aimed at serverless inference, offering lightweight binaries, GPU support, and performance gains over Python‑based PyTorch, while sparking debate over Rust’s learning curve and the future of AI deployment.
This guide walks through creating a Rust project that uses the Tonic library to implement gRPC streaming, covering project setup, protobuf definitions, server and client code, testing with grpcurl, and enabling the reflection API for service introspection.
Cloudflare replaced Nginx with Pingora, a Rust‑written reverse‑proxy service that delivers higher speed, better efficiency, and stronger security by redesigning the worker model, using multithreading, and optimizing connection reuse, resulting in significant CPU, memory, and latency savings across billions of requests.
fnm is a fast, Rust‑built, cross‑platform Node.js version manager that simplifies installing, switching, and uninstalling Node versions, with step‑by‑step instructions for WSL and Windows installations, usage commands, alias setup, and common operations, all illustrated with code snippets and screenshots.
OpenObserve is a Rust‑based, cloud‑native observability platform that offers log, metric, and trace collection with up to 140‑times lower storage costs than Elasticsearch, supports both single‑node and HA deployments, provides a built‑in UI, and includes detailed installation and query examples for Kubernetes environments.
Cloudflare replaced NGINX with Pingora, a Rust‑written reverse‑proxy service that processes over a trillion requests daily, offering higher throughput, better connection reuse, lower CPU/memory usage, and enhanced security, while also enabling new features such as HTTP/2 upstream and seamless integration with Cloudflare’s product suite.
CoUnit is an open‑source Rust‑based tool that uses local semantic search and LLMs to create a virtual team interface, enabling low‑cost, offline knowledge retrieval, API discovery, and cross‑team assistance for software development teams.
This article explains the origins and purpose of Linux's standard input (0), standard output (1), and standard error (2) file descriptors, shows how they are defined in Rust and Go, and illustrates their behavior in terminal emulators and SSH sessions with detailed diagrams.
Despite massive layoffs at major tech firms in 2023, the U.S. still has over 375,000 open R&D positions, while Julia climbs into the TIOBE Top 20 and a new Rust survey reveals soaring adoption, high daily usage, and growing confidence among professional developers.
This article demonstrates the problem of unordered file content when multiple Tokio tasks write concurrently in Rust, shows a sample program that exhibits the issue, and provides a solution using Tokio’s asynchronous Mutex to synchronize file access, ensuring ordered and complete writes.
The article examines the current obstacles to seamless, zero‑configuration WebAssembly deployment across environments, focusing on language support, the WASI layer, component models, and the evolving role of Rust, Go, Python and other languages in the ecosystem.
This article explains what WebAssembly is, why it is needed for high‑performance web applications, how it works internally, which languages can target it, typical use cases, and provides practical examples of loading and using WebAssembly modules in browsers and Node.js.
This article explores image processing techniques from basic filters to advanced OpenCV applications, demonstrating how WebAssembly enables high-performance image processing in web browsers.
Google’s internal survey of over a thousand Rust developers shows that, despite concerns about ownership and borrowing, most find Rust no harder to learn than other languages, quickly become productive, appreciate its safety and performance, yet cite slow compilation as the top challenge.
Linux 6.4 has been officially released, featuring the removal of SELinux runtime disabling, enhancements to F2FS and Btrfs filesystems, a batch of new Rust code, integration of Intel LAM after criticism, performance optimizations for LoongArch, early Apple M2 support, Wi‑Fi 7, and AMD autonomous boot, while the merge window for 6.5 is now open.
The article explores how Rust's memory‑safety and efficiency are driving major companies like Microsoft, Google, and Amazon to rewrite operating‑system components and cloud services, while also tracing Rust’s quirky origins, rapid rise in popularity, and the challenges it still faces.
Cedar is an open‑source, domain‑specific language from Amazon that lets developers define, analyze, and enforce access‑control policies outside application code, supporting RBAC and ABAC, with SDKs for Rust and Java and integration into Amazon Verified Permissions and AWS Verified Access.
The Rust project has introduced a new top‑level governance body, the Rust Leadership Council, replacing the core team with representatives from nine top‑level teams to address past governance issues and improve coordination across the community.
Zed, a Rust‑written collaborative code editor created by the original Atom author, offers superior startup speed and low memory usage compared with Electron‑based editors, and introduces an unconventional "open source Zed on Zed" plan that lets contributors use the editor itself to develop and improve the project.
In January 2023, Cloudflare surged to become the most popular web server, surpassing Apache and Nginx with a 21.64% market share, and is now replacing Nginx with its Rust‑based Pingora proxy, which handles over a trillion requests daily while using only a third of the resources of its predecessor.
This article compares three popular Rust web frameworks—actix-web, warp, and axum—by examining their versions, download counts, ecosystem metrics, performance considerations, and code examples for JSON handling, routing, middleware, and shared state, ultimately recommending the best fit for different project sizes.
The article introduces Mojo, a new programming language positioned as a superset of Python that offers Rust‑like speed and safety through ahead‑of‑time compilation, discusses its early‑stage features, performance claims, online playground, and evaluates its potential to complement or replace Python in data‑science and high‑performance scenarios.
The article explains how Rust’s strict type system and concepts such as type hints, dataclasses, algebraic data types, newtype, typestate patterns, and safer mutex designs can be adopted in Python to improve code robustness, readability, and maintainability.
Rye, created by Armin Ronacher, is an experimental Python package manager that introduces a workspace concept, standalone Python installations, and clear separation of development and production dependencies, offering a unified solution to the fragmentation of existing Python tooling while providing detailed installation and workflow instructions.
Microsoft has begun replacing parts of the Windows 11 kernel with Rust, adding around 36,000 lines of memory‑safe code that have passed boot tests, with the Win32k.sys driver now available in Insider builds, promising no performance loss and even speed gains over C++.
This article walks through using Rust and the AWS SDK to connect to object storage services, perform basic CRUD operations, and handle large file uploads and downloads efficiently with multipart techniques.
Microsoft is integrating Rust into the Windows kernel to replace legacy C++ code, aiming to eliminate whole classes of memory‑safety bugs, boost performance, and set a new standard for secure system‑level development.
This article introduces NAPI‑RS, a Rust‑based framework for creating pre‑compiled Node.js native extensions, covering project setup, multi‑platform distribution, type generation, module registration, advanced usage patterns, and debugging techniques to help developers efficiently bridge Rust and JavaScript.
WebAssembly has evolved to version 2.0, offering extensive instruction support, large memory handling, and vector operations, and is now widely used across web and non‑web scenarios; this article surveys popular languages (C/C++, Rust, Go, AssemblyScript, JavaScript, etc.) and key toolchains such as Emscripten, Binaryen, wasi‑sdk, TinyGo, wabt, wasm‑pack, and wasm‑bindgen.
This article explains why Tokio may discard asynchronous tasks when the thread pool is saturated and demonstrates how to use a bounded JoinSet to block task creation until resources become available, ensuring all tasks complete.
Rspack, a Rust‑written web bundler from ByteDance, is officially released as an open‑source project offering dramatically faster dev and build times, strong Webpack compatibility, flexible configuration, and a roadmap that includes richer loader support, advanced caching, plugin APIs, and quality‑assurance measures.
This article details the motivations, challenges, and outcomes of rewriting the KCL compiler from Python to Rust, highlighting significant performance gains, reduced bugs, memory savings, and the learning curve associated with adopting Rust for a large‑scale systems project.
Cloudflare engineers have rewritten a core Nginx module in Rust, creating the Pingora proxy to replace Nginx, improve performance and safety, and pave the way for a future backend infrastructure without Nginx, highlighting Rust’s security benefits for complex, high‑scale services.
This article examines how WebAssembly can accelerate canvas and WebGL animation engines by redesigning data structures, separating JS and WASM animation objects, optimizing the update cycle, handling mixed animations, and presenting benchmark results for thousands of animated nodes.
This article provides a comprehensive guide on Rust build scripts, the role of sys crates, foreign function interfaces, and cross‑compilation techniques, illustrating how to create and use NAPI‑sys and libsodium‑sys crates, manage Cargo instructions, and leverage tools like Zig for seamless multi‑platform builds.
This article explains why using both clickhouse-rs (TCP) and clickhouse.rs (HTTP) in a single Rust project causes a Cargo links conflict, demonstrates failed workspace isolation attempts, and shows how renaming the links field in the native library resolves the issue.
Recent Python ecosystem trends highlight the rise of Rust bindings via PyO3, the emergence of pure‑Python web UI frameworks like Streamlit and Pynecone, and growing emphasis on static type safety with tools such as mypy and pydantic, signaling a shift toward higher performance and reliability.
The article analyzes 2023 programming language trends, highlighting Python's continued dominance, the ongoing decline of PHP and Java, and Rust's rising popularity due to its safety and performance, while noting the broader industry perception and adoption patterns.
The fish command‑line shell, known for its user‑friendly features, is planning a gradual migration from C++ to Rust to reduce development pain, attract contributors, improve concurrency support, and keep the project modern, with a PR already demonstrating several components rewritten in Rust.
This article walks through setting up a Starwift cloud‑native data warehouse on JD Cloud, configuring network access, installing the ClickHouse client on macOS, and demonstrates both TCP and HTTP Rust integrations with example code, while noting common dependency conflicts.
This article introduces WebAssembly’s efficient, safe, open standards and LLVM‑based compilation pipeline, then guides Rust developers through installing tools, writing and binding simple functions, optimizing performance and bundle size, and explores tooling, runtimes, real‑world use cases, current limitations, and future extensions such as WASI, SIMD, and threads.
JetBrains’ 2022 State of Developer Ecosystem survey of over 38,000 developers shows JavaScript remains the most popular language, TypeScript’s usage has tripled, Rust tops the list of promising languages, and shifts in preferred OS, remote work, and developer satisfaction highlight evolving industry trends.
This technical digest surveys Tencent’s health‑code operations architecture, dissects ChatGPT’s training pipeline, contrasts Web 2.0 and Web 3.0 on Ethereum, explains AI‑generated art, details WeChat’s overload controls and QQ Music’s high‑availability design, examines the rapid scaling of the “Sheep Sheep” mini‑game, introduces Rust for front‑end developers, showcases big‑data football prediction models, and outlines common C++ pitfalls and best‑practice recommendations.
Google's Chrome security team announced that Chromium will soon support third‑party Rust libraries, aiming to simplify development, reduce memory‑safety bugs, and enhance overall browser security by integrating safer Rust code into Chrome binaries.
This article explores how Rust’s safety, performance, and WebAssembly integration make it a compelling option for modern frontend development, highlighting industry insights, real‑world use cases, and the language’s growing popularity among developers.
This article explores GaiaX's cross‑platform layout solution, detailing the performance tests that validated Flexbox, the advantages of the Rust‑based Stretch library, and the engineering fixes for iOS crashes, aspect‑ratio handling, and multithreading issues.
GaiaX, Alibaba Entertainment’s cross‑platform dynamic UI framework, adopts Flexbox implemented with the Rust‑based Stretch engine to deliver millisecond‑level layout latency on phones, tablets, OTT, Macs and IoT devices, while fixing iOS 32‑bit crashes, redefining aspect‑ratio logic, adding thread‑safe wrappers and extensive tests, and open‑sourcing the extended library.
Occlum v1.0, the open‑source trusted execution environment operating system released by Ant Group, delivers up to five‑fold performance improvements, supports over 150 Linux syscalls, introduces async I/O, dynamic memory management, and a Spark‑BigDL big‑data analysis solution, while outlining future GPU and TDX extensions.
Linux will start supporting the Rust programming language from kernel version 6.1, adding about 12,500 lines of code, with ongoing work from the Rust‑for‑Linux community, GCC’s Rust front‑end integration, and early driver examples demonstrating Rust’s potential in kernel development.
This guide introduces Nushell, a Rust‑written cross‑platform shell, explains its core goals, and provides step‑by‑step installation commands for Ubuntu/Debian, RHEL, macOS, Docker, and how to set it as the default user shell.
This article explains how to integrate Redis into a Rust backend by defining resource structs, wrapping the client with enums, implementing a connection pool using r2d2, creating a global singleton with once_cell, and providing example code for querying and storing data.
Google’s shift to Rust for Android development has dramatically cut memory‑safety bugs, dropping from 223 incidents in 2019 to 85 in 2022, and reducing the share of such vulnerabilities from 76% to 35%, highlighting Rust’s growing role in mobile security.
Wasmer 3.0 enables compiling WebAssembly modules into native executables for Windows, Linux, and macOS without any runtime dependencies, adds improved WASI support via a new Rust API, and offers cross‑platform performance and security benefits while sparking community debate over speed trade‑offs.
The article analyzes how the rapid evolution of front‑end technologies, Gartner's maturity curve, ThoughtWorks' radar, and the D2 conference’s topic‑selection process shape the 2023 language and framework landscape, highlighting emerging tools like Turbopack, Rust, and mature options such as Kotlin and Swift.
The November TIOBE index shows Rust climbing into the top four while Python, C, Java and C++ maintain growth, presents the full Top 20‑50 language list, details the 51‑100 entries, and includes historical and celebrity rankings to illustrate long‑term popularity trends.
This article provides a comprehensive technical analysis of GaiaX, Alibaba's cross‑platform high‑performance rendering engine, covering its core concepts, three‑layer architecture, rendering pipeline, node‑tree calculations, view‑hierarchy merging, text auto‑fit logic, and key open‑source resources.
The November TIOBE index reveals that Python, C, Java and C++ continue strong growth while Rust gains momentum, and provides detailed rankings from the top 10 to the top 100, offering insights for developers choosing languages and tracking industry popularity trends.
The November TIOBE ranking reveals Python, C, Java, and C++ maintaining top positions with steady growth, while Rust holding 20th place, and languages like Ruby, Swift, and Visual Basic declining, and Fortran falling out of the top 20, highlighting shifting trends in programming language popularity.
The article shows how to transform a single‑threaded Rust STUN server into a high‑performance, multi‑core service by using Linux’s SO_REUSEPORT to bind multiple threads, assigning each to a NIC queue, and employing batch syscalls recvmmsg/sendmmsg, achieving over a million packets per second with significantly lower CPU usage.
This article explains GaiaX, Alibaba's cross‑platform template engine, detailing its core concepts, DSL structure, three‑layer architecture, Rust‑based Stretch layout engine, rendering pipeline, and optimization techniques such as node‑tree calculation, view‑hierarchy merging, and text auto‑fit for Android and iOS.
The November 2022 TIOBE index shows Rust re‑entering the Top 20 with a record 0.70% share, highlights shifts among PHP, SQL, Scratch and other languages, and provides detailed rankings from the top 10 to the 100th position, offering insight into programming language popularity trends.
The article introduces TECC, a privacy‑computing framework that balances security and performance by using trusted execution environments, data secret‑sharing, lightweight cryptographic protocols, and Rust‑based implementation to enable near‑plaintext speed for secure multi‑party machine learning and data analysis.
The article examines Google’s Carbon language as a modern successor to C++, discussing its goals, design principles, interoperability with existing C++ code, and how it compares to other successor languages like Rust, Kotlin, and TypeScript.
This article explains why traditional CPU inference and naïve GPU usage are inefficient for recommendation workloads, introduces NVIDIA Multi‑Process Service (MPS) technology, describes VIVO's custom Rust‑based inference engine and deployment strategies, and presents performance and cost benefits along with practical deployment considerations.
