Bytes by ui.dev·11wFirefox is cooking again
Firefox 147 shipped with major web platform features including Navigation API, CSS Anchor Positioning, and View Transition upgrades after Mozilla backtracked on AI-focused plans following user backlash. The release also includes updates on Vercel RSC vulnerabilities, Yarn 6 rewrite in Rust, Expo SDK 55 beta dropping legacy architecture support, and Node.js 25.5 adding simplified Single Executable App building.
It's Foss·12wThis Could be the Best Graphics Editor for Linux Users (Yes, it is Open Source)
Graphite, an open-source Rust-based 2D graphics editor aiming to be the "Blender of 2D," has released its second desktop release candidate as a Flatpak for Linux. While previously only available in browsers, the desktop version offers similar functionality with better system integration, though users may need to disable UI acceleration to avoid blank window issues. The vector editing tools are mature, but raster editing remains experimental and disabled by default. Performance lags behind established tools like GIMP and Inkscape, particularly with smaller brush strokes, and the application is not yet stable enough for critical production work. The desktop build must be manually downloaded from the Graphite Discord and installed via Flatpak, with potential sandboxing considerations for file access.
MetalBear·13wHow Our Engineering Team Uses AI
MetalBear's engineering team shares practical experiences using AI coding tools while building mirrord, a Kubernetes development tool in Rust. AI proves most valuable for understanding unfamiliar code, exploring architectural alternatives, and generating scripts. It struggles with complex architectures and long-running reasoning tasks. The team finds ChatGPT most reliable for iteration, Gemini best for deep research but prone to losing context, and Claude Code somewhere in between. Success depends on scoping problems tightly and controlling context rather than which model is used. AI accelerates tedious and exploratory work but cannot replace deep system understanding.
SHAPeS·12wC++ and Rust
The Rust vs C++ debate has intensified, with Rust gaining adoption for its memory safety without performance costs. However, complete replacement may be unnecessary. Major projects like Chromium demonstrate that combining both languages strategically works well, using Rust for memory-critical components while maintaining C++ for other parts. Game engines and established codebases show C++ isn't easily replaceable. A pragmatic approach suggests both languages have distinct strengths and can coexist rather than one completely replacing the other.
DevOps Toolbox·14wThe Most Underrated IDE.
Zed is a Rust-based, open-source code editor from the Atom team that emphasizes speed and Vim-first design. It offers extensive out-of-the-box features including native Vim keybindings, built-in AI assistance with their own Zeta model, real-time collaboration, integrated debugging, terminal with AI help, and multi-cursor editing. The editor requires minimal configuration compared to Neovim, supports multiple AI providers, and includes a CLI utility. While not a complete Vim replacement, it provides a compelling alternative for developers seeking a fast GUI editor with strong Vim support and modern AI features at $10/month or free without AI.
All Things Open·14wPop!_OS 24.04 review: Was the two-year wait for COSMIC Desktop worth it?
Pop!_OS 24.04 ships with COSMIC Desktop, a new desktop environment built entirely in Rust by System76. The review covers installation, automatic window tiling, customizable panels and docks, and keyboard shortcuts. Despite being based on Ubuntu 24.04 LTS, the distribution maintains modern hardware support through backported kernels and current applications via Flatpak. COSMIC delivers fast performance, extensive customization without config file editing, and proves that building a production-ready desktop environment from scratch is achievable.
Hacker News·11wI made my own git
A developer built a simplified version control system from scratch to understand git's internals. The implementation uses SHA-256 hashing (instead of git's SHA-1) and zstd compression (instead of zlib) to store file objects, tree structures, and commits. The project demonstrates how git works as a content-addressable file store, with commits referencing tree objects that contain file hashes. Key features include recursive directory traversal, object compression/decompression, commit generation with parent tracking, and checkout functionality. The hardest part was parsing the custom object formats, which could be improved by using structured formats like JSON or YAML.
Hacker News·12wReplacing Protobuf with Rust to go 5 times faster
PgDog replaced Protobuf serialization with direct C-to-Rust bindings in their PostgreSQL proxy, achieving 5x faster query parsing and 10x faster deparsing. The team forked pg_query.rs and used bindgen with AI-assisted code generation to create 6,000 lines of recursive conversion code that maps C structs directly to Rust. Profiling revealed Protobuf deserialization as the bottleneck, not the Postgres parser itself. The new implementation uses unsafe Rust with recursive algorithms for better CPU cache locality and zero additional memory allocation, resulting in 25% overall performance improvement in pgbench benchmarks.
LogRocket·14w6 fast (native) alternatives for VSCode
VSCode's Electron-based architecture creates performance bottlenecks through high resource consumption, especially on low to mid-range hardware. Six native alternatives offer significantly better performance: ecode (C++, 50MB disk, 40MB RAM), CudaText (Free Pascal, 20MB disk), Lite (C/Lua, 1MB disk, ultraminimal), Lite XL (improved Lite with better features), Lapce (Rust, VSCode-like workflow, 60MB disk), and Zed (Rust, full VSCode replacement with AI features, 400MB disk). These editors use native rendering through OpenGL, SDL, wgpu, or platform-specific graphics APIs instead of Chromium, achieving 10-30x lower resource usage while providing comparable features through growing plugin ecosystems.
Noted·13wPortabase: A Lightweight Self-Hosted Database Backup Solution
Portabase is a self-hosted database backup and restore tool supporting PostgreSQL, MySQL, and MariaDB. It uses a central server for management and lightweight agents that operate in outbound pull mode, eliminating the need to expose databases to the internet. The platform features three retention strategies (fixed count, time-based, GFS rotation), supports S3-compatible storage backends, and integrates with notification platforms like Slack and Discord. The central server is built with Next.js 16 and PostgreSQL, while agents have been refactored from Python to Rust for better performance and a 4x smaller Docker image.
Code to the Moon·12wOpenAI went ALL IN on this Rust framework
Orhoon, creator of Ratatouille (a Rust TUI framework with 17,000 GitHub stars), discusses the library's evolution from the unmaintained TUI-rs fork, its immediate-mode rendering approach, and ecosystem adoption including by OpenAI's Codex. He shares insights on maintaining multiple open-source projects, the challenges of AI-assisted coding diminishing programming joy, his hardware project Twetar (a guitar learning device), and the philosophy behind keeping Ratatouille beginner-friendly through architectural simplicity rather than reactive patterns.
Cloudflare·13wWhat came first: the CNAME or the A record?
A routine memory optimization to Cloudflare's 1.1.1.1 resolver accidentally changed the order of CNAME records in DNS responses, breaking resolution for clients like glibc's getaddrinfo and causing Cisco switches to reboot. The incident revealed that while RFC 1034 uses the word "preface" to suggest CNAMEs should appear first, it lacks normative language (MUST/SHOULD) making the requirement ambiguous. Some DNS clients use sequential parsing that expects CNAMEs before A records, while others search the entire answer set. Cloudflare reverted the change and proposed an Internet-Draft to formally clarify CNAME ordering requirements in DNS responses.
Hacker News·11wDeep dive into Turso, the "SQLite rewrite in Rust"
Turso is a new database engine written in Rust that maintains compatibility with SQLite's file format while addressing long-standing limitations. It adds built-in encryption, MVCC with concurrent writes support, and async I/O with io_uring. Unlike SQLite, Turso can scale from in-process usage to networked deployment across multiple machines, making it suitable for projects that start small but may need to scale. The project supports extensions through a Rust SDK and aims to combine the simplicity of embedded databases with the scalability of traditional client-server databases.
The Apache Software Foundation Blog·14wThe Apache Software Foundation Announces New Top-Level Projects
The Apache Software Foundation has promoted three projects to Top-Level Project status: HertzBeat (an AI-powered observability platform for monitoring and alerting), Teaclave (a secure computing platform using Trusted Execution Environments with Rust-based SDKs), and Training (a repository of open source educational materials for Apache projects). These promotions recognize mature communities that have adopted The Apache Way and demonstrate the foundation's commitment to sustainable open source development.
Lobsters·13wBevy 0.18
Bevy 0.18 introduces major rendering improvements including procedural atmosphere occlusion affecting PBR shading, customizable atmospheric scattering for diverse environments, and significant enhancements to the Solari raytraced renderer. The release adds font variations with variable weights, strikethroughs, underlines, and OpenType features. UI improvements include automatic directional navigation for gamepads/keyboards, new widgets (Popover, MenuPopup), and fullscreen material support for post-processing. Developer experience gains include cargo feature collections for selective compilation, first-party camera controllers, glTF extension support, safe mutable component access, and easy screenshot/video recording capabilities.
JetBrains·11wRust vs JavaScript & TypeScript: Performance and WebAssembly
Rust and JavaScript/TypeScript are complementary languages increasingly used together in hybrid architectures. JavaScript/TypeScript excels at rapid iteration, UI development, and full-stack flexibility with its massive ecosystem, while Rust delivers superior performance, memory safety, and reliability for system-level tasks. WebAssembly bridges the two, enabling Rust to handle performance-critical logic within JS/TS applications. Modern teams commonly use JS/TS for the product layer and Rust for the underlying engine, combining speed with flexibility. Real-world examples include Figma using Rust/Wasm for graphics rendering with a TypeScript/React interface, Biome replacing JS tooling with Rust implementations, and Cloudflare powering edge computing with Rust while developers write in JS/TS.
Code to the Moon·14wUltimate Rust Smart Pointer Tier List 2026
A subjective ranking of Rust's most common smart pointers based on practical usage frequency. Covers reference counting (Rc, Arc), interior mutability (Cell, RefCell), singleton patterns (LazyLock, OnceLock, OnceCell, LazyCell), thread-safe primitives (Mutex, RwLock), and utility types (Box, Cow, Pin, Weak). Arc, RwLock, Box, and LazyLock receive top rankings for multi-threaded scenarios, while less frequently used types like Weak and OnceCell land in lower tiers. Emphasizes that rankings are personal and context-dependent.
Phoronix·13wBurn 0.20 Released: Rust-Based Deep Learning With Speedy Perf Across CPUs & GPUs
Burn 0.20 introduces CubeK, a high-performance multi-platform kernel system built on CubeCL that enables unified CPU and GPU execution across NVIDIA CUDA, AMD ROCm, Apple Metal, WebGPU, and Vulkan. The release aims to deliver peak performance on diverse hardware without maintaining fragmented codebases, with benchmarks showing significantly lower execution times compared to LibTorch and ndarray. The update also includes a complete overhaul of the ONNX import system and various stability improvements.
Gamefromscratch·13wBevy 0.18 -- Rust Powered Game Engine
Bevy 0.18, a Rust-based open-source game engine, introduces atmospheric scattering with customizable controls, improvements to the Solari real-time ray tracer (specular materials, soft shadows, better performance), built-in free and pan cameras, full-screen material support for post-processing effects, cargo feature sets for selective builds (2D/3D/UI only), enhanced UI navigation for keyboard/gamepad, font improvements (weights, strikethrough, underline), new UI widgets (popover, color plane), PBR shading fixes, and extensible glTF extension handling. The engine supports both 2D and 3D rendering using an ECS architecture.
The Register·11wCursor is better at marketing than coding
Cursor's CEO claimed their AI agents built a working web browser from scratch in a week, generating 3M+ lines of code. However, developers who examined the GitHub repository found the browser barely compiles, doesn't run properly, and heavily relies on existing projects like Servo and QuickJS despite "from scratch" claims. The project consumed an estimated 10-20 trillion tokens costing millions of dollars, yet produced a non-functional result with failing CI builds and abysmal performance. The incident highlights the gap between AI coding tool marketing hype and actual deliverable software, with industry experts calling for practical results over inflated claims.
It's Foss·13wBTW, Arch Users! Pacman Might Be Getting a Rust Replacement
Arch Linux's Pacman package manager may eventually be replaced by ALPM (Arch Linux Package Management), a new Rust-based project that has completed six major milestones with 15 months of funding from the Sovereign Tech Fund. ALPM provides libraries and tools for package management with full Pacman compatibility. A key difference is licensing: Pacman uses GPL while ALPM uses dual Apache 2.0/MIT licensing, which is more permissive. The transition could mirror Ubuntu's sudo-rs implementation, where the Rust version runs underneath while users continue using familiar commands.
IEEE Spectrum·11wAI Code Transforms C to Rust for Safer Software
The Great Refactor initiative aims to use AI-powered tools to automatically convert 100 million lines of vulnerable C/C++ code in critical open-source libraries into memory-safe Rust by 2030. Memory safety issues account for roughly 70% of software vulnerabilities, and while manual conversion requires thousands of hours, modern AI coding tools can now reliably translate programs up to 5,000 lines with oversight. DARPA's TRACTOR program is exploring hybrid approaches combining AI with classical code analysis. Key challenges include ensuring the translated code is maintainable by humans, the limited pool of Rust experts, and securing $100 million in government or private funding.
DEV·14wTop Open Source Projects That Will Dominate 2026
A curated list of nine open source projects predicted to gain prominence in 2026, including Biome (Rust-powered JavaScript toolchain), Bun (fast Node.js alternative), Deno 2.0 (TypeScript-first runtime), Zed (AI-enabled code editor), Turso (edge SQLite database), Ollama (local LLM runner), Ruff (Python linter), Astro (content-focused web framework), and Continue (open source AI coding assistant). The common themes are performance improvements through Rust rewrites, enhanced developer experience, and AI integration.
Hacker News·15wIntroducing OpenWorkers – Self-hosted Cloudflare Workers in Rust
OpenWorkers is an open-source runtime that enables self-hosted execution of untrusted JavaScript in V8 isolates, providing a Cloudflare Workers-compatible alternative. Built in Rust, it supports KV storage, PostgreSQL, S3/R2 storage, service bindings, and standard Web APIs. The architecture includes secure sandboxing with CPU and memory limits, cron scheduling, and can be deployed with a single PostgreSQL database and Docker Compose file. The project evolved over 7 years from vm2 to deno-core and now runs on rusty_v8, aiming to deliver edge computing capabilities without vendor lock-in.
Steve Klabnik·11wThe most important thing when working with LLMs
Working effectively with LLMs requires giving them objective ways to evaluate their own work. The key is providing quick feedback mechanisms that indicate success or failure and guide corrections when things go wrong. This mirrors human development workflows: write code, run tests/compiler, iterate based on feedback. Tools with clear error messages and minimal verbose output work best. Good practices like comprehensive test suites, strong type systems, and helpful compiler errors benefit both LLMs and human developers. By optimizing the feedback loop, you can safely auto-accept LLM actions and dramatically increase development velocity.