Hasty Briefsbeta

All tags

#rust

595 stories total

Bilingual

Show HN: Munal OS: a graphical experimental OS with WASM sandboxing
a year ago
- Munal OS is an experimental operating system written entirely in Rust with a unikernel design.
- It features a fully graphical interface in HD resolution with mouse and keyboard support.
- Applications are sandboxed using WASM, ensuring security and memory separation.
- The OS includes a network driver, TCP stack, and a customizable UI toolkit.
- Embedded applications include a web browser, text editor, and Python terminal.
- Munal OS does not implement traditional OS features like bootloaders, page mapping, virtual address space, or interrupts.
- It runs as a single EFI binary, utilizing UEFI boot services minimally.
- The OS relies on VirtIO drivers for input, network, and GPU, making it currently limited to QEMU.
- Performance is monitored via a global event loop, with cooperative scheduling for applications.
- The UI toolkit, Uitk, supports immediate mode rendering and basic widgets with customizable styling.
- Munal OS uses Wasmi for WASM execution, providing a custom system call API instead of WASI standards.
- The project is built with Rust Nightly 2025-06-01 and requires specific Rust components for compilation.
- Acknowledgments include Philipp Oppermann's Rust OS tutorial and various open-source projects.
Rust compiler performance
a year ago
- Rust developers frequently complain about slow compilation times and the slow feedback loop.
- The Rust Project does care about compiler performance, with weekly performance triages, comprehensive benchmarking, and continuous efforts to improve speed.
- Compilation performance has improved significantly over the years, with benchmarks showing up to 1.77x speedup in clean builds.
- Despite improvements, Rust's compilation times are still a bottleneck for many developers, especially compared to languages like Python.
- Achieving near-instant rebuilds in Rust is challenging due to its complex type system, borrow checking, and other features.
- Potential solutions include parallel frontend, alternative codegen backends, smarter incremental compilation, and faster linkers.
- Technical challenges include the complexity of the Rust compiler codebase, trade-offs in optimizations, and maintaining backward compatibility.
- Prioritization is an issue, as the Rust Project must balance performance improvements with stability, new features, and other priorities.
- Contributors to Rust are mostly volunteers with diverse interests, and not all focus on performance optimizations.
- Funding and long-term investment in compiler performance could accelerate improvements, but maintaining contributions is crucial.
- Future initiatives include making LLD the default linker on Linux and running a compiler performance survey to identify bottlenecks.
A Plan for SIMD
a year ago
- Raph Levien outlines a plan for SIMD in Rust, aiming to make SIMD programming ergonomic and safe.
- The plan builds on previous discussions and aims to support a wide range of CPUs with fine-grained levels, including SSE 4.2 and AVX-2.
- Key goals include lightweight dependency, fine-grained SIMD levels, and support for a full cartesian product of SIMD widths and types.
- The proposal suggests using code generation to reduce boilerplate and improve compile times, moving away from heavy macro use.
- Explicit vs. variable width SIMD programming is discussed, with a preference for explicit widths for Linebender projects.
- The plan includes support for WASM SIMD and considers future work on embedded SIMD extensions like RVV and SVE.
- Feedback is encouraged via Zulip threads and the fearless_simd repository, with ongoing development focused on Vello's CPU and hybrid renderers.
R9: Plan 9 in Rust
a year ago
- R9 is a reimplementation of the Plan 9 kernel in Rust, derived from the original Plan 9 source code.
- The kernel is built using Cargo and the xtask pattern.
- To build for x86_64: `cargo xtask build --arch x86-64`.
- To build for aarch64 (Raspberry Pi 3 supported): `cargo xtask build --arch aarch64`.
- Use `cargo xtask help` to see available subcommands.
- R9 is not yet self-hosting.
- `cargo xtask dist` requires `llvm-objcopy`, installable via `rustup component add llvm-tools`.
- If `llvm-objcopy` issues persist, install LLVM separately and set `OBJCOPY`.
- Ensure `qemu` or `qemu-kvm` is installed for running R9 in QEMU.
- Supported QEMU architectures include aarch64 (raspi3b/4b), x86-64 (q35), and riscv64 (virt).
- R9 has been tested on Raspberry Pi 4 (prints 'r9' via miniuart).
- For netboot, use `cargo xtask dist --arch aarch64 --verbose` and copy the binary to a TFTP server.
- Raspberry Pi firmware uses `config.txt` to configure UART (e.g., `enable_uart=1`).
Kernel Memory Safety: Mission Accomplished
a year ago
- The CrowdStrike outage in 2024 highlighted vulnerabilities in mature OSes due to memory-safety bugs.
- Asterinas is a Rust-based framekernel OS designed to achieve complete kernel memory safety with a minimal Trusted Computing Base (TCB).
- The framekernel architecture combines the performance of monolithic kernels with the security of microkernels, confining unsafe code to a small, auditable core.
- OSTD, the OS framework for Asterinas, provides safe abstractions for kernel development, enabling features like system call handling in safe Rust.
- Asterinas supports over 210 Linux system calls, multiple CPU architectures, file systems, sockets, and devices, all while maintaining competitive performance.
- The TCB in Asterinas is approximately 15,000 lines of code, significantly smaller than other Rust-based OSes, and is amenable to formal verification.
- Future plans for Asterinas include support for Linux namespaces, cgroups, a graphics subsystem, and ARM architecture, aiming for production readiness.
- Asterinas is open-source and welcomes contributors to help advance memory-safe OS development.
Show HN: Zeekstd – Rust Implementation of the ZSTD Seekable Format
a year ago
- Rust implementation of the Zstandard Seekable Format.
- Splits compressed data into independent frames for efficient decompression.
- Zeekstd updates the seekable format while maintaining compatibility.
- Encoder starts new frames at 2MiB of uncompressed data by default.
- Decoder can decompress all frames or specific frames as configured.
- Includes a CLI tool utilizing the library.
- zstd C library is dual licensed under BSD/GPLv2.
- Zeekstd is licensed under BSD 2-Clause.
Retrobootstrapping Rust for some reason
a year ago
- Rust's initial compiler, rustboot, was written in OCaml and emitted 32-bit i386 machine code.
- The transition to rustc (using LLVM) involved a bootstrap process: stage0 (rustboot on rustc), stage1 (stage0 on rustc), and stage2 (stage1 on rustc) for verification.
- Bitrot issues complicate retrobootstrapping due to changes in tools, compilers, and libraries over 14 years.
- Debian's EOL Docker images provide a viable environment for retrobootstrapping Rust's initial bootstrap and fixpoint.
- The correct Rust commit for the fixpoint is 6daf440037cb10baab332fde2b471712a3a42c76 from April 2011.
- LLVM version 45e1a53efd40a594fa8bb59aee75bb0984770d29 (or equivalent SVN commit) is required for compatibility.
- Performance observations: stage0 (rustboot) was faster to build but produced slower code, with LLVM providing a 2x speed boost at 3x the binary size.
- Modern Rust's bootstrap is slower due to increased codebase size (600kloc vs. initial 25kloc).
Bzip2 crate switches from C to 100% rust
a year ago
- bzip2 crate version 0.6.0 now uses a Rust implementation (libbz2-rs-sys) by default, improving performance and cross-compilation.
- The Rust implementation generally outperforms the C version, especially in compression, with significant speedups.
- Cross-compilation is simplified with the Rust implementation, eliminating issues with C dependencies, especially for WebAssembly, Windows, and Android.
- Symbols are not exported by default in libbz2-rs-sys, preventing conflicts with other dependencies, though a feature flag allows exporting if needed.
- The Rust implementation allows running tests with MIRI, enabling safer use of unsafe code and higher-level libraries.
- An audit found one logic bug (off-by-one error) and improved the fuzzer, with no other significant issues.
- The update is a maintenance win, making the bzip2 crate faster and easier to use without needing to think about underlying complexities.
Show HN: Lstr – A modern, interactive tree command written in Rust
a year ago
- Fast directory scanning with parallel processing for speed.
- Minimalist design focusing on essential features.
- Interactive TUI mode for keyboard-driven exploration.
- High-performance with optional rich information display (icons, permissions, sizes).
- Git integration to show file statuses directly in the tree.
- Smart filtering respects .gitignore and allows control over recursion depth.
- Classic and interactive modes cater to different user preferences.
- Shell integration for visual directory changing (lcd function).
- Compatibility with other CLI tools via piping (e.g., fzf, less, bat).
- Customizable thread usage for directory scanning with RAYON_NUM_THREADS.
Show HN: ht-mcp – a Rust MCP server of headless terminal for agents
a year ago
- Pure Rust implementation of Model Context Protocol (MCP) server for headless terminal ht.
- Single binary with no external dependencies.
- Direct integration with ht headless terminal library for optimal performance.
- Supports concurrent terminal session management.
- Optional live terminal preview via web interface.
- Available for macOS (Intel/Apple Silicon), Linux, and Windows.
- Installable via Homebrew, crates.io, or GitHub releases.
- Includes commands for session management, keystroke sending, and terminal state capture.
- 40x faster startup and 70% less memory compared to TypeScript implementation.
- Apache 2.0 License, contributions welcome.
Fast multiplayer 3D renderer, written in Rust
a year ago
- Client-server 3D renderer with real-time player movement and view synchronization.
- Built with Rust, OpenGL, and SDL2.
- Features n-tick rate server (default: 128 ticks/sec).
- Supports multiplayer with unlimited capacity.
- Basic lighting: ambient, diffuse, and specular.
- Includes back-face culling.
- Current issues: server instability with 3+ connections, needs documentation improvements.
- Future improvements: client-side server interpolation, culling techniques (frustum & occlusion), instanced-based rendering, AABB-based collision.
- Repository available at: https://github.com/splurf/blazed-demo.
- Requires SDL2 configuration before compiling the client.
- Client and server can be run with cargo commands.
- Client usage options include FPS settings, offline mode, and network address configurations.
- Server usage options include TCP/UDP address settings and ticks per second (TPS) configuration.
Show HN: Kentro – a fast Rust library for K-Means clustering
a year ago
- High-performance Rust implementation of K-Means clustering algorithms.
- Supports standard K-Means, Spherical K-Means, Balanced K-Means, and K-Medoids.
- Parallel processing support using Rayon for multi-threaded execution.
- Flexible API with builder pattern for easy configuration.
- Memory efficient and optimized for large datasets.
- Comprehensive error handling with detailed error types and messages.
- Includes examples for basic, balanced, medoids, and text clustering.
- Automatically uses all available CPU cores for cluster assignment.
- Designed for high performance with minimal memory allocations.
- Licensed under the Apache 2.0 License.
Show HN: A DOS-like hobby OS written in Rust and x86 assembly
a year ago
- RoureXOS operating system has a second iteration rewritten in Rust.
- The OS can be run using an ISO image in QEMU emulator or on x86_64 baremetal.
- Installation requires Rust and dependencies like `xorriso`, `net-tools`, and `grub2-tools`.
- Commands provided for compiling the kernel, bootloader, and creating an ISO image.
- QEMU emulation can be run with ISO or floppy image.
- Alternative method to run the kernel exclusively using `cargo bootimage`.
- Steps to get pty number in stdout and set up SLIP packets for network interface.
- Instructions to catch packets using `tcpdump`.
Rewriting Kafka in Rust
a year ago
- Rewriting Kafka in Rust leverages Rust's advantages for superior performance and efficiency.
- Avoid turning functions into async unless necessary to minimize overhead and task proliferation.
- Minimize the number of Tokio tasks to reduce CPU cache thrashing and scheduling overhead.
- Favor lock-free architectures and minimize the use of Tokio async locks to enhance performance.
- Use unsafe code judiciously in performance-critical paths, ensuring encapsulation and thorough testing.
- Separate mutable and immutable data to optimize lock granularity and reduce contention.
- Distinguish between asynchronous and synchronous data operations to optimize lock usage.
- Employ static dispatch in performance-critical paths to avoid runtime overhead.
- Design experience includes connection-per-task models, centralized request processing, and worker recovery.
- StoneMQ was developed with exacting standards to outperform Kafka while maintaining readable code.
A real fixed-point decimal crate in Rust
a year ago
- Rust's built-in f32 and f64 types have drawbacks: they can't accurately represent decimal numbers in base 10 and don't guarantee fraction precision.
- This crate provides fixed-point decimal types using integer types with a scaling factor in base 10 for accuracy and static scale binding for precision.
- Two types of fixed-point decimals are offered: ConstScaleFpdec (scale specified via const generics) and OobScaleFpdec (scale managed out-of-band).
- Operations like +, -, and comparisons are restricted to same types and scales, ensuring type safety and performance, while * and / allow different scales with specified result scales.
- The crate addresses cumulative error in operations like transaction fees through a cum_error parameter, improving precision in financial calculations.
- Supports no_std and optional serde integration for serialization/deserialization.
- License: MIT.
Asterinas: A new Linux-compatible kernel project
10 months ago
- Asterinas is a new Linux-ABI-compatible kernel project written in Rust, developed at SUSTech in China.
- It introduces a 'framekernel architecture' combining aspects of monolithic and microkernel designs for safety and efficiency.
- The core idea is encapsulating unsafe Rust code in a library, allowing the rest of the kernel to use safe abstractions.
- Asterinas aims for a small, formally verified Trusted Computing Base (TCB) while maintaining Linux compatibility.
- The project is collaborating with CertiK for formal verification using Verus.
- Asterinas supports x86 and RISC-V architectures, with 206 Linux system calls implemented (out of 368 in Linux 6.7).
- It includes OSTD (a Rust OS framework) and OSDK (a Cargo addon for kernel development).
- Primary focus is on cloud computing, particularly for Alibaba Cloud in China, with plans for container host OS support.
- Unlike Rust for Linux, Asterinas builds a new kernel from scratch rather than adding Rust to Linux.
- The project is in early development with no official releases yet, but shows promise for OS innovation.
Fast Rust Builds (2021)
10 months ago
- Rust code is known for slow compilation, but projects like rust-analyzer show it's possible to maintain reasonable build times with care.
- Build times are crucial for productivity, acting as a multiplier on development speed and affecting mental flow and context switching.
- The 'silver bullet' for managing build times is continuous attention and optimization before they become a problem.
- CI time is a valuable metric for build performance, offering standardized feedback and encouraging healthy practices like using merge robots (e.g., bors).
- Effective CI caching strategies focus on rarely changing dependencies rather than the entire target directory to optimize build times.
- Reducing dependencies and critically evaluating each one's necessity can significantly decrease build times.
- Tools like `cargo -Z timings` and `cargo llvm-lines` help profile and optimize compilation by identifying bottlenecks and redundant instantiations.
- Architecting Rust projects with a clear crate dependency graph can enhance parallelism and reduce compilation times.
- Avoiding excessive use of procedural macros and generics at crate boundaries can prevent unnecessary compilation overhead.
- Strategies like thin generic wrappers around non-generic implementations and minimizing the number of final artifacts can further optimize build times.
Minimal auto-differentiation engine in Rust (for educational purposes)
10 months ago
- Minimal automatic-differentiation engine written in Rust.
- Demo trains a tiny Multi-Layer Perceptron to learn the XOR function.
- Writes a rendered computation graph of a single Perceptron to graph.html.
- Example usage with Scalar objects for automatic differentiation.
- Scalar stores value, gradient, and operation details.
- Operator overloads and helpers build a directed acyclic graph.
- backward() propagates gradients recursively through the graph.
- Graph visualization with plot::dump_graph emits a D3.js HTML file.
How to write Rust in the Linux kernel: part 1
10 months ago
- Introduction to Rust in the Linux kernel and its differences from user-space Rust.
- Prerequisites for building Rust in the kernel, including required tools and versions.
- Configuration and build process for Rust code in the kernel, including makefile integration.
- Testing Rust code in the kernel using KUnit, Clippy, and doctests.
- Documentation and formatting tools for Rust code in the kernel.
- Upcoming topics in the series, including a comparison of C and Rust driver modules.
Publishing a Docker Container for MS Edit to the GitHub Container Registry
10 months ago
- Microsoft released Edit, a terminal text editor written in Rust with a retro MS DOS feel.
- Edit can be run on Apple Silicon Macs using a Docker container with an aarch64-linux-gnu build.
- Two Docker setups were tested: Ubuntu (glibc) and Alpine (with gcompat for musl compatibility).
- A multi-stage Dockerfile was created for Alpine to minimize the final image size.
- The Docker image was published to GitHub's Container Registry for public use.
- GitHub's Container Registry requires a Personal Access Token (PAT) with specific permissions.
- The final image can be run with a command that mounts the current directory as a workspace.
- A GitHub repository was created to host the Dockerfile and usage instructions.

first prev7next

About|Login

#rust

Show HN: Munal OS: a graphical experimental OS with WASM sandboxing

Rust compiler performance

A Plan for SIMD

R9: Plan 9 in Rust

Kernel Memory Safety: Mission Accomplished

Show HN: Zeekstd – Rust Implementation of the ZSTD Seekable Format

Retrobootstrapping Rust for some reason

Bzip2 crate switches from C to 100% rust

Show HN: Lstr – A modern, interactive tree command written in Rust

Show HN: ht-mcp – a Rust MCP server of headless terminal for agents

Fast multiplayer 3D renderer, written in Rust

Show HN: Kentro – a fast Rust library for K-Means clustering

Show HN: A DOS-like hobby OS written in Rust and x86 assembly

Rewriting Kafka in Rust

A real fixed-point decimal crate in Rust

Asterinas: A new Linux-compatible kernel project

Fast Rust Builds (2021)

Minimal auto-differentiation engine in Rust (for educational purposes)

How to write Rust in the Linux kernel: part 1

Publishing a Docker Container for MS Edit to the GitHub Container Registry