Hasty Briefsbeta

All tags

#rust

595 stories total

Bilingual

Experimental Tauri Verso Integration
a year ago
- Verso is a browser based on Servo, a Rust-based web browser rendering engine.
- Verso aims to simplify Servo's complex APIs, making it more accessible for developers.
- Servo's APIs are low-level and daunting, whereas Verso offers a more ergonomic and easier-to-use API.
- Tauri integrates with Verso through a custom runtime called tauri-runtime-verso, similar to tauri-runtime-wry.
- tauri-runtime-verso is not as feature-rich as Tauri's production backends but supports many functionalities like windowing and plugins.
- Future plans include pre-built Verso executables, more windowing features, and initialization scripts without temporary files.
- Customization unique to the Verso runtime is planned, including setting executable paths and window-specific features.
- The project is financially supported by NLNet through grants.
OxiCloud – lightweight alternative to Nextcloud file sharing (Rust)
a year ago
- OxiCloud was created as a simpler, faster alternative to existing file storage solutions like NextCloud.
- Features include a straightforward interface, lightweight design, responsive UI, and Rust-based performance.
- Optimized with Link Time Optimization (LTO) for maximum speed and efficiency.
- Supports English and Spanish interfaces with minimal setup required.
- System requirements include Rust 1.70+, PostgreSQL 13+, and at least 512MB RAM (1GB recommended).
- Follows Clean Architecture principles for easy extension and maintenance.
- Development workflow includes commands for building, testing, and optimizing the project.
- Future plans include user authentication, file sharing, WebDAV support, and more.
- Contributions are welcome, with guidelines provided in CONTRIBUTING.md.
- Licensed under MIT License, built by a developer seeking better file storage solutions.
Rust Any part 3: we have upcasts
a year ago
- The As-Any Hack was introduced three years ago to enable upcasting to supertraits in stable Rust.
- The hack addressed the issue where methods from the `Any` trait couldn't be used on a `dyn DebugAny`, despite `DebugAny` inheriting from `Any`.
- As of Rust 1.86, the issue is fixed, allowing direct use of `Any` methods like `downcast_ref` on `dyn DebugAny`.
- The fix means old workarounds like the As-Any Hack can be retired once the minimum supported Rust version (MSRV) is updated.
- An updated example of the `Extensions` struct demonstrates how to use the new functionality without the hack.
Xee: A Modern XPath and XSLT Engine in Rust
a year ago
- Xee is a modern implementation of XPath and XSLT in Rust, developed over the last two years.
- Xee includes a command-line tool for XPath queries and a Rust library for XPath queries from Rust.
- The project was initiated in 2023 with support from Paligo, aiming to modernize XML technologies.
- Xee implements XPath 3.1 and partially XSLT 3.0, offering a modern alternative to outdated libraries like libxml2 and libxslt.
- XML technologies, though no longer 'cool', remain widely used in formats like SVG, MathML, and document standards.
- Xee's architecture involves lexing, parsing, and compiling XPath and XSLT into bytecode for execution.
- The project faces challenges due to the extensive and deep specifications of XML technologies, spanning over 1800 pages.
- Xee's XPath 3.1 implementation is nearly complete, passing 20,130 out of 21,859 conformance tests.
- The author calls for contributors to help with further development, optimization, and expanding XSLT support.
- Xee aims to secure a future for XML technologies by providing a modern, open-source implementation outside the Java ecosystem.
Towards fearless SIMD, 7 years later
a year ago
- Rust's SIMD programming experience remains challenging despite progress, with all SIMD intrinsics marked as unsafe due to varying CPU support.
- Linebender projects are beginning to adopt SIMD for CPU/GPU hybrid rendering, color conversion, and 2D geometry primitives to maximize performance.
- Multiversioning is crucial for SIMD to handle different CPU capabilities, with approaches like the 'multiversion' crate and 'pulp' library being explored.
- Safety improvements are in progress, including proposals to make SIMD intrinsics safe under certain conditions and better runtime feature detection.
- Emerging trends like FP16 and AVX-512 are influencing SIMD development, with FP16 offering benefits for pixel values and AVX-512 introducing predication for efficient string operations.
- The 'std::simd' portable SIMD effort is ongoing but may not fully address the need for target-specific optimizations and multiversioning.
- Language evolution proposals aim to enhance Rust's SIMD support, making it safer and more ergonomic for developers.
- The goal is to foster community discussion and development of Rust's SIMD infrastructure to compete with solutions like Highway in C++.
Building a Linux Container Runtime from Scratch
a year ago
- The need for a new low-level container runtime arose from the limitations of existing tools like Kubernetes CRI, Bubblewrap, and util-linux's unshare, which are either too high-level or CLI-dependent.
- Styrolite was developed to offer a rich programmatic interface for spawning and managing containers with precision, combining the benefits of a clean Rust API with CLI-like rapid iteration.
- Linux containers are built on namespaces, which provide alternative views of system resources (e.g., mount, PID, IPC, user namespaces), allowing flexible but complex containerized environments.
- Styrolite unshares key namespaces (Mount, PID, IPC, User, Time, UTS) to create isolated environments, acknowledging Linux namespaces' limitations as security boundaries.
- The tool simplifies container creation with a programmatic interface, reducing errors and improving maintainability compared to CLI-based approaches.
- Styrolite is used in Edera Protect for secure microservices, application sandboxing (via styrojail), and custom CI/CD environments, offering fine-grained isolation and resource control.
- Designed for minimal overhead, Styrolite provides fast container initialization and explicit security controls, addressing namespace limitations with robust defaults.
- The project is open-source, encouraging community contributions through GitHub, issue reporting, and code/documentation improvements.
Just write a test for it
a year ago
- Author appreciates Rust for guiding towards best practices.
- Discusses issues with SQL migrations in the bors project during Google Summer of Code 2025.
- Highlights a bug where NOT NULL columns were added without DEFAULT values in populated tables.
- Describes the solution: using sqlparser crate to write a test detecting problematic SQL migrations.
- Emphasizes Rust's ecosystem and tooling for quickly implementing robust solutions.
- Mentions potential future improvements like testing migrations with non-empty databases.
Show HN: Await-Tree – Visualize Async Rust Task Execution in Real-Time
a year ago
- Async Rust Futures can be composed or nested for various control flows.
- The execution of async tasks can be visualized as a logical tree that changes over time.
- `await-tree` allows runtime dumping of the execution tree with annotated spans.
- Supports dynamic span customization with runtime `String` for better debugging.
- Handles complex async control flows and arbitrary `Future` topologies.
- Uses an arena-based data structure with zero extra `unsafe` code.
- Optional features include `serde` for serialization and `tokio` for runtime integration.
- Compared to `async-backtrace`, `await-tree` offers more flexibility and safety.
- Used in production by RisingWave, a distributed streaming database.
- Licensed under Apache License 2.0.
Rust on the Ferris Sweep
a year ago
- RMK is a keyboard firmware written in Rust, chosen for a Ferris Sweep keyboard.
- QMK, a C-based firmware, is mature but complex for custom keyboard designs.
- RMK lacks pre-made configurations, requiring users to define pin mappings and keymaps manually.
- Setting up RMK involves using `rmkit` to generate a template and configuring `keyboard.toml`.
- Pin mappings were derived from the PCB design due to incompatibility with QMK's mappings.
- Half-duplex UART communication was configured using RP2040's PIO feature, requiring a git version of RMK.
- A `vial.json` file was created for VIAL software compatibility, involving layout adjustments.
- Initial flashing issues were resolved by lowering the baud rate due to insufficient pull-up resistors.
- RMK is functional but lacks some advanced features like display support and per-key RGB.
- RMK is recommended for those familiar with firmware configuration and interested in Rust.
Show HN: Zxc – Rust TLS proxy with tmux and Vim as UI, BurpSuite alternative
a year ago
- Terminal-based intercepting proxy written in Rust with tmux and vim as user interface.
- Requires vim plugin for UI functionality with specific keybindings and commands per window/filetype.
- Windows include Interceptor, History, Repeater, and Addons, each a vim instance communicating via unix socket.
- Features disk-based storage, custom HTTP/1.1 parser, and supports HTTP/1.1 and WebSocket.
- Dependencies include tmux, vim (>8.2.4684), ffuf, sqlmap, and openssl.
- Installation involves copying binaries, generating keys, and setting up vim plugins.
- Supports session management with flags for new sessions, attaching, port specification, and domain filtering.
- Interceptor window commands for toggling, forwarding, dropping requests/responses, and showing queue.
- History window records requests; closing halts recording but can be resumed.
- Repeater window for repeating requests with commands for sending and establishing WebSocket connections.
- Addons window integrates tools like ffuf and sqlmap, with configurable commands and file prefixes.
- Configurable via global and per-session TOML files, with support for domain and content type filtering.
- Filetype-specific commands and highlights for history, request, and response files.
- Debugging enabled with -d flag, logging proxy and channel info to session logs.
- Future features may include host redirection, HTTP/2/3 support, and SOCKS.
Rust 1.86.0
a year ago
- Rust 1.86.0 introduces trait upcasting, allowing trait objects to be coerced to supertrait references.
- New `get_disjoint_mut` method enables safe mutable indexing of multiple elements in `HashMap` and slices.
- Safe functions can now be marked with `#[target_feature]`, with restrictions on their usage.
- Debug assertions for non-null pointers added for soundness in debug mode.
- The `missing_abi` lint now warns by default, encouraging explicit ABI specification.
- Deprecation warning issued for the `i586-pc-windows-msvc` target, to be removed in Rust 1.87.0.
- Several APIs stabilized, including `{float}::next_down`, `{float}::next_up`, and `Vec::pop_if`.
- New const context stabilizations for APIs like `hint::black_box` and `str::split_at`.
Ferron – a fast, memory-safe web server written in Rust
a year ago
- Ferron is a fast, memory-safe web server written in Rust.
- High performance due to Rust’s async capabilities.
- Memory-safe design leveraging Rust's safety features.
- Modular architecture for easy customization and extensibility.
- Focus on robust security practices and safe concurrency.
- Components include `ferron` (main web server) and `ferron-passwd` (password hashing tool).
- Still a work in progress; installation instructions pending initial release.
- Repository can be cloned and explored: `git clone https://github.com/ferronweb/ferron.git`.
- Build and run using Cargo: `cargo build -r` and `cargo run -r --bin ferron`.
- Configuration properties and contribution details available in documentation.
- Licensed under the MIT License.
SpacetimeDB v1.0: Multiplayer at the speed of light
a year ago
- SpacetimeDB is a combined database and server system.
- It allows uploading application logic directly into the database via 'modules'.
- Clients connect directly to the database, eliminating the need for separate web or game servers.
- All application logic, including permissions and authorization, is written in Rust and deployed as a single binary.
- SpacetimeDB is optimized for real-time applications like games and chat, with low latency and high speed.
- It holds all application state in memory while persisting data in a write-ahead-log (WAL) for recovery.
- SpacetimeDB can be installed on macOS, Linux, and Windows via simple scripts or from source.
- The system is used in the MMORPG BitCraft Online for real-time data processing and synchronization.
- SpacetimeDB supports multiple programming languages for module development.
- It is licensed under BSL 1.1, converting to AGPL v3.0 with a linking exception after a few years.
BPF from Scratch in Rust
a year ago
- Yeet is a dynamic runtime for BPF programs on the Linux kernel.
- BPF (Berkeley Packet Filter) is a virtual machine that allows safe kernel behavior modification.
- The article demonstrates writing a minimal BPF program in Rust without macros or frameworks.
- The BPF program hooks into a tracepoint (sys_enter_nanosleep), increments a counter, and prints a message.
- The Rust toolchain is configured to target BPF with specific flags for debug info and BTF support.
- The example includes inline BPF assembly to interact with the kernel directly.
- Yeet provides a CLI and daemon (yeetd) to manage and run BPF programs dynamically.
- The program is registered and started using yeet commands, with output visible via trace logs.
- The article explains the BPF verifier and how the program passes its checks.
- Yeet offers a sandbox for safe BPF experimentation and a package manager for pre-made BPF packages.
Clawtype: Custom wearable chorded keyboard and mouse
a year ago
- Pixel art based on a design by IFeel_Attacked.
- Rust-embedded project for the SparkFun ProMicro RP2040 board.
- Variant of the Chordite keyboard.
- Structural design and 3D-printed parts from Clawtype by Cunfusu.
- Licensed under AGPL v3 or later.
- Contributions are licensed under AGPL-3.0 without additional terms.
A Year of Rust in ClickHouse
a year ago
- Rust integration into ClickHouse was initiated to leverage Rust's strengths without rewriting existing C++ code.
- Initial Rust component was the BLAKE3 hash function, later replaced by a C++ implementation from LLVM.
- Subsequent Rust additions included 'skim' for terminal improvements and PRQL as an alternative query language.
- Delta Kernel integration marked practical use of Rust for Delta Lake support, replacing sketchy C++ code.
- Challenges included supply chain security, complex C++/Rust interop, panic handling, and sanitizer integration.
- Cross-compilation and library linking issues were addressed to maintain ClickHouse's portability.
- Rust's composability with C++ conventions and dependency management required careful handling.
- Despite challenges, Rust integration is deemed successful, encouraging contributions from Rust developers.
Pitfalls of Safe Rust
a year ago
- Rust's memory safety is important but not sufficient for overall reliability.
- Common bugs in safe Rust include type casting mistakes, logic bugs, panics from unwrap/expect, malicious build.rs scripts, incorrect unsafe code, and race conditions.
- Tips to avoid common problems: protect against integer overflow, avoid 'as' for numeric conversions, use bounded types, don't index into arrays without bounds checking, use split_at_checked, make invalid states unrepresentable, avoid primitive types for business logic, handle default values carefully, implement Debug safely, be careful with serialization, protect against TOCTOU, use constant-time comparison for sensitive data, don't accept unbounded input, be aware of Path::join behavior with absolute paths, check for unsafe code in dependencies with cargo-geiger.
- Clippy can prevent many of these issues at compile time.
- Testing, linting, and fuzzing are still important in Rust for maximum robustness.
Show HN: I built a Rust crate for running unsafe code safely
a year ago
- mem-isolate runs functions in a forked process to ensure memory purity.
- It uses POSIX fork() for isolation, leveraging copy-on-write memory techniques.
- Supports Unix-like systems only (Linux, macOS, BSD); no Windows or wasm support.
- Use cases include running leaky, unsafe, or heap-fragmenting code safely.
- Overhead is ~1ms due to fork() and serialization, making it slower than direct calls.
- Benchmarks show ~1.9ms for execute_in_isolated_process() vs. ~1.5ns for direct calls.
- Dual-licensed under MIT or Apache 2.0.
Rauthy: OpenID Connect Single Sign-On Identity and Access Management
a year ago
- Rauthy is a lightweight OpenID Connect Identity Provider with secure defaults and flexible configuration options.
- It emphasizes Passkeys and strong security, written in Rust for efficiency and speed, suitable for IoT and CLI tools.
- Features include High-Availability, client branding, UI translation, Admin UI, Events, Auditing, and more.
- Supports two database options: embedded Hiqlite (default) or Postgres, with minimal memory footprint.
- Offers two login options: Password + Security Key or Passkey-Only Accounts with User Verification.
- Designed for low resource usage, can run on a Raspberry Pi, with extensive caching for performance.
- Includes an Admin UI and user account dashboard for self-management of passwords, passkeys, etc.
- Provides client branding options, event and alerting system, brute-force and DoS protection.
- Suitable for IoT projects with OAuth Device Authorization Grant flow and compatibility for headless devices.
- Benchmarks show capability to handle millions of users efficiently, with some limitations in user-search speed.
- Already in production, works with typical OIDC clients, and offers a wide range of features and configurations.
- Quick start available with Docker for local testing, includes insecure demo config for easy setup.
This Month in Redox – March 2025
a year ago
- Redox OS is a Unix-like microkernel-based operating system written in Rust.
- Redox Summer of Code (RSoC) 2025 is open for applications, seeking students with Rust and low-level software experience.
- Redox received an NLnet grant for Unix-style signals and process management, with significant progress made by 4lDO2.
- USB input support has been improved, with external testing encouraged for mice and keyboards.
- Kernel improvements include the SYS_CALL system call unification and legacy scheme path deprecation warnings.
- Driver improvements feature userspace RTC, NVMe async support, and USB xHCI updates.
- System improvements include deadlock fixes, init configuration unification, and environment variable cleanup.
- USB improvements include fixes for hub drivers, xHCI, and USB 3.x support.
- Scheme improvements include the implementation of the /pci/ scheme for PCI device management.
- RedoxFS now has a garbage collector for the allocation log.
- Relibc improvements include ARM64/RISC-V fixes, printf() enhancements, and strftime() updates.
- Networking improvements include CUBIC congestion control for better performance.
- Terminal improvements include getting terminal size from alternative file descriptors.
- Packaging improvements include pkgar updates and explicit permission error messages.
- Program updates include fixes for sudo, Vim, Git, and OpenSSL.
- Build system improvements include GNU Debugger support and QEMU fixes.
- Documentation improvements cover system call tracing and configuration settings.
- Daily images are available for testing, with server and desktop variants.

firstprev0next

About|Login

#rust

Experimental Tauri Verso Integration

OxiCloud – lightweight alternative to Nextcloud file sharing (Rust)

Rust Any part 3: we have upcasts

Xee: A Modern XPath and XSLT Engine in Rust

Towards fearless SIMD, 7 years later

Building a Linux Container Runtime from Scratch

Just write a test for it

Show HN: Await-Tree – Visualize Async Rust Task Execution in Real-Time

Rust on the Ferris Sweep

Show HN: Zxc – Rust TLS proxy with tmux and Vim as UI, BurpSuite alternative

Rust 1.86.0

Ferron – a fast, memory-safe web server written in Rust

SpacetimeDB v1.0: Multiplayer at the speed of light

BPF from Scratch in Rust

Clawtype: Custom wearable chorded keyboard and mouse

A Year of Rust in ClickHouse

Pitfalls of Safe Rust

Show HN: I built a Rust crate for running unsafe code safely

Rauthy: OpenID Connect Single Sign-On Identity and Access Management

This Month in Redox – March 2025