Hasty Briefs - Daily Tech News Brief

Bilingual

Injecting Java from native libraries on Android
9 months ago
- Android presents unique challenges for Rust developers due to limited access to certain OS functions compared to desktop platforms.
- Advanced phone capabilities, like Bluetooth control, are only accessible via Android's Java SDK, not through native libraries like libc or the NDK.
- JNI (Java Native Interface) allows Rust to interact with Java APIs, enabling the use of Java classes and methods from native code.
- Previously, it was believed that Rust on Android couldn't create new Java classes, only instantiate existing ones, limiting functionality.
- For app developers, adding necessary Java classes isn't an issue, but it's problematic for Rust library developers whose users might not know to include these classes.
- Android's JNI documentation states that `DefineClass` isn't supported, but using `DexClassLoader` allows injecting pre-compiled Java classes at runtime.
- Rust crates can embed and inject Java classes (via `classes.dex`) into the JVM, making the process seamless for users.
- The process involves compiling `.java` files into `.class` files, converting them to `classes.dex`, embedding them in the Rust library, and loading them at runtime.
- This technique, though not widely known, enables modular Rust libraries on Android, similar to the ease of iOS development with C or ObjC interfaces.
- Examples include the `slint` and `netwatcher` crates, which use this approach to provide Java helpers without user intervention.
Graph-SQL: Rust CLI Tool to Generate GraphQL APIs for SQLite
9 months ago
- graph-sql is a high-performance Rust CLI tool and library that automatically introspects SQLite databases and generates complete GraphQL APIs with TOML-based configuration.
- It serves as a memory-safe alternative to traditional GraphQL servers, acting as a lightweight gateway that pushes business logic to the database layer for optimal performance.
- Key features include memory safety (Rust's zero-cost abstractions), database-first architecture, and support for SQLite extensions.
- graph-sql is recommended for internal tools, prototypes, development environments, and low-risk applications but not for mission-critical or real-time applications.
- The tool is in active development, with potential breaking changes, and users are advised to pin to specific commits for production use.
- graph-sql offers better performance, data consistency, and simplified architecture by pushing business logic to the database layer.
- SQLite advantages highlighted include edge computing, performance, simplicity, extensions support, and ACID compliance.
- The tool is optimized for heavy-load scenarios with minimal resource usage, efficient concurrency, stateless design, and native speed.
- Comparisons with Hasura, PostgREST, and Supabase highlight graph-sql's strengths in memory safety, setup simplicity, and performance.
- Installation is straightforward with cargo, and the CLI supports TOML configuration, automatic database creation, migration support, and schema export.
- The library API is simple and elegant, supporting integration with Rust web frameworks like Axum, Actix-web, Warp, and Tide.
- graph-sql automatically transforms SQLite databases into GraphQL services with features like memory safety, high performance, TOML configuration, and full CRUD operations.
- Current limitations include SQLite-only support, basic authentication, and no subscription support, with future plans for PostgreSQL, MySQL, and advanced features.
- Development setup involves cloning the repository, creating a config file, and running tests or examples.
- Contributions are welcome, with guidelines provided for forking, branching, and submitting pull requests.
- The project is licensed under MIT OR Apache-2.0 and acknowledges dependencies like async-graphql, SQLx, Axum, and SeaQuery.
Writing a Rust GPU kernel driver: a brief introduction on how GPU drivers work
9 months ago
- Introduction to Tyr, a Rust GPU driver for Linux supporting Arm Mali CSF-based GPUs.
- Exploration of GPU drivers using the VkCube application, which renders a rotating cube using Vulkan.
- Explanation of User Mode Drivers (UMD) and Kernel Mode Drivers (KMD) in GPU driver architecture.
- Overview of the API offered by Tyr, mirroring Panthor's API for the same hardware.
- Key responsibilities of KMD include memory allocation, work submission, and device initialization.
- Discussion on the complexity residing in UMD for translating high-level API commands to GPU-understandable commands.
- Formal definition of the KMD interface, including device information, memory allocation, job submission, and tiler heap management.
- Future exploration of CSF architecture and MCU in upcoming series installments.
TUI Version of Dmidecode Tool
9 months ago
- The operating system is Linux-based.
- To build dmitui, use the command: `cargo build --release`.
- The executable file will be located at `target/release/dmitui`.
- Copy the executable to a directory in your `$PATH`.
- Start dmitui with the command: `sudo dmitui`.
- Supports Firmware (type 0) and System (type 1).
- Licensed under GNU General Public License v3.0 or later.
Rust 1.89.0
9 months ago
- Rust 1.89.0 has been released, featuring new language improvements and updates.
- New support for explicitly inferred arguments to const generics using '_'.
- Introduction of a mismatched lifetime syntaxes lint to improve code clarity.
- Addition of more x86 target features including sha512, sm3, sm4, kl, and widekl.
- Cross-compiled doctests now tested, with options to ignore specific targets.
- i128 and u128 types can now be used in extern "C" functions without triggering improper_ctypes_definitions lint.
- Demotion of x86_64-apple-darwin to Tier 2 with host tools due to macOS changes.
- Standards compliant C ABI for extern "C" functions on wasm32-unknown-unknown target.
- New Tier-3 targets added: loongarch32-unknown-none and loongarch32-unknown-none-softfloat.
- Stabilization of various APIs including NonZero<char>, File locking methods, and more.
HorizonDB, a geocoding engine in Rust that replaces Elasticsearch
9 months ago
- Radar processes over 1 billion API calls per day, serving hundreds of millions of devices globally.
- HorizonDB, a geospatial database written in Rust, was developed to consolidate multiple location services into a single, high-performance binary.
- Prior to HorizonDB, geocoding was split across Elasticsearch, microservices, and MongoDB, leading to operational and scaling challenges.
- HorizonDB utilizes technologies like RocksDB, S2, Tantivy, FSTs, LightGBM, and FastText to enhance performance and efficiency.
- Rust was chosen for its safety, performance, and concurrency features, making it ideal for systems programming.
- RocksDB provides microsecond response times, serving as the primary record store with high efficiency.
- S2 enables efficient spatial indexing, converting O(n) point-in-polygon lookups into constant time operations.
- FSTs offer efficient string compression and prefix queries, caching millions of 'happy paths' with minimal memory usage.
- Tantivy, an in-process inverted index, was preferred over external services like Elasticsearch for its simplicity and performance.
- FastText improves search precision by representing words as numeric vectors, handling typos and out-of-vocabulary words effectively.
- LightGBM models classify query intent, structuring queries to enhance search performance and precision.
- Apache Spark processes hundreds of millions of data points quickly, with near-linear scalability.
- HorizonDB has significantly improved cost, performance, and scalability for Radar's geolocation services.
- Radar is hiring engineering talent and invites interested candidates to check their jobs page.
A simple pixel physics simulator in Rust using Macroquad
9 months ago
- Sbixel is a simple pixel physics simulator created to learn Rust.
- Uses macroquad for drawing, praised for its simplicity and effectiveness.
- Simulation employs a 'sector' system to optimize performance by focusing on active pixel areas.
- Settings for simulation and performance are located in src/def.rs.
- Current roadmap includes upgrading water simulation, improving sand/water interaction, optimizing rendering, refactoring logic, adding gas simulation, and introducing static objects.
- Project can be run with 'cargo run', with a recommendation to use '--release' for better performance.
Show HN: NTP diag tool, as is Ping for ICMP
9 months ago
- RKIK is a Rust-based CLI tool for stateless and passive NTP inspection.
- It allows querying NTP servers (IPv4 or IPv6) without root or sync.
- Features include comparing offsets between servers and output in human-readable or JSON format.
- Supports verbose mode for advanced metadata and accepts both FQDN and raw IP addresses.
- Installation options include downloading binaries, using package managers (rpm, dnf, yum, apt), or building from source.
- Example commands demonstrate querying servers, using IPv6, verbose output, JSON format, and comparing multiple servers.
- Output formats include detailed human-readable and structured JSON data.
Are We Teaching Rust Effectively?
9 months ago
- The author reflects on their initial confusion with Rust's lifetime annotations and how their understanding evolved over time.
- Lifetime annotations like 'a and 'b are considered bad style unless they add clarity; meaningful names like 'win or 'arena are preferred.
- The Aliasing Xor Mutability (AXM) principle is highlighted as Rust's fundamental concept, more important than ownership, borrowing, or lifetimes.
- AXM ensures that mutable data cannot be aliased, a principle that underpins Rust's safety guarantees.
- The author critiques current Rust educational materials for not emphasizing AXM enough, leading to misconceptions and overuse of workarounds like Rc and RefCell.
- A practical example demonstrates how to correctly implement a binary tree in Rust without unnecessary complexity, adhering to AXM.
- The post concludes with a call to reform Rust education to focus more on fundamental principles like AXM to improve learning outcomes.
Rust in 2025: Targeting foundational software
9 months ago
- Rust's mission is to make foundational software more accessible to author and maintain.
- Foundational software includes CLI tools, cloud platforms, embedded devices, and kernels.
- Rust combines C++'s zero-cost abstractions with a memory-safe type system.
- Type systems in Rust empower developers at all experience levels.
- Rust is also being used for higher-level applications like GUIs and webpages.
- Projects like Dioxus, Tauri, and Leptos push Rust's boundaries and improve ergonomics.
- Using Rust across the entire stack allows for shared libraries and support code.
- Smooth, iterative deepening is key for user experience in Rust.
- Future focus areas include language interop, type system extensions, and ecosystem leveling up.
Show HN: Rust macro utility for batching expensive async operations
9 months ago
- Rust macro utility 'batched' for batching expensive async operations.
- Supports configuration options like 'limit', 'concurrent', and 'window' for batch processing.
- Target function must be async and take a single argument of type Vec<T>.
- Return values are either cloned or pulled from an iterator based on the function's return type.
- Requires tokio async runtime and does not work inside structs.
- Includes tracing spans for batched requests and OpenTelemetry support for linked spans.
- Example usage with PostgreSQL for inserting messages in batches.
- Error handling with SharedError for non-Clone error types.
Show HN: Doxx – Terminal .docx viewer inspired by Glow
9 months ago
- doxx is a terminal-native document viewer for Microsoft Word files built with Rust.
- Features include beautiful terminal rendering, smart table support, and powerful export capabilities.
- Supports multiple view modes: document, outline, search, and help.
- Includes advanced table parsing with automatic header detection and intelligent alignment.
- Offers various export options: Markdown, CSV, plain text, and JSON.
- Cross-platform support for Windows, macOS, and Linux.
- Intuitive keyboard shortcuts and mouse support for navigation.
- Built with modern Rust libraries for performance and reliability.
- Planned future features include AI integration for document summarization and Q&A.
- Open-source under the MIT License, with contributions welcome.
Typechecker Zoo
9 months ago
- Project to create minimal implementations of successful static type systems from the last 50 years.
- Implementations will be in Rust, chosen for its parser ecosystem and ease of installation.
- Focus on practical implementation details rather than theoretical depth.
- Includes toy implementations of Algorithm W, System F, System F-ω, and Calculus of Constructions.
- Uses Rust libraries like larlpop, logos, and ariadne for parsing and testing.
- Project is MIT licensed and open for contributions on GitHub.
In-Memory Filesystems in Rust
9 months ago
- The author explores using in-memory filesystems in Rust for testing CLI tools to avoid slow file stat operations.
- Initial search for a Rust equivalent to Go's Afero leads to frustration due to lack of options and community pushback.
- The vfs crate is considered but lacks support for symlinks and file permissions, making it unsuitable for the author's needs.
- rsfs is another option but introduces complex type signatures and doesn't offer significant performance benefits over std::fs.
- Benchmarking reveals no significant performance difference between in-memory filesystems, ramdisk, and regular SSDs, suggesting modern storage and OS caching are highly efficient.
- The author concludes that testing directly against the filesystem is viable due to negligible performance gains from in-memory alternatives.
Show HN: GiralNet – A Privacy Network for Your Team (Not the World)
9 months ago
- GiralNet is a private, high-trust onion routing network written in Rust.
- Designed for small, trusted groups like journalists or activists.
- First stable release (v0.0.1) with full core functionality.
- High-trust security model where all node operators are personally known and vetted.
- Dynamic 3-hop circuits for traffic routing.
- Secure Directory Authority manages trusted nodes with TLS and shared secret.
- End-to-end encryption using Onion Routing and TLS.
- User-friendly TUI for setup, accessible to non-developers.
- Self-contained network infrastructure with no third-party reliance.
- Security features include TLS, AES-256-GCM, RSA, and shared secret authentication.
- Interactive setup, automatic config file creation, and Windows support.
- Requires 5 instances for full testing: 1 Directory, 3 Nodes, 1 Proxy.
- Open-source, welcoming contributions in areas like Pluggable Transports and GUI development.
- Known limitations include single Directory Server point of failure and reliance on operator trustworthiness.
- Future plans include Pluggable Transports, GUI, and decentralized discovery.
- Licensed under GNU GPL v2.0.
Show HN: OnPair – String compression with fast random access (Rust, C++)
9 months ago
- OnPair is a compression algorithm for efficient random access on sequences of short strings.
- It has two phases: Training (identifies frequent adjacent token pairs) and Parsing (compresses strings into token IDs).
- OnPair16 is a variant with a 16-byte limit on dictionary entries for optimizations.
- The Rust implementation supports up to 65,536 tokens, each with a 2-byte ID.
- Usage involves adding the crate to Cargo.toml and using OnPair or OnPair16 for compression/decompression.
- Example provided for compressing and decompressing a list of strings.
- Project is licensed under MIT, developed by Francesco Gargiulo and Rossano Venturini at the University of Pisa.
Show HN: Rucat – Cat for Prompt Engineers
9 months ago
- rucat is a Rust-based tool designed for the LLM era, enhancing prompt engineering by efficiently consolidating context from multiple files.
- It supports multiple output formats including ANSI, UTF-8, Markdown, ASCII, XML, JSON, and syntax-highlighted 'pretty' formatting.
- Features include line numbering, clipboard support, flexible input handling (files, directories, stdin), and path manipulation for cleaner output.
- rucat is ideal for developers and sysadmins, offering rapid context gathering for AI-driven tasks like debugging and repository analysis.
- Installation options include Homebrew for macOS and Cargo for Rust toolchain users, with cross-compilation support for Linux targets.
- Advanced usage includes processing NUL-separated file lists, stripping path components, and clipboard integration for seamless AI chat input.
- Configurable via TOML for default settings, rucat prioritizes performance and memory safety, being written in Rust.
- Open for contributions under GNU GPL v3.0, rucat is a collaborative tool, part of the modern developer's toolkit.
Show HN: Typed-arrow – compile‑time Arrow schemas for Rust
9 months ago
- typed-arrow provides a strongly typed, compile-time way to declare Arrow schemas in Rust.
- Maps Rust types directly to arrow-rs typed builders/arrays and arrow_schema::DataType with zero runtime cost.
- Performance: Monomorphized builders/arrays with zero dynamic dispatch; avoids runtime DataType matching.
- Safety: Column types, names, and nullability live in the type system; mismatches fail at compile time.
- Interop: Uses arrow-array/arrow-schema types directly; no bespoke runtime layer.
- Supports nested structs, lists, dictionaries, timestamps, and more with compile-time schema generation.
- Example usage includes deriving Record for structs and building RecordBatches with compile-time schema checks.
- Metadata can be added at schema or field level with attributes.
- Supports various Arrow data types including primitives, strings, binary, temporal, decimal, nested types, and dictionaries.
- Missing support for BinaryView, Utf8View, ListView, LargeListView, and RunEndEncoded.
Show HN: Luminal – Open-source, search-based GPU compiler
8 months ago
- Luminal is a deep learning library using search-based compilation for high performance.
- To run the demo on Mac, clone the repo and follow the given commands.
- Transitioning to '2.0' with large-scale kernel search, simplifying the compiler stack.
- Example code provided for setting up a graph and performing matrix multiplication.
- Llama 3 8B can be run locally using Luminal, with setup and run instructions provided.
- Luminal aims to be the fastest ML framework, supporting Q8 Llama 3 8B on M-series Macbooks.
- Core library is minimal, with 12 primitive ops supporting transformers and convnets.
- Compiles ops into complex GPU kernels for high performance.
- Uses exhaustive search for optimizations, enabling automatic derivation of complex rewrites.
- Written in Rust, interacting directly with CUDA/Metal APIs without abstractions.
- Emphasizes correctness with extensive testing against PyTorch implementations.
- Ahead-of-time compilation approach, similar to XLA and tinygrad, for better performance.
- Supports aggressive kernel fusion, shape-specific kernels, and handling devices/dtypes via compilers.
- Current features include Metal/CUDA support, full training, and implementations of models like Llama 3.
- Roadmap includes expanding search space, improving CUDA, adding Blackwell intrinsics, and more.
Rust: Python's New Performance Engine
8 months ago
- Rust is increasingly used in Python for performance optimization, with a 22% increase in usage for Python binary extensions in one year.
- Rust offers C-level performance, memory safety, and a better developer experience compared to C.
- High-profile Python projects like Polars, Pydantic V2, and FastAPI are leveraging Rust for significant performance improvements.
- Rust is influencing Python's core infrastructure, with ASGI servers and new type checkers written in Rust gaining traction.
- Enterprises benefit from Rust-enhanced Python through cost savings, improved performance, and energy efficiency.
- Python developers are advised to learn basic Rust to better understand and utilize Rust-enhanced libraries and extensions.
- The future of Python and Rust is hybrid, combining Python's expressiveness with Rust's performance for intensive tasks.

Hasty Briefsbeta

#rust

Injecting Java from native libraries on Android

Graph-SQL: Rust CLI Tool to Generate GraphQL APIs for SQLite

Writing a Rust GPU kernel driver: a brief introduction on how GPU drivers work

TUI Version of Dmidecode Tool

Rust 1.89.0

HorizonDB, a geocoding engine in Rust that replaces Elasticsearch

A simple pixel physics simulator in Rust using Macroquad

Show HN: NTP diag tool, as is Ping for ICMP

Are We Teaching Rust Effectively?

Rust in 2025: Targeting foundational software

Show HN: Rust macro utility for batching expensive async operations

Show HN: Doxx – Terminal .docx viewer inspired by Glow

Typechecker Zoo

In-Memory Filesystems in Rust

Show HN: GiralNet – A Privacy Network for Your Team (Not the World)

Show HN: OnPair – String compression with fast random access (Rust, C++)

Show HN: Rucat – Cat for Prompt Engineers

Show HN: Typed-arrow – compile‑time Arrow schemas for Rust

Show HN: Luminal – Open-source, search-based GPU compiler

Rust: Python's New Performance Engine