Bilingual

Vibe Coded X11 Server Written in Rust Adds Xinerama, FreeBSD Support
23 days ago
- YSERVER, a modern X11 server written in Rust with AI assistance, has released version 1.3.
- Recent additions include FreeBSD support, Xinerama extension, direct mode VT switching, display hotplug, and more X11 extensions.
- Compatible with desktop environments like MATE, Xfce, and Cinnamon, and window managers such as Compiz, Openbox, and Awesome.
- Tested on hardware ranging from AMD and Intel to Snapdragon and Apple Silicon graphics.
- Developments and source code are available on GitHub.
It's not me, it's the compiler
25 days ago
- A programmer discovered a compiler bug in Rust while refactoring a JavaScript engine's parser.
- The bug was in a function where using 'x as u32' for boolean addition caused incorrect behavior, but using an explicit if-else worked.
- Assembly inspection confirmed the compiler omitted an increment instruction, leading to a miscompilation.
- The issue was reported as 'Suspected miscompilation' and quickly fixed within 18 hours by the Rust community.
- The bug was classified as p-critical and i-miscompile, highlighting rare but serious compiler errors.
Read Rust Like a Chinese Character
20 days ago
- Author transitioned from Python to Rust after experiencing Python's limitations in production contexts, viewing them as non-ideal use cases rather than language flaws.
- Rust appealed as a compiled, memory-safe systems language that is fast, modern, and philosophically opposed to Python, suiting different production needs.
- The 'moonlanding' encounter with Rust's syntax involved confusion over 'if let Some(x) = optional_value {...}', which defies left-to-right reading assumptions from Python.
- Key discovery: 'Some()' is a variant of Rust's Option enum, representing a value that might exist, unlike Python enums that cannot hold data.
- Pattern matching in Rust allows syntactic consistency: the same syntax used to create data structures is used to unpack them, via 'mold and cast' logic.
- Comparison with Python's walrus operator (:=) shows similarity in combining assignment and evaluation, but Rust's if let integrates pattern matching directly into conditionals.
- Reading Rust requires treating certain statements as single visual concepts, like Chinese characters, rather than parsing left-to-right, to grasp pattern matching intuitively.
- Rust enums differ from Python dataclasses: enum variants are shapes within a single type, not separate types, necessitating if let for refutable patterns that may fail.
- The if let construct checks and extracts values simultaneously, verifying presence and safely unwrapping without manual calls, enhancing safety and readability.
Kani: A Model Checker for Rust
19 days ago
- Kani is an open-source model checker for Rust that performs bounded model checking to verify safety properties and functional correctness.
- It compiles Rust code from Mid-level Intermediate Representation (MIR) into CBMC's verification engine, automatically checking safety properties without user annotation.
- Kani provides a specification language with features like function contracts, loop contracts, quantifiers, and function stubbing to extend verification from bounded to unbounded domains.
- Case studies on industrial Rust projects demonstrate its feasibility, upgrading verification from panic-freedom to functional correctness and uncovering six previously unknown bugs.
- It scales in production CI, with over 16,000 harnesses verified per code change in the Rust standard library verification campaign.
Show HN: Nectar, a Rust-like React that compiles to WebAssembly
19 days ago
- Nectar compiles to WebAssembly with a single binary and zero dependencies, running the entire app in WASM while reducing JavaScript to a minimal 10 KB syscall layer.
- One Rust binary handles all development tasks including compilation, formatting, linting, testing, dev server, LSP, package management, and SSR, eliminating toolchain configuration.
- Features O(1) updates per binding without a virtual DOM, ensuring only exact DOM nodes update when signals change, and includes Rust-inspired safety features like a borrow checker and exhaustive pattern matching.
- Eliminates npm, node_modules, webpack, and bundlers by compiling apps to a .wasm binary and a 3 KB runtime, with common web patterns as language primitives.
- The same WASM binary runs on the server via wasmtime with built-in SSR, hydration, and deployment to 29 Cloud Run regions, compiling .nectar source to WebAssembly.
Fable 5 wrote a Windows kernel in 38 minutes
18 days ago
- The ntoskrnl-rs project successfully rewrote the Windows NT kernel in Rust, booting in QEMU and passing self-tests.
- Claude Fable 5 generated the core kernel (about 5,100 lines) in 38 minutes, including scheduling, memory management, and I/O subsystems.
- The kernel loads unmodified Windows drivers and binaries, providing a sandbox for analysis and debugging.
- Verification remains a bottleneck, as AI-authored code requires extensive testing for trust and correctness.
- Model choice matters: Fable excelled at greenfield generation, while Opus handled iterative debugging and security work.
- This demonstrates AI's potential to rewrite legacy critical infrastructure, reducing costs and memory-safety bugs.
Making My Rust Program Space-Flight Ready
11 days ago
- A Rust crate called 'hugebool' introduces a 16-byte 'Booléan' type for radiation hardening.
- The 'Booléan' uses bit patterns (like alternating 0x55 and 0xAA) to make single-bit flips detectable and repairable via nearest-match decoding.
- Triple modular redundancy is implemented with a generic 'Rad' struct for voting and scrubbing, protecting any 'Eq + Copy' type.
- Benchmarks show hardened reads (e.g., with voting and scrubbing) are about 12 times slower than plain bool reads, but still fast (195 million per second).
- Limitations: protection only applies to heap-allocated data, not registers, instruction pointers, or other system components, unlike specialized hardware like the RAD750.
- The approach leverages Rust's type system to turn silent hardware errors into detectable ones, offering a cost-effective alternative for critical systems.
'Rust makes coding fun again': Why Linux is moving away from C
10 days ago
- Linux stable kernel maintainer Greg Kroah-Hartman announced that Linux and other projects like Git are moving toward Rust.
- Rust is considered safer than C and helps eliminate common vulnerabilities like unchecked pointers and forgotten unlocks.
- Kroah-Hartman estimates that 80% of kernel CVEs would be caught by Rust, allowing maintainers to focus on logic bugs instead.
- Rust is becoming the default for new work in key subsystems, with some drivers only accepted in Rust.
- The Linux kernel will not be rewritten in Rust, but new code in subsystems like graphics will be Rust-only.
- Rust has influenced improvements in C code by introducing safety mechanisms like guards and scoped allocation.
- Kroah-Hartman emphasized that Rust makes coding fun by reducing worries about memory safety and locking issues.
- The Rust experiment in the Linux kernel is now considered official and no longer an experiment.
- Kroah-Hartman highlighted that Rust benefits both maintainers by easing review workload and users by enhancing security.
What can we learn from Bun's rapid Rust rewrite with AI?
9 days ago
- Bun was rewritten from Zig to Rust in 11 days using AI (Claude's Fable), costing $165,000, which shortened a potential 1-2 year manual migration.
- The primary motivation for the rewrite was to eliminate memory-related bugs (e.g., memory leaks, use-after-free) in Zig, as Rust provides memory safety and compiler-enforced guarantees.
- The migration process involved: prep work with a porting guide, adversarial reviews, parallel AI agents (64 total), and iterative fixing of compiler errors and test failures.
- Success factors included having a motivated engineer familiar with the codebase, a robust test suite, and willingness to invest in AI tokens.
- This demonstrates how AI can enable previously impractical rewrites or migrations, potentially transforming engineering workflows for complex projects.
Tested Kimi K3 for Coding
5 days ago
- The user tested the new Kimi K3 model by asking it to optimize a Rust function, specifically exploring SWAR (SIMD Within a Register) optimization.
- Kimi K3 completed the optimization task perfectly in about 15 minutes, resulting in a 2% speed improvement in the program.
- The user found Kimi K3 to be near-frontier level quality as claimed, costing approximately $1 for tokens on OpenRouter.
Converting Files into Minecraft Worlds
5 days ago
- The core idea is to convert any file into a Minecraft world by mapping each byte to a block.
- A palette maps 256 byte values to blocks, excluding blocks with age/level states (like crops) and multi-block entities (beds, chests).
- Blocks are placed in a 16x16x16 section, filling a full chunk column (24 sections) from Y=-64 to Y=320, then moving to the next chunk horizontally.
- A region file (.mca) can store up to ~96 MiB of data from 32x32 chunks.
- Encoding reads the file, writes a header (magic + original size), then places each byte's block at calculated coordinates.
- Decoding reads the header to get the original size, then reads the blocks and converts them back to bytes.
- Initial mistakes included a flat slab layout that only used 16 blocks of height (reducing capacity), misreading the .mca header causing a 2.3 exabyte size error, and invisible blocks from beds/chests.
- Future plans include adding creeper/TNT protection and supporting multi-region worlds for arbitrarily large files.

Hasty Briefsbeta

rust programming

Vibe Coded X11 Server Written in Rust Adds Xinerama, FreeBSD Support

It's not me, it's the compiler

Read Rust Like a Chinese Character

Kani: A Model Checker for Rust

Show HN: Nectar, a Rust-like React that compiles to WebAssembly

Fable 5 wrote a Windows kernel in 38 minutes

Making My Rust Program Space-Flight Ready

'Rust makes coding fun again': Why Linux is moving away from C

What can we learn from Bun's rapid Rust rewrite with AI?

Tested Kimi K3 for Coding

Converting Files into Minecraft Worlds