Hasty Briefsbeta

All tags

#rust

595 stories total

Bilingual

Announcing the Clippy feature freeze
10 months ago
- Clippy project will be on a 12-week feature-freeze starting from Rust 1.89.0 beta (June 26th 2025) to September 18th 2025 (Rust 1.89.0 stable release).
- No new features will be accepted during the freeze, only bug fixes.
- The freeze is due to a lack of capacity to maintain existing lints (over 750) and add new ones.
- The team will focus on improving the contribution process and marking good first issues for new contributors.
- Users can expect more accurate lints with fewer false positives and better edge case coverage.
- New lint requests can still be submitted as issues, but PRs for new lints will be queued until after the freeze.
- Advanced PRs for new lints might still be reviewed or merged during the freeze.
- Contributors are encouraged to help by fixing bugs, improving documentation, or addressing diagnostic issues.
- Direct help is available via Zulip or draft PRs for feedback.
- The goal is to improve Clippy's quality to meet the Rust community's expectations.
Show HN: Ariadne – A Rust implementation of aperiodic cryptography
10 months ago
- The Ariadne Suite is a Rust implementation of the Ariadne Protocol, a novel cryptographic architecture.
- Core components include `ariadne-core`, `ariadne-generator`, and `ariadne-primitives` for cryptographic operations.
- High-level protocols like `ariadne-etm` and transport protocols (`ariadne-transport-ephemeral`, `ariadne-transport-static`) are included.
- The protocol uses the Labyrinth (a binary tree of cryptographic rounds) and Thread (secret path through the Labyrinth).
- Aperiodic by design, ensuring no two blocks are processed the same way, providing inherent tamper resistance.
- Limitations include finite path length and no random access during decryption.
- The project is experimental, unaudited, and not recommended for production use.
- Includes comprehensive tests, documentation, and is released under CC0-1.0 license.
- Community contributions are welcome, evaluated on technical merit.
Snow - Classic Macintosh emulator
10 months ago
- Snow emulates classic Motorola 680x0-based Macintosh computers with a hardware-level approach.
- Supported models include Macintosh 128K, 512K, Plus, SE, Classic, and Macintosh II.
- Written in Rust and open-sourced under the MIT license.
- Features a graphical user interface and extensive debugging capabilities.
- Offers a limited online demo without full software functionality.
- Bleeding edge builds available for Windows, MacOS, and Linux.
- Documentation available for setup and further information.
- Bug reports can be filed on GitHub; support available via Discord.
Writing a basic Linux device driver when you know nothing about Linux drivers
10 months ago
- The author purchased a Nanoleaf Pegboard Desk Dock, which only supports Windows and macOS, prompting the development of a Linux driver.
- After reverse-engineering the device's protocol and receiving official documentation from Nanoleaf, the author decided to write a Linux driver.
- The device was identified using `lsusb`, revealing it as a Human Interface Device (HID) with a generic USB driver in the Linux kernel.
- Two options were considered for the driver: a kernel driver or a userspace driver via `libusb`. The author chose the latter for simplicity.
- A `udev` rule was created to allow non-root users to access the device, with specific instructions for NixOS users.
- The driver was written in Rust using the `rusb` crate, starting with basic device enumeration and interface claiming.
- The author encountered and resolved issues with the kernel driver holding the device open, requiring manual detachment.
- Data was sent to the device using interrupt endpoints, with initial success in changing the device's LED color.
- The driver was improved to handle interrupts properly, including polling for device responses in a background thread.
- The final proof-of-concept demonstrated that writing a simple USB device driver is feasible with minimal code.
Iroh: A library to establish direct connection between peers
10 months ago
- Iroh provides an API for dialing by public key, finding and maintaining the fastest connection.
- It attempts direct connections first, using hole-punching if necessary, with fallback to public relay servers.
- Built on QUIC using Quinn, offering authenticated encryption, concurrent streams, and avoiding head-of-line blocking.
- Pre-existing protocols include iroh-blobs, iroh-gossip, iroh-docs, and iroh-willow for various functionalities.
- Easiest to use from Rust, with example code provided for connecting and accepting connections.
- Includes iroh-ffi for FFI bindings to use from other languages.
- Repository contains multiple crates like iroh, iroh-relay, iroh-base, etc., for different functionalities.
- Licensed under Apache 2.0 or MIT, with contributions dual-licensed.
Coccinelle for Rust progress report
10 months ago
- CoccinelleForRust project progress shared by Tathagata Roy in collaboration with Inria and sponsored by Collabora.
- Coccinelle is a tool for automatic program matching and transformation, originally for C code, now being adapted for Rust.
- Example provided of a semantic patch to automate tedious code updates in Rust, replacing `expression.type_of(impl_id)` with `expression.type_of(impl_id).subst_identity()`.
- Complexity increases with function signature changes and related calls, demonstrated with a semantic patch example.
- Computational Tree Logic (CTL) is central to Coccinelle, adapted for Rust with minor changes from the C version.
- Rust's expression-dominated nature makes matching and transformation more computationally intensive, leading to optimizations like using `RefCell`s and hash tables.
- SmPL parser development leverages Rust Analyzer for parsing Rust constructs, focusing on custom syntax like ellipses and disjunctions.
- Challenges with transforming macros due to their non-standard nature, supporting only function-like macros.
- Current focus is on matching Coccinelle For Rust's functionalities with Coccinelle For C, with ongoing work on pretty printing and other features.
- CoccinelleForRust is available on Gitlab, with an invitation for feedback and questions.
Subsecond: A runtime hotpatching engine for Rust hot-reloading
10 months ago
- Subsecond is a Rust library enabling hot-patching for running applications without restarting, useful for game engines and servers.
- Features ThinLinking for faster Rust compilation in development mode.
- Usage involves calling functions with `subsecond::call` for automatic detouring to the latest version.
- Requires a third-party tool like Dioxus CLI for loading patches, installed via `cargo binstall dioxus-cli`.
- Operates via a jump table for function calls, avoiding direct memory modification for safety.
- Currently supports patching only the 'tip' crate, with future plans for full workspace support.
- Supports hot-reloading of globals, statics, and thread-locals with noted limitations.
- Does not support hot-reloading of structs due to layout and alignment constraints.
- Includes ThinLink, a fast linker for Rust, integrated into Dioxus CLI.
- Platform support includes major OSes and WebAssembly, with some limitations like iOS devices.
- Encourages framework authors to indicate Subsecond support with a badge.
- Licensed under MIT, with support options via GitHub sponsorship.
uv: An extremely fast Python package and project manager, written in Rust
10 months ago
- uv is an extremely fast Python package and project manager written in Rust.
- It replaces multiple tools like pip, pip-tools, pipx, poetry, pyenv, twine, and virtualenv.
- Offers 10-100x faster performance compared to pip.
- Provides comprehensive project management with a universal lockfile.
- Supports running scripts with inline dependency metadata.
- Manages and installs Python versions.
- Runs and installs tools published as Python packages.
- Includes a pip-compatible interface for a familiar CLI with performance boost.
- Supports Cargo-style workspaces for scalable projects.
- Disk-space efficient with a global cache for dependency deduplication.
- Installable without Rust or Python via curl or pip.
- Supports macOS, Linux, and Windows.
- Backed by Astral, the creators of Ruff.
- Can update itself to the latest version if installed via standalone installer.
- Manages project dependencies and environments with lockfiles and workspaces.
- Supports building and publishing projects, even those not managed with uv.
- Executes and installs command-line tools provided by Python packages.
- Installs Python and allows quick switching between versions.
- Provides a drop-in replacement for common pip, pip-tools, and virtualenv commands.
- Extends interfaces with advanced features like dependency version overrides and reproducible resolutions.
- Licensed under Apache License 2.0 or MIT license.
Higher: Favourite Haskell type classes for Rust (2023)
10 months ago
- Introduction of functor hierarchy traits in Rust inspired by PureScript and Scala's Cats.
- Implementation challenges due to Rust's type system limitations, especially with constraints in trait implementations.
- Use of Generic Associated Types (GATs) to approximate higher kinded types, with noted limitations.
- Difficulty in implementing Functor for types like HashSet due to stricter bounds in implementations than in traits.
- Complications with Bind trait implementations and the need for explicit type annotations.
- Discussion on the limitations of GATs compared to higher kinded types and the impact on abstraction usability.
- The crate serves as an exploration of Rust's type system capabilities rather than a practical tool.
- Call for language improvements such as constraint kinds to better support functional programming abstractions.
I Switched from Flutter and Rust to Rust and Egui
10 months ago
- Personal experience shared about transitioning from Flutter to egui for UI development.
- Flutter and Rust integration was initially used with flutter_rust_bridge for generating bindings.
- Frustration with FFI issues and the complexity of managing two programming languages led to exploring egui.
- Egui was chosen for its simplicity and the impressive work seen in projects like rerun.
- Rewriting UI in egui over a weekend led to abandoning Flutter due to reduced complexity.
- Concerns about the readability and maintainability of generated code by flutter_rust_bridge.
- The project's scale didn't justify the complexity of Flutter, especially with a single developer.
- Egui's immediate UI refresh paradigm eliminated common Flutter issues like state management and UI not updating.
- Performance improvement noted in the Rust-only application, possibly due to reduced overhead from FFI.
- Encouragement for support towards BoquilaHUB, focusing on AI for biodiversity.
Show HN: Rust ↦ WASM, K-Means Color Quantization Crate for Image-to-Pixel-Art
10 months ago
- Pixel-art converter available at https://gametorch.app/image-to-pixel-art
- Free, no sign-up required, runs entirely in the browser
- Uses Rust → WebAssembly to convert images to low-color pixel-art
- Features include K-means palette extraction, transparency handling, and down-sampling
- Public API allows for palette specification and returns PNG-encoded bytes
- Requires Rust nightly or stable (≥ 1.70) and wasm-pack for compilation
- Can compile directly via Cargo with specific backend flags
- Output includes WebAssembly binary and JavaScript wrapper
- Example usage provided for integrating into web projects
- Project released under MIT license, developed quickly with o3
Rust 1.88.0
10 months ago
- Rust 1.88.0 has been released, featuring new capabilities and improvements.
- Introduction of 'Let chains' in Rust 2024 edition, allowing &&-chaining of let statements in if and while conditions.
- Support for naked functions with #[unsafe(naked)] attribute, offering full control over assembly generation.
- Boolean configuration in cfg predicates now supports true and false literals for clearer conditional compilation.
- Cargo introduces automatic cache cleaning to manage disk usage by removing old, unused files.
- Several APIs have been stabilized, including Cell::update, HashMap::extract_if, and more.
- The i686-pc-windows-gnu target has been demoted to Tier 2, potentially affecting future testing and bug fixes.
- Encouragement for users to test future releases via beta or nightly channels and report bugs.
Show HN: A Python Language Server, Mypy-compatible
10 months ago
- A Mypy-compatible Python Language Server built in Rust.
- Standards-compliant with a fully featured type system.
- Unparalleled performance: 20-200x faster than Mypy with optimized memory usage.
- Currently supports diagnostics; features like completions and go-to-definition are in development.
- Developed by the creator of Jedi, leveraging 14 years of Python auto-completion and static analysis experience.
- Alpha release with some expected false positives; beta release coming soon.
- Works in VSCode, Vim, and all other LSP-compatible editors including Helix, NeoVIM, SublimeText, Emacs, Zed, etc.
- Key features: Mypy config compatibility, error recovery, incremental checking, file watching, Python 3.13 support.
- Advanced code understanding: passes >95% of Mypy's tests, supports various imports, type narrowing, and more.
- Performance optimized: written in Rust, significantly faster than Mypy, minimal memory usage.
- Comprehensive type system support including TypeVar, Overloads, Dataclasses, Protocols, Literal Types, and more.
- Includes executables: zubanls (language server) and zmypy (Mypy replacement), compatible with Linux, Mac, and Windows.
- Free during alpha; pricing post-alpha based on code size—free for most users, paid for large codebases.
- Built by David Halter, founder of Jedi, addressing speed limitations in existing tools.
- Aimed at professionals needing precision, reliability, and speed; future support for Django, LSP features underway.
- Initial 2025 release may not cover all needs; open to feature requests based on real-world demand.
Weird Expressions in Rust
10 months ago
- Rust's type system allows for some unusual expressions, demonstrated in the `weird-expr.rs` test file.
- The `never` type (`!`) can coerce into any other type, enabling expressions like `return true` assigned to a boolean.
- Examples include using `return` in place of `()` in function parameters and returning `while` loops.
- Rust's weak keywords, like `union`, allow for creative naming in certain contexts.
- Range syntax (`..`, `..=`) can be combined in various ways, all implementing `Debug`.
- Assignment expressions can be chained with empty tuples (`()`), showcasing Rust's flexibility.
- Unicode characters can be used for identifiers, bypassing keyword restrictions.
- The `Deref` trait enables recursive function calls through smart pointer-like behavior.
- Match guards can include nested `if` statements, and patterns can be chained with `|`.
- The `matches!` macro and wildcard patterns allow for complex, albeit unconventional, logic.
Sniffnet v1.4: it's 2X faster than Wireshark at processing PCAP files
10 months ago
- Sniffnet v1.4 is now available with major improvements and fixes.
- New feature: ability to process network data from PCAP files, enhancing compatibility with tools like Wireshark.
- PCAP file support enables inspection of historical data for troubleshooting and network forensics.
- Demonstrated processing speed: 1.6 GB PCAP file (2.6M packets) in ~25 seconds on an old MacBook Air.
- Sniffnet is 2.2x faster than Wireshark on the same machine and allows real-time data preview.
- Performance boost due to Rust programming language and minimal parsing of packet headers.
- New features include ARP protocol support, donut chart for traffic stats, and bogon IP tagging.
- Enhanced accessibility with new default themes and detailed notifications.
- Focus on extracting key packet header fields (IPs, ports, protocols) for efficiency.
Rust in the Linux kernel: part 2
10 months ago
- Fujita Tomonori wrote a Rust version of the Asix AX88796B embedded Ethernet controller driver in 2023, serving as a simple example for comparing Rust and C in the kernel.
- The Rust driver starts with legalities and documentation comments, followed by a `use` statement for importing necessary modules from the kernel crate.
- A macro `kernel::module_phy_driver!` is used to set up symbols for the PHY driver, similar to C's `module_phy_driver()` macro.
- Constants `BMCR_SPEED100` and `BMCR_FULLDPLX` are defined in Rust, with explicit type annotations and casts from C-defined constants.
- A shared function `asix_soft_reset` demonstrates Rust's error handling with `Result` and the try operator `?`, contrasting with C's error propagation.
- The main driver for AX88796B is implemented as an empty structure `PhyAX88796B` with a `Driver` trait implementation, using `#[vtable]` to interface with C's PHY driver infrastructure.
- The article concludes with a summary comparing steps to implement a PHY driver in C versus Rust, highlighting Rust's trait system and macro usage.
The Complete Rust Security Handbook
10 months ago
- Rust provides memory safety but requires discipline for application security.
- The Security Trinity: Type Safety, Error Safety, Secret Safety.
- Use semantic types to prevent bugs like transferring money to the wrong place.
- Avoid panics in financial systems to prevent DoS attacks.
- Handle overflows explicitly to avoid silent money corruption.
- Use cryptographic randomness for security-critical operations.
- Zeroize secrets to prevent them from lingering in memory.
- Avoid logging sensitive information.
- Use parameterized queries to prevent SQL injection.
- Offload CPU-intensive work to thread pools in async contexts.
- Release locks before await points to prevent deadlocks.
- Ensure cancellation safety in async operations.
- Verify authorization and ownership in smart contracts.
- Use deterministic functions in blockchain contexts.
- Document safety invariants for unsafe blocks.
- Enable security-focused compiler and build settings.
- Write property-based tests to verify security invariants.
- Implement layered security checks in critical functions.
- Follow best practices for secure Rust development.
Error Handling in Rust
10 months ago
- Current standard in Rust is to define one error enum per module or crate, covering all possible error cases.
- This approach leads to large error enums that include variants not relevant to all functions, complicating error handling.
- Alternative philosophy suggests representing errors as independent structs rather than enum variants, exemplified by the 'terrors' crate.
- The 'error_set' crate offers a more concise way to define error enums for functions, with automatic trait implementations for conversions.
- The 'error_set' crate supports error sets from variants and unions, working seamlessly with the '?' operator.
- Other libraries like 'SmartErr' explore different paradigms in error handling, including automatic error enum generation based on function bodies.
Maestro now supports gcc
10 months ago
- Maestro now supports gcc and g++, enabling C and C++ application development.
- Successfully tested with an obfuscated C program (donut.c) demonstrating basic functionality.
- Cross-compilation process detailed, involving multiple stages to build gcc for Maestro.
- Program loading in Maestro involves mapping ELF segments, allocating stack, and handling auxiliary vectors.
- Future goals include porting essential development tools (git, make, rustc) and adding SMP support.
- Plans for 2026 include developing a desktop environment, potentially with Wayland support.
Rust CLIs with Clap
10 months ago
- Types in Rust provide a contract between system parts, enhancing developer experience with strong, static typing.
- Rust's type system is ideal for CLI tools, contrasting with dynamically typed languages like Python and Node.js.
- Clap, a Rust crate, simplifies CLI argument parsing, offering features like argument validation and built-in help.
- Using Clap's derive feature allows defining CLI interfaces with Rust types, improving maintainability and readability.
- Type-driven CLI design reduces test surface area and supports mocking for unit tests.
- Semantic versioning (SemVer) is crucial for CLI tools, similar to libraries, to avoid breaking changes.
- Clap supports environment variables, integrating them seamlessly into the CLI interface.
- Automated SemVer checks via GitHub Actions can prevent unintended breaking changes in CLI tools.

first prev8next

About|Login

#rust

Announcing the Clippy feature freeze

Show HN: Ariadne – A Rust implementation of aperiodic cryptography

Snow - Classic Macintosh emulator

Writing a basic Linux device driver when you know nothing about Linux drivers

Iroh: A library to establish direct connection between peers

Coccinelle for Rust progress report

Subsecond: A runtime hotpatching engine for Rust hot-reloading

uv: An extremely fast Python package and project manager, written in Rust

Higher: Favourite Haskell type classes for Rust (2023)

I Switched from Flutter and Rust to Rust and Egui

Show HN: Rust ↦ WASM, K-Means Color Quantization Crate for Image-to-Pixel-Art

Rust 1.88.0

Show HN: A Python Language Server, Mypy-compatible

Weird Expressions in Rust

Sniffnet v1.4: it's 2X faster than Wireshark at processing PCAP files

Rust in the Linux kernel: part 2

The Complete Rust Security Handbook

Error Handling in Rust

Maestro now supports gcc

Rust CLIs with Clap