I built a custom Programming Language & IDE from scratch using Rust and WebGPU (It runs UI and Tensors directly on GPU!

https://github.com/qweewq1888pop-a11y/Turkce-KOD-rust-ile-yap-ld-.git

https://preview.redd.it/be6wyvwfgz9g1.png?width=1454&format=png&auto=webp&s=1cf0e1386ea61faaafbb56c0f89ee4b23808e89f

Maybe in v1.0 I can implement a more natural syntax engine!

https://redd.it/1pxxfg4
@r_rust

How would a Souls-like have looked on PS1? I'm creating a browser-based engine in rust to find out
https://ebonura.github.io/bonnie-engine/

https://redd.it/1py1t0i
@r_rust

Rust & Ratatui - Guide from 0 to hero

I'm hobbyst and seeing much beautyfull projects(such impala, wiremix, blutui) i decide to make own tool to manage themes on my Archlinux.
I made cargo templates... and, OH GOD! "fn main" as main function run another functions, exclude render function. In addition mysticist schemat of code (i just don't understand anything). Tried based on examples but fuse some in one usually does not work, plus other method to make single paramether or more than single.
Somebody know basic tutorial to rust/ratatui? I will be greatful for every answear, not important is site, yt video or anything...

https://redd.it/1py5bac
@r_rust

How do you use libc in your projects?

I need to use libc in my library, and I see there are several options:

- Raw bindings by the Rust lang team
- The rustix crate, safe bindings for libc written in Rust by the bytecode alliance
- The nix crate
- Or writing custom bindings

What options do you prefer and why? using raw bindings to allow maximum flexibility and performance? Or safe bindings like Rustix? Or something else?

https://redd.it/1pxv5jk
@r_rust

Can miri or another interpreter be used as a profiler?

Let's suppose I have a program and want to see what parts are slowest, not be running code a zillion times, but by interpreting it (once!) and counting how many MIR instructions get executed.

I know that miri in particular is intended for identifying (in)correctness, but it happens to be able to simulate other platforms with, e.g. different int sizes , different endians, etc, which could make it a multi platform profiler, too.



https://redd.it/1pyccl6
@r_rust

Using Rust to provide C-compatible dependencies

Disclaimer: I am **not** a Rust developer (or a software developer for that matter), but a sysadmin. I've had these questions mulling around in my mind for a while.

To you all with actual Rust experience, how much of an extra burden is it to write and maintain a library that exposes its public API not just via Rust but also unmangled C?

I'm thinking about this from the perspectives of simpler multi-language binding interop and enabling existing non-Rust projects to acquire more safety with drop-in replacements. Putting aside the human/community complexities for a moment, would it make any sense to effectively create/port C libraries in Rust? Does this actually provide increased safety? Is it generally a reasonable strategy?

For example, providing OpenSSL API/ABI compatible versions of libssl and libcrypto. Or GNOME/Freedesktop libraries, [insert favorite C library here\], etc. Entirely new, greenfield projects, too!

The main idea is to provide underlying components in memory-safe languages without needing to upend entire platforms or existing ecosystems.

\---

For fun I posed the question to Claude (Opus 4.5 w/reasoning) and was given a response that I was expecting but can't fully vet on my own. Do you agree or disagree with its analysis?

https://gist.github.com/omenos/cadd1ccdf2de300b7b3cf23c7fa4440e

https://redd.it/1pyenu5
@r_rust

Architecture Dilemma: Tauri Mobile vs. React Native for a companion app for a Rust-heavy Local-First App

Hi everyone,

I’m currently building a privacy-focused, local-first Personal Finance Management application. I am hitting a fork in the road regarding strategy for the mobile version and would love feedback.

The Current Stack (Desktop):

Framework: Tauri v2 ( so rust backend)
Database: SQLite (local) + JSON cache for precomputed results
Frontend: React

The Rust backend is heavy. It handles complex database rollups for analytics, database migrations, and multi-currency conversions.

Now as this is personal finance type application users will like to use mobile version to log data on the fly.

I am torn between two architectural approaches.

Option A: Use Tauri for Mobile also

I port my existing Tauri app to Android/iOS.

Architecture: The exact same Rust binary runs on the phone. It manages its own local SQLite DB and runs the full analytics engine.
Sync: sync to merge two states ( still figuring this out ).
The Issue: I keep reading that Tauri Mobile (even v2) still fights the OS on things like build chains, permissions, and UI jankiness, unstability.

Option B: React Native

I build a React Native with Expo app.
Here also i thought of two ways->

1. Create a dumb mobile app which will just act as a logging platform and show end results. The mobile app has zero business logic. It has a simple "Pending Transactions" queue. It pushes pending items to the Desktop. The Desktop acts as the Server, processes the logic/rollups, and returns a computed JSON snapshot for the phone to display. The phone is "read-only" for analytics and requires a sync to show updated stats, but the UI is guaranteed to be stable and smooth
2. Create a full replica in React-native. But in this case there can be performance issue as database size increases and also will have to maintain two separate codebase with same logic.

My questions

1. Is Tauri Mobile stable enough in late 2025 for a production app?
2. Are the "build chain nightmares" and Android permission issues (specifically for local networking) still a major blocker in late 2025?
3. Should i just use react-native for mobile for best user experience?
4. For data sync which is better IROH,IPFS, libp2p or just a standard desktop server with just on demand sync. Has anyone used this in a React Native context? Does it play nice with Expo, or will I be fighting the JSI/Native Module bridge
5. Has anyone successfully implemented this Desktop as a Server pattern with Tauri? Are there hidden pitfalls with local network discovery?

Any insights are appreciated!

https://redd.it/1pyexyr
@r_rust

rust-analyzer changelog #308
https://rust-analyzer.github.io/thisweek/2025/12/29/changelog-308.html

https://redd.it/1pyg8qo
@r_rust

Hey Rustaceans! Got a question? Ask here (53/2025)!

Mystified about strings? Borrow checker has you in a headlock? Seek help here! There are no stupid questions, only docs that haven't been written yet. Please note that if you include code examples to e.g. show a compiler error or surprising result, linking a playground with the code will improve your chances of getting help quickly.

If you have a StackOverflow account, consider asking it there instead! StackOverflow shows up much higher in search results, so ahaving your question there also helps future Rust users (be sure to give it the "Rust" tag for maximum visibility). Note that this site is very interested in question quality. I've been asked to read a RFC I authored once. If you want your code reviewed or review other's code, there's a codereview stackexchange, too. If you need to test your code, maybe the Rust playground is for you.

Here are some other venues where help may be found:

/r/learnrust is a subreddit to share your questions and epiphanies learning Rust programming.

The official Rust user forums: https://users.rust-lang.org/.

The official Rust Programming Language Discord: https://discord.gg/rust-lang

The unofficial Rust community Discord: https://bit.ly/rust-community

Also check out last week's thread with many good questions and answers. And if you believe your question to be either very complex or worthy of larger dissemination, feel free to create a text post.

Also if you want to be mentored by experienced Rustaceans, tell us the area of expertise that you seek. Finally, if you are looking for Rust jobs, the most recent thread is here.

https://redd.it/1pygtfj
@r_rust

What's everyone working on this week (53/2025)?

New week, new Rust! What are you folks up to? Answer here or over at rust-users!

https://redd.it/1pygulr
@r_rust

Simple Housekeeping (Bash) Script for Rust Projects

I have a tendency to create a dedicated directory for a topic that I'm currently learning in Rust. After several years, the number of directories has grown to hundreds and with that, came the storage space choke. Taking advantage of year-end holiday, I developed this simple bash noscript to handle the housekeeping better. I wrote about this experience in my blog: Simple Housekeeping Script for Rust Projects

I hope it could be useful for others. Please have a look and I'm happy to hear your feedback!

https://redd.it/1pyh2uq
@r_rust

Hauchiwa 0.9: A type-safe, graph-based static site generator library

Hauchiwa is a flexible static site generator library designed for those who want to build their own custom SSG pipeline in Rust. Version 0.9 brings a massive evolution, I have completely rewritten the core architecture to use a graph for build tasks.

What's new in 0.9?

* Hauchiwa now builds a dependency graph (DAG) of your build pipeline. This allows for precise parallel execution and smart incremental rebuilds.
* When a task produces data (like parsed Markdown or compiled CSS), it returns a Handle<T>. You pass this handle to dependent tasks. If the types don't match, your build code won't compile.
* A new macro makes wiring up these dependencies ergonomic and clean.
* Support for `importmap`, and improved support for Svelte SSR via Deno & Esbuild.

Why use Hauchiwa?

If you are tired of rigid frameworks (Hugo/Jekyll/Zola) or fighting with complex config files, Hauchiwa lets you define your build logic in Rust. You define the inputs (loaders), transformations (tasks), and dependencies (handles). Hauchiwa handles the caching, parallelism, and watching.

A taste:

let mut config = Blueprint::<()>::new();

// 1. Load Markdown
let posts = config.load_documents::<Post>("content/**/*.md")?;

// 2. Render pages (depends on `posts`)
hauchiwa::task!(config, |ctx, posts| {
let mut pages = Vec::new();
for post in posts.values() {
pages.push(Output::html(&post.path, render(&post)));
}
Ok(pages)
});

config.finish().build(())?;

I'd love to hear your feedback!

* [https://crates.io/crates/hauchiwa](https://crates.io/crates/hauchiwa)
* [https://docs.rs/hauchiwa/latest/hauchiwa/](https://docs.rs/hauchiwa/latest/hauchiwa/)

https://redd.it/1pyjg24
@r_rust

Looking for good quic libraries with http3 support in Rust.

Well I'm building an experimental http3 framework using Rust's h3 crate followed by Quinn rs especially for JS Runtime since they don't have http3 support yet. Therefore there is no well established articles or documents regarding quic, udp servers and http3 protocols. As an experienced engineer I have seen a lot of corporates networks were blocking udp ports just because they cannot introduce the MITM breach thing during quic hand shakes. Because every single packets gets encrypted leaving with no traces even headers are encrypted. Tbh this might sound fantastic that quic servers are safer than tcp. But it comes up with a huge cost. Running this rustls crypto on both sides each request become more cpu intensive ultimately you get best end to end protection with increased max cpu usage. Well I have been using oha to test my http3 server. It gave very low Rps compared to years of optimized tcp stacks like axum and rocket.

Coming back to my project it's already in alpha stage I moved those rust native addons to node Js. It worked really well even on deno and bun. I have implemented stream support by pulling h3-Quinn internals and forged like express ergonomics res.stream(chunks) for streaming large files seamlessly. My framework actually performed well compared to golang's - h3 library. But haven't open sourced it yet because people barely showing interest they just switch to tcp stacks without knowing the underlying vulnerabilities.

Most of the corporates hides this quic related projects just by phrasing udp ports are unsafe vulnerable to attacks. I would like to seek help all regarding benchmarking http3 Rust libraries plz do share me rust h3 / quic libraries.

https://redd.it/1pymhdv
@r_rust

NeatCLI - fast file organizer written in Rust

Hey all,

Been working on this for a while - a CLI tool to organize messy folders. My Downloads was getting out of control so I built this.

Basic usage:

neatcli organize ~/Downloads --by-type --execute

Creates folders like Images/, Documents/, Videos/ and sorts everything automatically.

Other stuff it does:

duplicate detection (content hashing)
similar image finder (perceptual hashing)
watch mode - auto-organize new files as they appear
EXIF sorting for photos (by camera, date taken)
audio metadata for music (by artist, album)
PDF text search

Wrote it in Rust because I got tired of slow Python tools and dealing with pip/virtualenv stuff. Single binary, around 9MB.

Install:

cargo install neatcli
# or
brew install patchybean/tap/neatcli

GitHub: https://github.com/patchybean/neatcli

Open to feedback - especially what's missing or broken.

https://redd.it/1pyqflv
@r_rust

Disintegrate v3.0.0
https://github.com/disintegrate-es/disintegrate

https://redd.it/1pysfyu
@r_rust

Suggest rust apps with very few or none dependencies (want to test mrustc)

Long story short, I am trying to get rust working on a platform where rustc is broken. I think I have fixed mrustc compiler for it, but I need some realistic cases to test whether it produces usable executables (beyond helloworld and ternimal). Looks like its minicargo does not have a mechanism to resolve multiple dependencies automatically, and given dependency hell in Rust, I would prefer to avoid writing build sequences by hand and fixing gazillion of libs (very likely something will be broken for a platform in question) at this stage. So it will be helpful to know what can be compiled with absolutely minimal dependencies and shown to work or not work correctly.

https://redd.it/1pys7is
@r_rust

Garbage collection in Rust got a little better
https://claytonwramsey.com/blog/dumpster2/

https://redd.it/1pyv5sn
@r_rust

sockudo-ws: Ultra-fast WebSocket library that outperforms uWebSockets

I've been working on a high-performance WebSocket library for Rust and wanted to share it with the community.



Benchmarks against uWebSockets:



\- 512 bytes, 100 conn: 232,712 msg/s vs 227,973 msg/s (1.02x faster)

\- 1024 bytes, 100 conn: 232,072 msg/s vs 224,498 msg/s (1.03x faster)

\- 512 bytes, 500 conn: 231,135 msg/s vs 222,493 msg/s (1.03x faster)

\- 1024 bytes, 500 conn: 222,578 msg/s vs 216,833 msg/s (1.02x faster)



Key features:



\- SIMD acceleration (AVX2/AVX-512/NEON) for frame masking and UTF-8 validation

\- Zero-copy parsing

\- permessage-deflate compression

\- Split streams for concurrent read/write

\- Passes all 517 Autobahn test suite cases

\- Simple API with ws.send() style



N-API bindings for Node.js coming soon.



Used in Sockudo (https://github.com/RustNSparks/sockudo), a Pusher-compatible WebSocket server.



GitHub: https://github.com/RustNSparks/sockudo-ws



Feedback welcome!

https://redd.it/1pywd6j
@r_rust

Build a database from scratch in rust

Hi, I have coded some very small applications using rust and am newbie in rust but I have been trying to read this book https://build-your-own.org/database and start implementing it step by step in rust, but I feel I don't understand it well, and I am not sure that it's dumb to suddenly fall myself in such complex topic, my goal is to becoming from being a frontend engineer to software engineer and as I love rust language I started coding in it, so I will be glad if anyone could give me some clue, thanks.

https://redd.it/1pyxitr
@r_rust

corroded: so unsafe it should be illegal

corroded is a library that removes everything Rust tried to protect you from.

It's so unsafe that at this point it should be a federal crime in any court of law.

But it's still blazingly fast 🗣️🦀🔥

Repo is here.

https://redd.it/1pz0edr
@r_rust

I made a Rust implementation of the classic simulation Particle-Life

This one of my favorites particle simulations. Emergent behavior is just awesome. Hope you like it. Enjoy it!.

https://youtu.be/t-gvqfDl450

https://preview.redd.it/16pw30y679ag1.png?width=1280&format=png&auto=webp&s=b870661b5f250d9ca13581fb06e5adcdb6d215e3



https://redd.it/1pz630c
@r_rust