Rust

via Matthias Endler (@mre@mastodon.social): Forgot to share this here: https://corrode.dev/blog/named-arguments-at-home/

Responding to Steve Klabnik’s post on named and optional arguments, Matthias Endler argues Rust already has most of what you’d want — without new language features. Argument structs, builders, and newtypes get you 80% of the ergonomics while keeping the names attached to types rather than to every function’s calling convention.

via El Perro Negro (@elperronegro@shmg.online): For 9 months I have been using RapidRaw as part of my RAW image workflow. So much so that Rawtherapee and Lightroom have fallen by the wayside.

RapidRAW is a non-destructive, GPU-accelerated RAW photo editor that ships in about 20 MB — smaller than many of the images it edits. Built with Rust and Tauri by a solo developer, it offers AI masking, presets, batch edits, and optional generative tools that can run locally, via your own ComfyUI server, or in the cloud.

Via RustTrending: A feature rich, native desktop, YouTube Music client. Tauri + Rust + SvelteKit, ad-free playback through libmpv, Last.fm scrobbling and Discord Rich Presence, no Electron.

via Sander (@bergmeister@mountains.social): This looks excellent for stabilizing those outdoor activities videos. Free and open source.

Gyroflow is an open-source, Rust-based video stabilization tool that uses gyroscope data recorded by action cameras, drones, and mirrorless cameras to smooth footage and level the horizon. It handles lens distortion and rolling shutter correction, supports GPU-accelerated realtime preview, and ships plugins for DaVinci Resolve and Adobe apps — impressive for a free, cross-platform project.

via Astra Underscore (@astra_underscore@wetdry.world): I feel like some of you Rust freaks might be into this:

Creusot is a tool that helps you formally prove your Rust code is correct. It uses deductive verification to let you write specifications as annotations in your Rust code and then verify them automatically, bringing the power of formal methods to everyday Rust development.

Looks like an open-source effort to build a git client with the Rust/Tauri stack.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Introduction to durable execution with Flawless and Rust

Flawless is a durable execution engine for Rust: workflows that run to completion even when the process is killed mid-flight. Instead of hand-rolling a state machine with resume rules and idempotence guarantees around every external API call, you write plain business logic and let the engine handle the replay. Currently in beta 3.

via Thomas (@wheezle@hachyderm.io): Been writing code in the sans-IO style for a while now and really enjoying it so I wrote up a blog post about it! #rustlang

Firezone’s Thomas Eizinger explains the sans-IO pattern: implementing network protocols as pure state machines that never touch a socket or call Instant::now themselves, leaving all IO and timing to the caller. The payoff is fast, exhaustive, deterministic tests and a way to sidestep the “function colouring” problem — async ends up confined to a thin outer layer instead of infecting the whole stack.

via yosh (is out of office) (@yosh@toot.yosh.is): New blog post: Ergonomic Self-Referential Types for Rust

Yosh Wuyts sketches what it would take to make self-referential types in Rust genuinely ergonomic: 'self lifetimes, in-place construction, an !Move marker in the type system, and safe phased initialization without the option-dance. It’s an early exploration rather than a finished design, but it’s a useful map of how several proposed features could combine to replace the awkwardness of Pin.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Htmd: A turndown.js inspired HTML-to-Markdown converter for Rust

htmd is a Rust crate for converting HTML to Markdown, modeled closely on turndown.js — it offers the same rich set of options and passes turndown’s test suite. Handy if you need reliable HTML-to-Markdown conversion in a Rust pipeline without shelling out to a JavaScript runtime.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Introducing emit: developer-first diagnostics for Rust applications

Ashley Mannix introduces emit, a diagnostics framework for Rust that’s been years in the making. Rather than following OpenTelemetry’s data model, everything is a single primitive — an event, described by a message template — from which logs, trace spans, and metric samples are all built. It still plugs into OTLP collectors, rolling files, or a pretty-printed console when you want them.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Building a dynamically-linked plugin system in Rust

Micah Wylde walks through how Arroyo, a real-time SQL engine, supports user-defined functions in a language that really wants to produce static binaries. He weighs scripting languages, out-of-process RPC, and Wasm before landing on dynamically-linked shared libraries with a C ABI, then digs into the details of designing safe FFI types and interfaces. A great read if you’ve ever wondered how to make a Rust program extensible at runtime.

via Axel Rauschmayer (@rauschma@fosstodon.org): Monolith lets you download a complete web page as a single HTML file—by inlining images etc.

Monolith is a Rust CLI tool that bundles an entire web page — CSS, images, JavaScript, fonts and all — into a single self-contained HTML file with no external dependencies. A handy way to archive pages that might not survive the next site redesign or link rot purge.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Blazingly Fast Linked Lists

Linked lists are usually an interview trivia question rather than a practical tool, but Dmitry Dygalo shows a case where they genuinely beat Vec: tracking the current location during JSON Schema validation so errors can point at the exact spot in the instance. The post walks through a series of optimizations drawn from real work on the jsonschema crate, measuring the impact of each step.

Eli Bendersky walks through why the “obvious” approach to parent pointers in a Rust tree fights the borrow checker, then works through the practical alternatives: Rc/Weak pairs, RefCell for interior mutability, and arena allocation with index-based links. A good reference for the moment you hit this wall in your own code.

via Rust Language (@rust@social.rust-lang.org): We got an email from the Serbian Registry of Internet Domain Names (RNIDS), the organisation that is responsible for the .rs top-level domain.

Looks like they are a big fan of Rust. 😊

Roman Kashitsyn lays out a set of goals for designing error types in Rust libraries: prefer specific enums over catch-all types, reserve panics for genuine bugs, lift input validation out of fallible calls, and embed rather than wrap underlying errors. The unifying theme is empathy — design the error type you’d want to handle as a caller.

via Kevin Stewart (@kstewart@hachyderm.io): Why is building a UI in Rust so hard? | Warp

The Warp team explains why Rust’s ownership model — great for systems code — fights against the shared, mutable, deeply-linked object graphs that traditional UI frameworks depend on. Their answer was to go functional: an immediate-mode, state-driven UI architecture that plays to Rust’s strengths instead of against them.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): arbtest — powerfully tiny property-based testing

arbtest is a property-based testing library for Rust with a refreshingly tiny API: one function, no macros. It takes an arbitrary::Unstructured random data source, shrinks failures automatically, and prints a seed you can use to deterministically replay any failure — plus it supports time budgeting and works with fuzzers.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Wrote a blog (and benchmark) different type of builder patterns in rust

A small benchmark repo comparing different ways to implement the builder pattern in Rust — owned self, &mut self, typestate, and friends. Handy data if you’ve ever wondered whether your builder’s ergonomics come at a runtime cost.

The Rust project’s 2023 annual survey results are in, drawing on responses from tens of thousands of Rust users about how (and where) they use the language, what they find hardest, and what they want next. Always a useful snapshot of where the community’s collective attention is heading — and yes, Vim landing near the top of the editor list generated the usual cheering.

via Martijn Faassen has moved (@faassen@fosstodon.org): I’ve just released a major change to the Xot XML tree library in Rust, version 0.21. It breaks a lot of APIs (as I’m the only major user at this point in time, I can still do it), and adds a lot of new functionalities.

Xot is, I claim, by far the most fully featured XML tree manipulation library available for Rust.

via Tim McNamara (@timClicks@mastodon.nz): Attached: 1 image

Tim McNamara points out a handy Rust tip: rustup can generate shell completions for itself and for cargo, so you get tab completion for subcommands and flags in your shell of choice. A small quality-of-life win that’s easy to miss in the rustup docs.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Rust Won’t Save Us: An Analysis of 2023’s Known Exploited Vulnerabilities

Horizon3’s analysis of the 2023 CISA Known Exploited Vulnerabilities catalog finds that memory-safety bugs account for a relatively small share of what attackers actually exploit; injection flaws, authentication bypasses, and logic errors dominate. A useful reality check for those of us who reach for Rust as a security panacea — memory safety closes one door, but plenty of others remain wide open.

via Brian Dorsey (@briandorsey@hachyderm.io): #rust #rustlang

binrw is a Rust crate that uses declarative attributes on ordinary structs and enums to generate binary parsers and writers, with support for endianness, conditional fields, and custom encodings. If you’ve ever hand-rolled byte-offset math for a file format or network protocol, this is a much safer and more readable way to do it.

via codepilot (@codepilot@chaos.social): It seems that “The four horsemen of bad #Rust code” by @mre@mastodon.social from #fosdem2024 is now available https://video.fosdem.org/2024/h1308/fosdem-2024-2434-the-four-horsemen-of-bad-rust-code.av1.webm

A FOSDEM 2024 talk on “The Four Horsemen of Bad Rust Code” — the recurring anti-patterns that show up when teams write Rust that compiles but fights the language instead of working with it. A good watch if you’ve ever wondered why your Rust code feels harder to maintain than it should.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Achieving Safe, Aliasable Mutability with Unboxed Types

Jake Fecher explains how the Ante language aims to allow aliasable mutability without giving up memory or thread safety, using unboxed types to sidestep Rust’s “Aliasability XOR Mutability” rule. A thoughtful look at one of the most common sources of friction in Rust’s borrow checker and what a different set of tradeoffs might look like.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): jj init: What if we actually could replace Git?

Chris Krycho makes a thorough, well-argued case for Jujutsu, the new Git-compatible version control system out of Google. His critique of Git’s incoherent mental model is worth the read on its own, but the real payoff is seeing how jj rethinks the working copy, revisions, and conflicts into something you can actually reason about.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Why Rust in Production?

Matthias Endler talks through several arguments for and against using Rust in production based on his experience consulting with many firms large and small.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): My Best and Worst Deadlock in Rust

Michael Snoyman walks through building a subtle Rust deadlock step by step, using an RwLock-guarded struct and a seemingly innocent read-then-write pattern. It’s the “worst” deadlock because it hides in plain sight, and the “best” because the tooling pointed straight at the culprit. Worth reading even if you think you know Rust’s concurrency rules.

Luca Palmieri fills a real gap in the Rust adoption literature: not how to convince your org to try Rust, but what to do once you’ve decided. His advice to not hire Rust specialists for your first project — and instead assess and upskill the team you already have — rings true, as does the warning about stranding a team of frustrated Rust experts if the bet doesn’t pan out.

Prossimo’s benchmarking work on Rustls shows the Rust TLS implementation already beating OpenSSL 3.2 in several scenarios, with automated per-PR performance feedback to catch regressions. A nice demonstration that memory safety doesn’t have to come at the cost of performance — historically the main argument for staying with C.

via Axel Rauschmayer (@rauschma@fosstodon.org): Two projects that sync in-browser SQLite databases with servers:

SQLSync is a collaborative, offline-first wrapper around SQLite that syncs web application state between users, devices, and the edge. Written in Rust and compiled to WASM, it brings reactive query subscriptions and automatic conflict resolution to local-first apps without requiring you to hand-roll a sync layer.

via Jan (@janpio@hachyderm.io): @scouten@ericscouten.social we have been trying https://codspeed.io/ for that use case. Works decently. Check github/prisma/prisma-engines PRs for examples.

CodSpeed runs benchmarks as part of CI and flags performance regressions directly in the pull request, using instrumentation rather than wall-clock timing so results aren’t drowned out by noisy shared runners. It supports Rust, Python, Node, and Go, and several open source projects use it to keep an eye on performance drift over time.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Announcing mdbook-pandoc: a mdBook backend powered by Pandoc. Render mdbooks to PDFs and much more!

An mdbook backend that uses Pandoc to generate output formats like PDF, EPUB, and more from mdbook projects. This is a useful tool for anyone writing documentation or books in Markdown with mdbook who needs high-quality typeset output beyond HTML.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Announcing Continuous Memory Profiling for Rust

Polar Signals, in collaboration with Materialize, has released rust-jemalloc-pprof, a library that exports jemalloc’s heap profiling capabilities in pprof format. This makes it much easier to debug memory leaks and understand heap usage in Rust applications, either as one-off investigations or as continuous profiling over time.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Common mistakes with Rust Async

A practical guide to common pitfalls in async Rust, starting with the often-overlooked issue of task cancellation. The Qovery team shares hard-won lessons about how async tasks can be stopped at any await point, leading to subtle bugs like counters that never decrement. A valuable read for anyone working with Tokio and async Rust in production.

via Luca Palmieri (@algo_luca@hachyderm.io): We all talk so much about why you should adopt Rust.

A practical guide for engineering leaders looking to introduce Rust into their organizations. Covers team building, upskilling strategies, and scaling — focusing on the often-overlooked management perspective rather than the usual individual contributor advocacy angle.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Introducing FireDBG - A Time Travel Visual Debugger

FireDBG is a time travel visual debugger for Rust that captures function call trees, arguments, and return values, then lets you navigate backward and forward through program execution. Instead of littering code with println! statements, it visualizes the entire control flow as an interactive call tree. A fascinating approach to making Rust debugging more intuitive.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): On inheritance and why it’s good Rust doesn’t have it

Jimmy Hartzell continues his series on why Rust is beyond object-oriented programming, tackling inheritance — the most problematic of OOP’s three pillars. He makes a compelling case that inheritance’s appeal is largely based on misleading textbook examples (shapes, animals) that have little to do with real-world programming, and explains why Rust deliberately omits it in favor of better composition patterns.

via Mara Bos (@Mara@hachyderm.io): 🦀 New #rustlang blog post! “Behind the Scenes of Rust String Formatting: format_args!()”

A deep dive into how Rust’s format_args!() macro and fmt::Arguments type work behind the scenes. Mara Bos explores the current implementation, its trade-offs in structure size, code size, and runtime overhead, and brainstorms potential future improvements. A fascinating look at one of Rust’s most ubiquitous but underappreciated building blocks.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Common Rust Lifetime Misconceptions (2020)

An excellent and thorough walkthrough of common misconceptions about Rust lifetimes. Covers key misunderstandings such as confusing lifetimes with scopes, thinking lifetimes can grow or shrink at runtime, and misunderstanding the relationship between T, &T, and &mut T with respect to lifetime bounds. A must-read for anyone looking to deepen their understanding of Rust’s ownership model.

via Matthias Endler (@mre@mastodon.social): If you don’t run parallel rustc yet, give it a shot. Nice perf boost on modern hardware.

The Rust compiler is gaining parallel front-end compilation support, which should help improve compile times for large Rust projects. This has been a long-awaited improvement in the Rust ecosystem.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): mem_dbg is a crate to recursively compute the memory usage of a data structure or print its layout

A Rust crate for measuring and displaying the memory usage of data structures, providing both the actual heap memory consumption and the capacity-based memory usage. Useful for profiling and optimizing memory in Rust applications.

via nrc (@nrc@hachyderm.io): Blog post: A response to ‘A decade of developing a programming language’. https://www.ncameron.org/blog/a-response-to-a-decade-of-developing-a-programming-language/

Nick Cameron, a long-time Rust contributor, responds to a blog post about a decade of programming language design. He shares thoughtful opinions on gradual typing, simplicity vs. expressivity in type systems, error handling design, and the tension between language complexity and usability.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Rust global variables, two years on

A thorough update on the state of global variables in Rust. With Mutex::new() now being const and OnceLock in the standard library, many common patterns that previously required external crates like once_cell or lazy_static now work out of the box. A great reference for anyone working with Rust globals.

via C & C++ Weekly (@c_discussions@mastodon.social): Idiomatic Rust (for C++ Devs): Constructors and Conversions

A thorough guide mapping C++ constructor patterns to idiomatic Rust equivalents. Covers initialization, default construction, conversions, copy/move semantics, and the From/Into traits, making it useful for anyone transitioning to Rust from C++ or similar languages.

via Rust Trending: greyblake / nutype: Rust newtype with guarantees 🇺🇦 🦀 ★972

Alex Kladov on matklad: Push Ifs Up And Fors Down

via Rust Weekly 🦀: Nix users, you can fearlessly start using Rust scripts already

via Chris Biscardi: Really enjoyed this post by @benwis on using cranelift and mold/sold to improve Leptos compile times. Includes explanations and benchmarks.

via Valentine Briese :transuwu:: Little bit of a trick I discovered for documenting fields which are on multiple structures:

via Matthias Endler: I wrote an article on “Rust in Production.”

via shuttle: RUST WEB FRAMEWORK COMPARISON 🚨

via Rust Weekly 🦀: Rust async vs C# async vs C++ async

via Rust Weekly 🦀: Microsoft is doubling down on Rust

via shuttle: LINK CHECKING WITH RUST 🌟

via yosh: From the Windows blog, about the increasing role @rust is playing in securing Microsoft Surface devices:

via Rust Weekly 🦀: Was Rust Worth It?

via Mo :ferris: :tux:: Faster Rust Serialization 🚀

via Matthias Endler: A quick article on how I deploy Rust apps:

via Rust Weekly 🦀: Learning Rust, a Python developer’s perspective

tamasfe/taplo: A TOML toolkit written in Rust

via Jack Rusher: “I will try to convince you that ridiculing JavaScript for this is less insightful than it first appears and that Swift’s approach to string length isn’t unambiguously the best one. Python 3’s approach is unambiguously the worst one, though.”

via Rust Weekly 🦀: cargo-dist pre-release looking for feedback!

via Martijn Faassen: This is a cool post about performance optimization:

via Rust Weekly: A fresh look on incremental zero copy serialization

via fasterthanlime 🌌: Holy fuck, migrating from the rust/cache action to the sccache action made macOS CI times (for a typical PR) fall from 9 minutes to 1 minute

via Florian Gilcher: ✅: implemented thanks.rust-lang.org in real life.

via Rust Daily: How we reduced the memory usage of our Rust extension by 4x

via Rust Weekly: Announcing Zngur: A C++/Rust interop tool

via yosh: I was pinged about fallible drop on the forums, so I wrote a few notes about the design space over there:

Cackle is a code ACL checker and is an additional tool to help make supply-chain attacks harder.

via Benjamin Fry: “… we’ve still found Rust to be a significant improvement over C (or C++), both in terms of safety and productivity, in all the bare-metal use cases where we’ve tried it so far.”

via Martijn: This nice little article on dependency injection in #rustlang is a good reminder that blog posts don’t need to be long or complicated to be valuable!

via James Gayfer: After almost a year hiatus, I’ve revived my blog 🎉

via Fabio Valentini: I just wrapped up feature development for rust2rpm v25 (the tool we use in crates and applications). I’ve been dogfooding the latest code for a few days now, and some of the changes make package maintenance much nicer — further reducing the need for manual changes.

via Rust Weekly: Announcing Divan: Fast and Simple Benchmarking for Rust

Via Rust tips: If you want your #Rustlang code to be fast and compact, avoid code that could panic.

via Adam Chalmers: My impressions from Rustconf 2023.

via Rust Weekly: ε-serde is an ε-copy (i.e., almost zero-copy) serialization/deserialization framework

via Rust Weekly: A Rust Dockerfile boilerplate for quickly building size optimized images

via notgull: New blogpost about Rust!

via Rust Weekly: I wrote a tool to print colorized Rust backtraces.

via Rust Weekly: Let’s Build a FIPS-Validated Rust Crypto Library

via Rust Weekly: allocation-counter: Count and test the number of allocations, now with more utility methods

via Rust Weekly: A tutorial for accessing C/C++ functions within a shared library (.dll/.so/.dylib) from Rust

via Rust Weekly: Silt-Lua, another pure rust Lua interpreter and runtime

via Rust Weekly: set_field: Set fields on structs by string

via Kevin Stewart: Using Zig in our incremental Turborepo migration from Go to Rust — Vercel

via yosh: Gah, Sabrina Jewson’s post on Async Drop really was ahead of all of us, and we’re all still just playing catch-up.

via Rust Weekly: Becoming a [Rust] contractor

via Rust Weekly: My Node.js is a bit Rusty: a x25 perf boost by rewriting a Node.js module into Rust with napi.rs

via Rust Weekly: Inside Rust Blog: crates.io Postmortem: User Uploaded Malware

via Rust Weekly: 5 Strong Opinions On Everyday Rust

GitHub: “Rust continues to top the charts as the most admired and desired language by developers, and in this post, we dive a little deeper into how (and why) Rust is stealing the hearts of developers around the world.”

via Kevin Stewart: Build a Cross-Platform CLI with Deno in 5 minutes

via Rust Weekly: Change in Guidance on Committing Lockfiles | Rust Blog

Arash Sal Moslehian: “We take a peek at the inner workings of Tokio, an asynchronous runtime for Rust that provides scheduling, networking, and many other primitive operations for managing asynchronous tasks.”

via Rust Weekly: Stateful Property Testing in Rust

“Rust has great support for type-driven design, which can guide you towards robust and idiomatic code to enforce invariants at compile-time. Always be on the lookout for ways to let the type-system guide you towards stronger abstractions.”

via Rust Weekly: Why Rust’s memory safety, performance, and concise syntax were a perfect fit for us

via Nicholas Nethercote: New blog post: “The top-level Rust compiler numbers are 7% walltime reductions and 10% peak memory reductions over the past five months, but read the whole post for the full details.”

via a co-worker: proptest: Hypothesis-like-property-based testing and shrinking.

via Rust Weekly: Picking the right Rust web framework in 2023

via Rust Weekly: Way too many strings in Rust? You may just need one more, meet hipstr

via Rust Weekly: I’m 15 years old and I wrote a QR code generator in Rust as my first project

via Rust Weekly: monch: Inspired by nom, but specifically for strings

via Chris Biscardi: I spent the last 6 months rewriting all of my infrastructure and tooling in #rustlang

via Rust Weekly: Inclusion of Rust ring crate now brings cryptographic operations and TLS clients to WASIX

via Kevin Stewart: Logan Keenan - Client-Side Server with Rust: A New Approach to UI Development

via Rust Weekly: Announcing August! An Emmet-like language that produces JSON, TOML, or YAML, written in Rust

via Rust Weekly: The Case for Rust on the Web

via Rust Trending: martinvonz / jj: A Git-compatible DVCS that is both simple and powerful ★3590

John Arundel on Bitfield Consulting: Rust vs Go in 2023

via Rust Weekly: Client-Side Server with Rust: A New Approach to UI Development

via Rust Weekly: Learning Async Rust With Entirely Too Many Web Servers

via Rust Weekly: Making illegal states unrepresentable

via Python Weekly: Understanding how Rust Python FFI works with cool info-graphics

via Rust Weekly: SpacetimeDB: A new database written in Rust that replaces your server entirely

via Erlang & Elixir Weekly: Interfacing Elixir with Rust to Improve Performance: Discord’s Story

via Rust Trending: kawasin73 / prsqlite: Pure Rust implementation of SQLite ★42

via Rust Trending: GyulyVGC / sniffnet: Application to comfortably monitor your Internet traffic 🕵️‍♂️ ★10303

via Rust Trending: supabase / postgres_lsp: A Language Server for Postgres ★1626

via Rust Weekly: Just wrote my first ever blog post on making fake pixel art with Rust and Blender. Feedback appreciated!

via Rust Trending: dandavison / delta: A syntax-highlighting pager for git, diff, and grep output ★18097

via Rust Weekly: CachewDB - An in-memory, key value database implemented in Rust

via Rust Trending: quickwit-oss / tantivy: Tantivy is a full-text search engine library inspired by Apache Lucene and written in Rust ★8527

via Rust Weekly: Optimizing CI/CD pipelines in your Rust projects

via Rust Trending: sharkdp / bat: A cat(1) clone with wings. ★42279

via Rust Weekly: How to improve Rust compiler’s CI in 2023

via Rust Weekly: Unsafe: on Rust still being helpful even with a lot of unsafe

via Predrag Gruevski: Cargo adopts cargo-semver-checks to ensure semver compliance of its own crates 🔥🔥🔥 @weihanglo once again pushing #rustlang forward, go team! 🦀

via Rust Weekly: An Open Source Project to Create Dashboards 10x Faster in Rust

via Rust Trending: pola-rs / polars: Fast multi-threaded, hybrid-out-of-core query engine focussing on DataFrame front-ends ★18955

via Rust Trending: starship: ☄🌌️ The minimal, blazing-fast, and infinitely customizable prompt for any shell! ★35371

via Rust Weekly: Blog Post: Can You Trust a Compiler to Optimize Your Code?

via Rust Weekly: High-throughput stream processing in Rust

via Rust Weekly: [Code review request] Rhythm: a thread-safe rate limiter in Rust with no dependencies

via Rust Weekly: Is using multi-line /* */ comments a bad practice?

Via Rust Trending: slint-ui / slint: Slint is a declarative GUI toolkit to build native user interfaces for applications that are written in Rust, C++, or JavaScript. ★9105

Via Rust Trending: orf / gping: Ping, but with a graph ★8826

via Rust Weekly: Optimizing Rust programs with PGO and BOLT using cargo-pgo

via Rust Weekly: We chatted with the maintainer of Iced - a cross-platform GUI library for Rust. Thoughts?

via Rust Trending: powdr-labs / powdr: A modular stack for zkVMs, with a focus on productivity, security and performance. ★151

via Rust Trending: IgnisDa / ryot: Roll your own tracker! ★452

via Rust tips: Another list of #rustlang tips

via Rust Trending: PRQL / prql: PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement ★7931

via Rust Trending: econaxis / time2reach: Public-transit travel time map ★112

via Rust Weekly: I’ve spent time to actually understand Pin and Unpin, so you don’t have to:

via Rust Weekly: Learn Unsafe Rust from My Mistakes

via Rust Weekly: Rust fact vs. fiction: 5 Insights from Google's Rust journey in 2022

via Rust Trending: o2sh / onefetch: Command-line Git information tool ★7980

via Rust Trending: WebAssembly / WASI: WebAssembly System Interface ★3877

via Rust Trending: TheAlgorithms / Rust: All Algorithms implemented in Rust ★16654

via Rust Trending: Byron / gitoxide: An idiomatic, lean, fast & safe pure Rust implementation of Git ★6554

via Rust Trending: DioxusLabs / dioxus: Fullstack GUI library for desktop, web, mobile, and more. ★10283

via Rust Weekly: SvelteKit and Tauri: Blazing-Fast Desktop Applications

via Kevin Stewart: What I Learned Building a CLI App in Rust - Stratus3D

via Rust Weekly: Simple Rust Function Macros - Sometimes, repeating yourself is not that bad, as long as macros do it for you

via Rust Weekly: Talloc, a better no_std allocator

via Golang Weekly: How Turborepo is porting from Go to Rust

via Rust Weekly: Leptos vs Dioxus vs Sycamore (vs Svelte?): Part 1 — Syntax comparison

via Rust Trending: iggy-rs / iggy: Iggy is the persistent message streaming platform written in Rust, supporting QUIC, TCP and HTTP transport protocols, capable of processing millions of messages per second. ★189

via Rust Weekly: Total functions, panic-freedom, and guaranteed termination in the context of Rust

via Rust Trending: cube-js / cube: 📊 Cube — The Semantic Layer for Building Data Applications ★15832

via Rust Trending: flamegraph-rs / flamegraph: Easy flamegraphs for Rust projects and everything else, without Perl or pipes <3 ★3574

via Rust Trending: launchbadge / sqlx: 🧰 The Rust SQL Toolkit. An async, pure Rust SQL crate featuring compile-time checked queries without a DSL. Supports PostgreSQL, MySQL, SQLite, and MSSQL. ★9239

via Rust Trending: swc-project / swc: Rust-based platform for the Web ★27978

via Rust Weekly: Why the “Null” Lifetime Does Not Exist

via Rust Weekly: Self-Hosted Cloud Using WebAssembly

via Zig Weekly: Three Different Cuts: Rust, Go, and Zig

via Rust Trending: rust-unofficial / awesome-rust: A curated list of Rust code and resources. ★35753

via Yoav Levy: Melody 0.19.0 | A language that compiles to regular expressions and aims to be more easily readable and maintainable

via Rust Weekly: Simple example of building rust code w/ C deps using nix + naersk

via Rust Trending: pingcap / talent-plan: open source training courses about distributed database and distributed systems ★8950

via Rust Trending: microsoft / windows-rs: Rust for Windows ★8689

via Rust Weekly: How rustdoc achieves a genius design

via Rust Trending: libp2p / rust-libp2p: The Rust Implementation of the libp2p networking stack. ★3476

via Rust Trending: tauri-apps / tauri: Build smaller, faster, and more secure desktop applications with a web frontend. ★66400

via Rust Trending: tikv: Distributed transactional key-value database, originally created to complement TiDB ★13339

via Rust Weekly: Maximizing Your Rust Code’s Performance

via yosh: Oh fun, now watching: “Flux: Liquid Types for Rust.”

via Rust Trending: openobserve: 🚀 10x easier, 🚀 140x lower storage cost, 🚀 high performance, 🚀 petabyte scale - Elasticsearch/Splunk/Datadog alternative for 🚀 (logs, metrics, traces). ★5117

via Rust Weekly: Announcing mailfred 0.1, a library to offer services through the email infrastructure processing emails as requests & responses.

via Rust Weekly: Blog Post: Put a Pin on That

via Nicholas Nethercote: New blog post: Back-end parallelism in the Rust compiler

via Rust Weekly: Fighting Rust Anxiety: Insights from a Go Developer

via Rust Weekly: vim-doge v4: The Rust Rewrite

via yosh: New blog post: Bridging Fuzzing and Property Testing

via Rust Weekly: Ubiquity (v0.3.0) - I made a cross-platform markdown editor to learn some Rust. It uses Yew, Tauri, Tailwind and DaisyUI. Currently available on Windows, Linux and the web. (Appears that a Mac version has been added since.)

Kent Bull: KERI Tutorial Series — KLI: Sign and Verify with Heartnet

via Rust Trending: m1guelpf / tinyvector: A tiny embedding database in pure Rust. ★135

via Rust Weekly: Building a Web App in Rust: From Zero to Deployment

via Rust Trending: rustdesk: Virtual / remote desktop infrastructure for everyone! Open source TeamViewer / Citrix alternative. ★43747

Tue Henriksen on LinkedIn: Why Rust is easy

via Rust Trending: dtolnay / proc-macro-workshop: Learn to write Rust procedural macros [Rust Latam conference, Montevideo Uruguay, March 2019] ★2979

via Boa JavaScript engine: Boa just arrived at @fosstodon, so here we have our #introduction. 😋

via Rust Weekly: Zawgl graph database

via @modev: I have started “Rust Atomics and Locks” by Mara Bos.

via Rust Trending: firecracker-microvm / firecracker: Secure and fast microVMs for serverless computing. ★21924

via Gankra: We just released the first version of our next release-engineering tool — oranda!

via Rust Weekly: Languages on the rise like Rust and Go are being quite vocal against inheritance and many engineers seem to agree. Why? And is it the fall of inheritance?

via Rust Daily: How to think about async/await in Rust

Raymii.org: Site update, self-hosted search via pagefind

via Rust Trending: surrealdb: A scalable, distributed, collaborative, document-graph database, for the realtime web ★21210

via Rust Trending: rust-unofficial / awesome-rust: A curated list of Rust code and resources. ★35492

via Rust Weekly: Pixelate images - an intro to Rust and the image crate

Lars Bergstrom at Google Open Source Blog: Rust fact vs. fiction: 5 Insights from Google’s Rust journey in 2022

via Rust Daily: Building an out-of-tree Rust Kernel Module

Grafbase: How we built the Grafbase local development experience in Rust

A Lemmy instance dedicated to Rust language.

via Rust Weekly: I was wrong about Unsafe Rust

Programming Language and compiler benchmarks: Rust vs Zig benchmarks: Which programming language or compiler is faster?

Richard Schneeman at Scheems: It’s dangerous to go alone, pub mod use this.rs

via Rust Daily: Effective Rust (35 Specific Ways to Improve Your Rust Code):

Quickwit blog: Observe your Rust application with Quickwit, Jaeger and Grafana

via Rust Trending: spyglass-search / spyglass: A personal search engine: Create a searchable library from your personal documents, interests, and more! ★1824

via Rust Weekly: GQL: A new SQL like query language for .git files written in Rust

via Rust Weekly: Google open-sources Rust crate audits

via Rust Weekly: Blog post: Writing Python like it’s Rust

via heckj: @nugmanoff and I have just cut an initial release of YSwift, an MIT licensed open source Swift CRDT library that is powered by the Rust implemention of Yjs.

via Rust Weekly: More than 10x faster Rust + Cargo builds with Firebuild cache

via Webdev Weekly: Can Rust Beat JavaScript in 2023?

via Rust Daily: The Rust Performance Book

GitHub: VPlugin/VPlugin: A Rust framework to develop and use plugins within your project, without worrying about the low-level details

via Rust Trending: getdozer / dozer: Connect any data source, combine them in real-time and instantly get low-latency Data APIs. All with just a simple configuration! ★633

via yosh: Alright, did a final one: the html crate now implements the right content types for each element. This is just the broad categories, not yet the special one-off item kinds. But it should get like 90% the way there!

via Rust Weekly: Modular Errors in Rust — Sabrina Jewson

via Rust Trending: MaterializeInc / materialize: Materialize is a fast, distributed SQL database built on streaming internals. ★4966

via Axel Rauschmayer: Limitations of #Rust strings

via Rust Weekly: imstr crate: Immutable Strings in Rust (Cheaply Clone-able and Slice-able Strings)

GitHub: dtolnay/no-panic: Attribute macro to require that the compiler prove a function can’t ever panic

via Rust Weekly: garde: a validation library

via Rust Weekly: thiserror, anyhow, or How I Handle Errors in Rust Apps

via Rust Weekly: Blog Post: Rust Is a Scalable Language

via Rust Weekly: NIST added Rust to its list of “Safer Languages” as part of its Software Assurance Metrics and Tool Evaluation

via squillace: #webassembly at the #edge from #wasmio

via Ed Page: clap v4.2.0, with user-styled help descriptions, is now out!

via Rust Weekly: Generators

via Rust Weekly: Is there any AST-level analysis/instrumentation tool for Rust?

Adam Chalmers: Why use Rust on the backend?

via Stefan Baumgartner: Giving zed.dev another spin. It’s fast and it’s beautiful, really. It’s a pleasure to look at it and the original theme is very balanced. It feels very snappy, especially when you get LSP feedback. I miss inlay hints, but I’m sure they will end up one way or another.

via Rust Trending: google / comprehensive-rust: This is the Rust course used by the Android team at Google. It provides you the material to quickly teach Rust to everyone. ★10865

via Rust Weekly: Must move types by Niko Matsakis

via Rust Weekly: Mountpoint — file client for S3 written in Rust, from AWS

via Rust Trending: analysis-tools-dev / static-analysis: ⚙️ A curated list of static analysis (SAST) tools and linters for all programming languages, config files, build tools, and more. The focus is on tools which improve code quality. ★10978

via Rust Weekly: Switching from C++ to Rust

via Rust Weekly: Why is safe version of function faster than unsafe?

via Rust Weekly: Faster than Rust and C++: the PERFECT hash table

via sbmueller: Thanks @nrc for this splendid guide on error handling in Rust. Also much good stuff for error handling in general.

via Rust Trending: meilisearch: A lightning-fast search engine that fits effortlessly into your apps, websites, and workflow. ★34478

via Allan Friedman: This is pretty cool: a brand new free @github tool for creating #SBOM data for your repos. Built on the dependency graph API — supports Go, Rust, NPM, maven, and more. Both CDX and SPDX support!

via Rust Trending: neondatabase / neon: Neon: Serverless Postgres. We separated storage and compute to offer autoscaling, branching, and bottomless storage. ★6825

via Zig Weekly: When Zig is safer and faster than Rust

via Kevin Stewart: Why Turborepo is migrating from Go to Rust — Vercel

“Zero setup” cross compilation and “cross testing” of Rust crates

via Rust Daily: Safety and Soundness in Rust:

via Rust Weekly: Semgrep - Beta support for Rust

via Kevin Stewart: Why we built a Rust-powered desktop app for previewing documentation

Spyglass: Create a launchbar app w/ Tauri

via Rust Weekly: TL;DR: lld is a great choice for faster linking of iOS, macOS, etc. debug binaries. It takes 20-50% less time than ld64 and is now used by many large companies. Steps on how to integrate are in the section below. zld has been archived in favor of lld.

Ecow: Compact, clone-on-write vector and string.

A way to query arbitrary data sources in SQL-like fashion.

Adam Wiggins: The 2.0 release of Automerge is a huge milestone for local-first software. If you’re interested in developing great multi-user, multi-device software without needing massive infrastructure, it’s worth reading this post in full.

Google: For more than a decade, memory safety vulnerabilities have consistently represented more than 65% of vulnerabilities across products, and across the industry. On Android, we’re now seeing something different — a significant drop in memory safety vulnerabilities and an associated drop in the severity of our vulnerabilities.

UniFFI is a tool that automatically generates foreign-language bindings targeting Rust libraries. The repository can be found on GitHub. It fits in the practice of consolidating business logic in a single Rust library while targeting multiple platforms, making it simpler to develop and maintain a cross-platform codebase.