Tag: #rust

한국어English日本語中文

← All posts

• Open Source Worth Watching Right Now (5) Data and ML Pipelines

  A data pipeline is not something a single scheduler solves. Ingestion, transformation, orchestration, execution engines, the model lifecycle, and search stores have each become the territory of a different tool. This pos

  2026-08-12 · 5 min read #open-source#data-engineering#mlops#python#rust

• Open Source Worth Watching Right Now (2) Build Tools, Editors, CLIs, and Terminals

  Work that gets repeated dozens of times a day, such as installing packages, linting, and bundling, has been rewritten in native languages, and the waiting has come down from seconds to milliseconds. This post introduces

  2026-08-12 · 5 min read #open-source#developer-tools#cli#rust#performance

• Eleven Days of Bun's Zig-to-Rust Rewrite — What Actually Transfers from a Large AI Migration

  Follows Bun's 11-day move of 535,000 lines of Zig to Rust through the primary sources. From May 3 to May 14, 2026, it took up to 64 Claude instances, about 50 workflows, 6,502 commits, and roughly 165,000 dollars at API

  2026-07-31 · 13 min read #ai#bun#rust#migration#testing

• Servo Embedding Landed on crates.io While Verso Stalled — A 2026 Mid-Year Check on Webview Fragmentation

  Tauri keeps its binaries small by borrowing the OS webview (WebKitGTK, WKWebView, WebView2), and the price is webview fragmentation — rendering that differs subtly across platforms. Verso, a Servo-based webview that drew

  2026-07-17 · 12 min read #desktop#tauri#servo#webview#rust

• The Rust Standard Library Verification Campaign Found Zero Memory-Safety Bugs

  The results paper for the verify-rust-std campaign, led by AWS and the Rust Foundation, appeared in the 2026 NASA Formal Methods Symposium. The work — what the authors call 'the largest verification campaign ever reporte

  2026-07-16 · 25 min read #formal-methods#rust#verification#memory-safety#testing

• React Compiler Got Ported to Rust — What Merged, What Did Not, and That "10x" Number

  On June 9, 2026, PR 36173 — a Rust port of React Compiler — merged into facebook/react main. It added more than 120,000 lines across 461 files, and the number "3x faster as a Babel plugin, about 10x faster in the transfo

  2026-07-16 · 19 min read #react#rust#compiler#performance#frontend

• Rust 1.97 Cut Off Pre-Volta GPUs — Inside the nvptx64 Baseline Bump

  Rust 1.97 (July 9, 2026) raised the minimum requirements for the nvptx64-nvidia-cuda target to PTX ISA 7.0 (CUDA 11 driver or newer) and SM 7.0 (Volta or newer). Maxwell- and Pascal-generation GPUs, and CUDA 10 and older

  2026-07-16 · 13 min read #rust#cuda#gpu#compiler#nvidia

• Ferrocene's Certified core — The Compiler Is ASIL D, So Why Does the Library Stop at ASIL B?

  The claim that Ferrocene's Rust compiler is 'ASIL D certified' is true, but the conclusion people usually draw from it is not. Ferrocene qualified the compiler as an ISO 26262 ASIL D / TCL 3 tool, which means 'you may de

  2026-07-16 · 23 min read #embedded#rust#ferrocene#safety#systems

• pgrust: Postgres Rewritten in Rust, Passing 100% of the Regression Tests — What That Actually Means

  Malcolm Matis (malisper) released pgrust, a rewrite of Postgres in Rust. It targets Postgres 18.3 compatibility, passes more than 46,000 regression queries, and boots from an existing 18.3 data directory. This piece is a

  2026-07-11 · 6 min read #postgresql#rust#pgrust#database#regression-tests

• Rust 1.97.0 Dropped — and I Was Already Building With That Exact cargo

  Rust 1.97.0 shipped to stable on July 9, 2026. This post reads the three things that actually changed in the release notes — v0 symbol mangling promoted to stable, Cargo being able to deny warnings, and linker output no

  2026-07-11 · 5 min read #rust#rust-1.97#release-notes#cargo#kube-rs

• Building a Kubernetes GPU Operator in Rust — Diagnosing a Real Cluster with kube-rs

  Against a production 8-node homelab cluster (k8s v1.32.5), I used kube-rs to build and run a GPU operator in Rust myself. I defined a GpuInventory custom resource and launched two controllers (node scan → record CR statu

  2026-07-11 · 6 min read #rust#kubernetes#operator#gpu#kube-rs

• Rust Ownership, Borrowing, and Lifetimes

  How Rust guarantees memory safety with no garbage collector, through its three core ideas — ownership, borrowing, and lifetimes. Move semantics, the borrow checker's "shared XOR mutable" rule, why lifetimes exist, how to

  2026-07-03 · 14 min read #rust#ownership#systems

• Rust Enums, Pattern Matching, and Error Handling

  Rust has no null and no exceptions. Instead it has the Option and Result enums, and pattern matching to take them apart safely. Enums and algebraic data types, exhaustive match, if let and let else, propagating errors wi

  2026-07-02 · 12 min read #rust#error-handling#pattern-matching

• Rust Traits, Generics, and Trait Objects

  Traits are Rust's interfaces, and then some. The difference between traits and interfaces, generic trait bounds, the trade-off between static dispatch and dyn trait objects (dynamic dispatch), associated types, blanket i

  2026-07-01 · 11 min read #rust#traits#generics

• Rust Smart Pointers: Box, Rc, Arc, RefCell & Interior Mutability

  Smart pointers unlock the cases Rust ownership alone struggles to express. Put values on the heap with Box, share ownership with Rc and its thread-safe cousin Arc, move the borrow rules from compile time to run time with

  2026-06-30 · 11 min read #rust#memory#systems

• Async Rust: async/await and the Tokio Runtime

  Async in Rust has a different flavor from other languages. A Future is just a lazy state machine, and without an executor to poll it, nothing happens. What a Future really is, what .await means, the executor/runtime (Tok

  2026-06-29 · 11 min read #rust#async#tokio

• Building Web APIs in Rust: Axum and Actix

  A practical guide to building web backends in Rust. Axum's handlers, extractors, routing, and shared state; tower middleware; JSON with serde; database access with sqlx; robust error handling; and a comparison with the o

  2026-06-28 · 10 min read #rust#web#axum#backend

• Building CLIs in Rust: clap and the Secrets of ripgrep, fd, bat

  Over the past few years the command line has been quietly rewritten in Rust: ripgrep, fd, bat, eza, zoxide, bacon. This post explains why that renaissance happened and what you actually need to build a CLI yourself. We d

  2026-06-27 · 9 min read #rust#cli#tools

• Rust Macros: Declarative vs Procedural (derive)

  Rust macros are a metaprogramming tool that generates code at compile time. This post distinguishes pattern-based declarative macros (macrorules!) from procedural macros (derive, attribute, function-like) that receive co

  2026-06-26 · 10 min read #rust#macros#metaprogramming

• Building a Kubernetes Operator in Rust (kube-rs)

  A Kubernetes Operator is a controller that encodes operational knowledge as code. This post covers the Operator pattern (CRD + controller + reconcile loop) from first principles, then how to build a real operator with ku

  2026-06-25 · 12 min read #rust#kubernetes#operator#kube-rs