Hasty Briefs - Daily Tech News Brief

Bilingual

Hyperion: Minecraft game engine for custom events
8 months ago
- Built in Rust for high confidence against memory leaks and SEGFAULTS.
- Supports both vertical and horizontal scalability.
- I/O identified as the main bottleneck in massive events; logic can be offloaded horizontally.
- Core game server is scaled vertically.
A practical introduction to parsing in Rust
7 months ago
- Parsing transforms text into computer instructions, with parsers being a key stage in compilers.
- Parsers convert source code into syntax trees, which can be concrete (CST) or abstract (AST).
- The article introduces a simple language called 'simp' for parsing demonstration, inspired by Rust.
- Lexical analysis (lexing) splits source text into tokens, simplifying parsing by matching tokens instead of characters.
- The 'Logos' library is used for efficient lexer generation, handling tokens like keywords, operators, and literals.
- Parsing involves recursive descent, following grammar rules to build syntax trees from tokens.
- The parser handles statements (functions, variables) and expressions (arithmetic, calls) with precedence and associativity.
- Error recovery and reporting are crucial for user-friendly parsing, suggesting multiple error reports per file.
- Performance optimizations include arena allocation and minimizing small allocations in AST representation.
- Testing parsers effectively involves snapshot testing for ASTs and error messages, using tools like 'insta' and 'glob_test'.
Linux 6.18 Expected to Land Google's Rust Binder Driver
7 months ago
- Google engineers have reimplemented Android's Binder driver in Rust, which is critical for inter-process communication (IPC).
- The Rust Binder driver is queued for Linux 6.18 and expected to be merged soon.
- The driver has been tested on Android emulators and Google Pixel 6 Pro, supporting all features of the C version.
- The rewrite addresses complexity, technical debt, and security issues in the original Binder driver.
- Rust was chosen for its ability to prevent common programming errors like ref counting mistakes and use-after-free issues.
- The new driver aims to reduce complexity and improve security, crucial for Android's sandboxing strategy.
Are We Chasing Language Hype over Solving Real Problems?
7 months ago
- Debate over Ubuntu adopting a Rust-rewritten version of GNU Core Utils highlights concerns about unnecessary rewrites of stable, battle-tested software.
- Criticism of the tech community's tendency to prioritize new languages and frameworks over solving real problems, questioning the actual benefits of such rewrites.
- Discussion on 'shiny object syndrome' in software development, where the excitement for new technologies overshadows practical evaluation of their necessity and impact.
- Analysis of the psychological appeal of new programming languages, including their features, community, and the fresh perspectives they offer.
- Skepticism about the performance and security claims of Rust-rewritten GNU Core Utils, emphasizing the decades of optimization in the original C implementation.
- Reflection on broader industry trends where novelty is often celebrated over necessity, citing examples from web development like React Server Components and GraphQL.
- Call to focus on solving real problems rather than chasing hype, advocating for thoughtful evaluation of new technologies based on their merits and actual utility.
Why Zig Feels More Practical Than Rust
7 months ago
- Zig is considered more practical than Rust for CLI tools due to its simplicity and manual memory management.
- Rust's borrow checker enforces memory safety at compile time but adds complexity and cognitive overhead.
- Memory safety is just one aspect of software safety; predictable behavior, robustness, and performance are also crucial.
- Zig provides manual memory management with allocators and defer statements, offering control without the complexity of Rust's borrow checker.
- Developer ergonomics in Zig are better for small CLI tools, making it easier to write and reason about code.
- Rust excels in large, multithreaded systems where compile-time guarantees are essential.
- Zig treats developers as capable adults, while Rust's strict rules can feel restrictive for simple projects.
From Rust to Reality: The Hidden Journey of Fetch_max
7 months ago
- The article explores the journey of the `fetch_max` operation in Rust, from high-level code to assembly.
- It starts with a job interview scenario where a candidate uses Rust's `fetch_max` for atomic operations, sparking curiosity.
- The author investigates how Rust's `fetch_max` is implemented, uncovering layers of compiler transformations.
- The first layer is the Rust code itself, which is concise and safe for concurrent programming.
- The second layer involves macro expansion, where `fetch_max` is generated by a Rust macro for various atomic types.
- The third layer delves into LLVM IR, where Rust's high-level atomic operations are translated into intermediate representations.
- The fourth layer examines the transformation of LLVM IR into a compare-and-swap (CAS) loop for architectures like x86-64.
- The fifth layer reveals the final assembly code, showing how the CAS loop is implemented at the hardware level.
- The article highlights the power of modern compilers in abstracting complex, low-level details for developers.
- It also notes that some architectures, like Apple Silicon (AArch64), have native atomic max instructions, avoiding the need for a CAS loop.
- The author concludes by appreciating the abstraction and efficiency of Rust's compiler, which handles complex tasks seamlessly.
Engineering a fixed-width bit-packed integer vector in Rust
7 months ago
- Memory usage is a bottleneck when working with large datasets, especially when storing integers with smaller dynamic ranges than their type's capacity.
- Bit packing is introduced as a solution to reduce memory waste by storing integers back-to-back in a contiguous bitvector, allowing for more efficient storage.
- The article explores implementing a vector-like data structure in Rust called FixedVec, which compresses integers into a bit-packed format while maintaining O(1) random access performance.
- FixedVec mimics Rust's standard Vec<T> ergonomics, supporting mutable access and zero-copy slicing.
- The structure uses a backing buffer of u64 words and precomputes a mask for efficient bit extraction.
- Accessing elements involves calculating the bit position, word index, and bit offset, with optimizations for both in-word and cross-word boundary cases.
- Unaligned memory access is leveraged to improve read performance by reducing the number of memory operations required for cross-word elements.
- Benchmarks show that FixedVec outperforms standard Vec<T> for smaller bit widths due to improved cache locality.
- Iteration over FixedVec is optimized by maintaining a stateful iterator that amortizes memory access costs over multiple next() calls.
- Mutable access is provided through a proxy object pattern, enabling safe and ergonomic modifications to bit-packed data.
- Zero-copy views and slices are supported, allowing for efficient sub-region operations without data duplication.
- The article discusses future directions, including concurrent access and variable-length encoding for skewed data distributions.
STMicroelectronics official MEMS drivers, written in Rust
7 months ago
- Repository contains low-level platform-independent drivers for STMicroelectronics sensors written in Rust.
- Drivers follow the naming convention PARTNUMBER-rs (e.g., lsm6dsv16x-rs).
- Includes a 'util' folder with additional resources like libraries and crates.
- Each sensor driver folder contains a submodule repository, examples, and a README.
- Drivers require setting up hardware bus (SPI/I2C) and providing configured bus instance.
- BusOperation trait allows generic bus usage (I2C/SPI).
- Examples provided for Embassy and STM32 frameworks.
- Requires Rust compiler targeting the MCU and specified MSRV.
- Examples primarily for STM32 NUCLEO_F401RE but adaptable to other platforms.
- Schematics for STMicroelectronics evaluation boards guide pin setup for I2C/SPI.
Comparing Rust to Carbon
7 months ago
- Chandler Carruth presented at RustConf 2025 about interoperability between Rust and C/C++, highlighting the challenges and differences in approaches between Rust and Carbon.
- Carbon is an experimental language designed to be a C++ alternative, focusing on better syntax and memory safety while maintaining full compatibility with C++ for incremental upgrades.
- Carbon aims to allow file-by-file migration from C++ without changing the compiler or build system, though it is not yet usable as complex details are still being worked on.
- Rust's interoperability tools (e.g., bindgen, cxx crate, Crubit) are not ideal for brownfield C++ projects, which are tightly coupled and harder to decompose compared to greenfield projects.
- Carbon's design prioritizes meeting C++ where it is, inheriting complexities like separate compilation and header files, making it more suited for gradual migration of entrenched C++ codebases.
- Carbon introduces 'alias sets' to handle pointer aliasing in APIs, a feature Rust lacks, making it easier to represent complex C++ APIs without refactoring.
- Carbon allows patterns the compiler cannot prove memory-safe to be warnings instead of errors, offering flexibility Rust's strict safety checks do not.
- Rust and Carbon are seen as complementary, with Rust targeting greenfield development and Carbon focusing on incremental migration of existing C++ codebases.
Redox OS Development Priorities for 2025/26
7 months ago
- Redox development priorities for 2025/26 include stability, performance, and compatibility improvements.
- Three main Redox variants: Hosted Redox (Web Services Runtime), Redox Server (Edge and Cloud), and Redox Desktop (daily driver).
- Key development areas: Building Redox on Redox, compliance, programming language support, performance, security, hardware support, COSMIC/Wayland/GPU, and accessibility.
- Ways to contribute: Donations, development, documentation, and applying for grants.
- Redox is hiring a kernel/core developer and frequently applies for grants.
- Hosted Redox aims to be a secure runtime for web services, requiring improvements in network stack, virtiofs, virglrenderer, and more.
- Redox Server targets secure hosting for web services, with phased multi-tenant containerization.
- Redox Desktop focuses on usability, COSMIC Desktop support, and sandboxing by default.
- Self-hosting development on Redox is a priority, needing network performance improvements, Rust compiler updates, and workflow enhancements.
- Compliance and compatibility efforts include POSIX compliance, Rust std library testing, and porting Linux applications.
- Performance improvements focus on ring buffers for disk/network, scheduler updates, and hardware-accelerated graphics.
- Security enhancements involve capability-based security and Capsicum-style mechanisms.
- Hardware support includes firmware, WiFi, USB, I2C, IOMMU, and virtualization.
- COSMIC, Wayland, and GPU acceleration are high priorities, alongside accessibility and internationalization efforts.
Wild: A Fast Linker Written in Rust, Aims to Outperform Mold Linker
7 months ago
- Wild is a new high-speed linker written in Rust, aiming to outperform existing linkers like Mold.
- Led by David Lattimore, Wild focuses on fast linking for Linux systems and supports iterative development.
- Key design goals include incremental linking, which Mold does not currently support.
- Wild has been tested on Linux x86_64, ARM64/AArch64, and RISC-V platforms but lacks non-Linux and LTO support.
- Benchmarks show Wild outperforming LLD and sometimes Mold in certain scenarios.
- Licensed under Apache 2.0 and MIT, Wild is available on GitHub for further exploration.
Rustroid, a Rust IDE for Android
7 months ago
- Rustroid is a Rust IDE for Android that runs locally on the device.
- The creator's journey began with Minecraft modding on a mobile phone, leading to a realization about the lack of developer tools for Android.
- Experimentation with Java and Android SDK led to the creation of Rustroid after discovering Rust's ecosystem.
- Rustroid works by leveraging Android's Linux base and Termux's ported packages to run Rust on Android.
- The IDE features include a code editor with LSP, terminal emulator, and file explorer, built using Kotlin and Jetpack Compose.
- Key challenges included implementing a piece tree text buffer, syntax highlighting, and LSP integration.
- The app is distributed as a paid application on Google Play, priced at $7.00 USD, with considerations for accessibility.
- Future plans include expanding the IDE to support more languages and utilizing Compose Multiplatform for cross-platform development.
I built Foyer: a Rust hybrid cache that slashes S3 latency
7 months ago
- S3 is widely used in modern data systems for its unlimited capacity, durability, and low cost but suffers from high latency.
- RisingWave, a streaming database, faces significant latency challenges with S3 due to real-time processing requirements.
- Foyer is a hybrid caching library in Rust built by RisingWave to reduce S3 latency by combining memory and disk caching.
- Foyer's architecture includes a memory cache for low-latency access, a disk cache for larger capacity, and a coordinator to unify both layers.
- Foyer supports two modes: hybrid mode (memory and disk) and memory-only mode, with a consistent API for both.
- Hybrid caching with Foyer reduces S3 requests, lowers latency, and cuts costs while maintaining scalability and durability.
- RisingWave integrates Foyer deeply into its storage stack, using it to manage disk I/O, prefetching, and cache hydration.
- Foyer's design allows RisingWave to balance S3's cost benefits with the low-latency needs of stream processing.
- Hybrid caching is essential for real-time workloads using object stores like S3, making architectures viable for high-throughput applications.
Show HN: Cap'n-rs – Rust implementation of Cloudflare's Cap'n Web protocol
7 months ago
- Complete implementation of Cap'n Web protocol in Rust
- Supports capability-based RPC with promise pipelining
- Multi-transport support including HTTP, WebSocket, and WebTransport
- Production-ready with zero-panic code and comprehensive error handling
- Includes IL expression evaluation and JavaScript interoperability
- Organized into focused crates: core, transport, server, client, and interop-tests
- Comprehensive test suite and benchmarks included
- Fully compatible with JavaScript implementations
- Detailed documentation and coding standards provided
- Licensed under Apache 2.0 or MIT
Level Up your Rust pattern matching
7 months ago
- Rust's pattern matching basics include matching on enums, destructuring tuples, and handling Option and Result.
- Advanced techniques involve matching literals, variables, wildcards, and destructuring tuples and structs.
- Working with arrays and slices allows matching on structure, with array matches requiring exact elements and slice patterns adapting to any length.
- Advanced techniques include taking references instead of consuming values, using match guards for complex conditions, and binding the whole value with @.
- Patterns are allowed in irrefutable contexts (let bindings, function parameters) and refutable contexts (match, if let).
- Best practices include considering performance for hot paths, preferring match over if/else chains for enums, and destructuring multiple fields in one pattern.
- Using matches! for simple boolean checks is more concise than single-arm match.
- Key takeaways include mastering advanced destructuring, reference patterns, guards, @ bindings, and choosing the right pattern matching tool.
Bevy 0.17: ECS-driven game engine built in Rust
7 months ago
- Bevy 0.17 released with contributions from 278 contributors and 1311 pull requests.
- New experimental feature: Bevy Solari for raytraced lighting.
- Improved Observers/Events API for better flexibility and documentation.
- Introduction of Headless Bevy UI Widgets and Bevy Feathers for tooling-focused widgets.
- Rust Hotpatching allows for hot-reloaded Rust code without restarting the program.
- Light Textures feature for artistic light intensity modulation.
- DLSS support for Nvidia RTX GPUs for anti-aliasing and upscaling.
- Tilemap Chunk Rendering for efficient tilemap rendering.
- Web Assets support for loading assets from HTTP/HTTPS URLs.
- Reflect Auto-Registration simplifies runtime reflection setup.
- Frame Time Graphs for debugging frame times in Bevy apps.
- UI Gradients for background and border gradients in UI.
- Raymarched Atmosphere for more accurate lighting.
- Virtual Geometry BVH Culling improves rendering performance.
- Event/Observer overhaul for clearer and more performant APIs.
- Bevy Feathers introduces a comprehensive UI widget set for tooling.
- Headless Bevy UI Widgets provide unstyled, standardized widgets.
- Light Textures allow textures to modulate light intensity.
- Hot Patching Systems enables modifying systems during execution.
- DLSS integration for higher quality and stable images.
- Tilemap Chunk Rendering as a step towards built-in tilemap support.
- ViewportNode for rendering camera output directly to UI nodes.
- Raymarched Atmosphere supports accurate views from above the atmosphere.
- Procedural Sun Disk for realistic sun lighting.
- Web Assets support loading assets from the web with caching options.
- Reflect Auto-Registration reduces boilerplate for reflection setup.
- Virtual Geometry BVH Culling removes previous cluster limits.
- Frame Time Graph helps visualize performance metrics.
- Text2d Drop Shadows and Text Background Colors enhance text rendering.
- UI Gradients and Per-side UI Border Colors improve UI styling.
- Specialized UI Transform replaces Transform for UI elements.
- Data-Driven Materials refactor for more dynamic material handling.
- Entity Spawn Ticks for tracking recently spawned entities.
- ButtonInput for Key provides layout-aware key input handling.
- Val helper functions simplify UI value construction.
- glTF Forward Semantics Configuration for consistent model orientation.
- RenderStartup Schedule improves renderer initialization.
- Component Propagation simplifies state coordination in hierarchies.
- Infinite Children support in the children! macro.
- Decoupling Bevy's Public API from Bevy Render for modularity.
- Consistent Naming Conventions for System Sets improve clarity.
- Future plans include BSN, improved UI framework, and first-party entity inspector.
Pre-Emptive Multi-Tasking on Arm Cortex-M
7 months ago
- The article discusses writing a pre-emptive multi-tasking RTOS (Real-Time Operating System) for Arm Cortex-M processors using Rust.
- Background: The author writes embedded software in Rust, including for safety-critical systems, often transitioning from C-based RTOSes.
- C-language RTOSes: Lists several RTOS options like FreeRTOS, ThreadX, Zephyr, etc., highlighting their variability in features, licensing, and safety-critical ratings.
- Rust-language RTOSes: Mentions RTOSes written in Rust, such as embassy and RTIC, noting their different approaches to task handling.
- RTOS Definition: Explains that an RTOS provides real-time guarantees, allowing tasks to run with predictable timing, unlike general-purpose OSes like Windows.
- Arm Cortex-M Features: Details how Cortex-M processors facilitate RTOS development with features like automatic register saving, SysTick timer, and PendSV exception for task switching.
- Writing an RTOS in Rust: Describes the process of setting up task stacks, using PendSV for context switching, and managing task states.
- Example Implementation: Provides a Rust code example demonstrating task creation, stack management, and scheduler initialization.
- Conclusions: Summarizes that writing an RTOS in Rust for Cortex-M is feasible with about 300 lines of code, leveraging hardware features effectively without needing C.
How to Avoid Fighting Rust Borrow Checker
7 months ago
- Rust's ownership system forms a tree-shaped structure where each object has exactly one parent.
- Mutable borrows in Rust are exclusive, meaning no other borrows can coexist with a mutable borrow.
- Borrowing in Rust is contagious; borrowing a child indirectly borrows all its parents.
- Rust's borrow checker can reject some correct programs due to its conservative nature.
- Reference shapes in memory can be tree-shaped (simple) or involve sharing (complex).
- For shared immutable objects, use immutable borrows or reference counting (Rc/Arc).
- Shared mutable objects are borrow-check-unfriendly and require special solutions.
- Circular references in data structures complicate borrowing and require careful handling.
- Solutions for borrow-check-unfriendly cases include data-oriented design, ID/handles, and deferred mutation.
- Contagious borrowing can cause issues when borrowing a part of an object forces borrowing the whole object.
- Interior mutability (Cell, RefCell, Mutex) allows mutation through immutable references.
- Using IDs or handles instead of borrows can decouple object lifetimes from references.
- Deferring mutation by treating mutations as data (commands) can simplify borrowing.
- Circular references in programming are common but require weak references (Weak) to avoid memory leaks.
- Rust's mutable borrow exclusiveness is crucial for memory safety, especially with interior pointers.
- Reference counting (Rc/Arc) has performance costs due to atomic operations.
- Bump allocators provide fast allocation but cannot free individual objects.
- Unsafe Rust allows bypassing borrow checker but requires careful handling to avoid undefined behavior.
- Rust's Send and Sync traits ensure thread safety by controlling data sharing across threads.
- Async programming in Rust requires futures to be Send and 'static for thread safety.
- Temporary lifetime extension and reborrowing are subtle aspects of Rust's borrowing rules.
- Rust's trade-offs include memory safety and performance at the cost of flexibility and quick iteration.
DARPA project for automated translation from C to Rust (2024)
7 months ago
- DARPA launches the TRACTOR program to automate the translation of legacy C code to Rust, aiming to eliminate memory safety vulnerabilities.
- Memory safety issues in C arise from direct memory manipulation and undefined behaviors, leading to prevalent software vulnerabilities.
- The software engineering community agrees that bug-finding tools are insufficient, advocating for proactive solutions like memory-safe languages.
- Rust, a memory-safe language, is gaining traction, but rewriting vast amounts of legacy C code at scale remains a challenge.
- TRACTOR seeks to improve automated C-to-Rust translation using novel combinations of software analysis and large language models (LLMs).
- Public competitions will test LLM-powered solutions, aiming for translations that match the quality of skilled Rust developers.
- Rust's strict rules act as guardrails, ensuring memory safety and allowing developers to focus on higher-level concerns.
- DARPA will host a Proposers Day on Aug. 26, 2024, for interested participants to learn more about the TRACTOR program.
The Expression Problem and Rust
7 months ago
- The expression problem in software design involves balancing extensibility between adding new data types and new operations.
- Rust's trait objects initially seem to avoid the expression problem, but the solution is not straightforward.
- Two common approaches in Rust are enum-based (easy to add operations, hard to add data types) and trait-based (easy to add data types, hard to add operations).
- Splitting a single trait into multiple traits per operation was proposed as a solution but introduces new issues, such as hard-coding operations in data type definitions.
- A proposed solution involves using generics to allow functions to specify required operations or data types dynamically, avoiding hard-coded lists.
- Implementing this solution in Rust requires complex patterns, such as using `Unsize` for trait objects, which may be overengineering for many use cases.
- The article suggests that sometimes committing to opinionated design choices is better than striving for perfect extensibility in statically typed languages like Rust.

Hasty Briefsbeta

#rust

Hyperion: Minecraft game engine for custom events

A practical introduction to parsing in Rust

Linux 6.18 Expected to Land Google's Rust Binder Driver

Are We Chasing Language Hype over Solving Real Problems?

Why Zig Feels More Practical Than Rust

From Rust to Reality: The Hidden Journey of Fetch_max

Engineering a fixed-width bit-packed integer vector in Rust

STMicroelectronics official MEMS drivers, written in Rust

Comparing Rust to Carbon

Redox OS Development Priorities for 2025/26

Wild: A Fast Linker Written in Rust, Aims to Outperform Mold Linker

Rustroid, a Rust IDE for Android

I built Foyer: a Rust hybrid cache that slashes S3 latency

Show HN: Cap'n-rs – Rust implementation of Cloudflare's Cap'n Web protocol

Level Up your Rust pattern matching

Bevy 0.17: ECS-driven game engine built in Rust

Pre-Emptive Multi-Tasking on Arm Cortex-M

How to Avoid Fighting Rust Borrow Checker

DARPA project for automated translation from C to Rust (2024)

The Expression Problem and Rust