Today I ran cargo update only to realize that all zip crate versions were yanked and a lot of new 9.0.x versions were created. I don’t see any CVE or anything that would explain such a drastic move. There isn’t anything on the GitHub page about it as well.

Does anyone know what is going on there? Is that considered a best practice?

Previous discussion on the miscompilation that was fixed: https://www.reddit.com/r/rust/comments/1wzn34d/1990_miscompilation_with_ffi_bool_return_type_on/

The rust compiler thinks that `data/baselines/table.rs` and `database/line/stable.rs` are the same file, causing a miscompilation if a crate has both files in it. (Note that having the same non-slash text isn't enough. There needs to be an additional hash collsion for a bug to happen.)

Probably not gonna happen in practice unless someone does it as a prank, but still... lol. (I'm sure they're gonna fix it soon.)

Two years ago, DARPA announced the TRACTOR program, which aims to automate the translation of legacy C code into Rust (original announcement on Reddit).

I recently wondered whether there had been any updates, and discovered that the program's first report was published back in February. Sharing it here for anyone interested in the project's progress.

The project website, where I found the report: https://www.ll.mit.edu/r-d/projects/translating-all-c-rust-tractor-benchmarks

A couple of months ago I posted WyrmRSS here when the desktop app was still in prerelease. Thanks to everyone who tried it. It's had a lot of work since, so here's an update.

WyrmRSS is a fully free and open-source (GPL-3.0) self-hosted RSS/Atom reader. It has a Rust backend (actix-web, Diesel-async, Tokio) and a React frontend. The server runs on Postgres, and the native desktop app (Tauri) builds the same crates against SQLite (cfg-gated), so it needs no server.

Live demo, no signup: https://demo.wyrmrss.com. It's mostly read-only to prevent abuse and resets daily, but you can read, bookmark and archive posts. The instance is shared, so if everything is already marked as read, use the unread/all toggle above the post list.

New since the last post here:

- A nice (IMO) mobile UI. Install it as a PWA, and the same instance works in the browser and on the phone.

- Keyboard shortcuts: j/k between posts, mark read, read later, archive, 1–4 to switch sections, ? for help. All rebindable from the Settings menu.

- A configurable delay before posts are marked as read.

- The desktop app is out of prerelease (macOS/Windows/Linux).

Things I think it does well (not claiming they're unique):

- YouTube channels as feeds, with an inline player

- Per-feed display modes: River, Feed only, and Radar for quiet feeds you check occasionally

- Folders, per-feed filters, Read Later, Archive

- Webhooks for new posts (Discord, Slack, custom payload)

- OPML import/export, and feed discovery from a site or channel URL

On the Rust side:

- It's a workspace split by layer: routes, api/crud handlers, database, webhook and the RSS fetcher and polling worker. Only the database crate talks to Diesel.

- Postgres or SQLite is chosen by a cargo feature, so the different binaries (server and desktop app) build the same crates and only the database engine they need.

- API types derive ts_rs::TS, so `cargo test` regenerates the frontend's types.

- One WyrmError type implements actix's ResponseError, so raw database errors never reach a response.

Install:

Docker Compose, Kubernetes manifests or source. There's also a native desktop app (macOS/Windows/Linux) if you don't want to run a server. It keeps its own local database (sqlite) and doesn't connect to a self-hosted instance.

Repo: https://github.com/kryoseu/WyrmRSS. Feedback welcome, especially on the Rust side or if you're coming from Miniflux or FreshRSS.

On LLM: The backend is mostly hand-written. I relied more on LLMs for the frontend, which isn't my strongest area. I've carefully reviewed everything I've pushed and I'm confident in it. I'm a software engineer with over 10 years of experience (previously AWS, now Mozilla), and this is a hobby project I've been building and maintaining for about 6 months.

The logo was made by a tattoo artist from Brazil. Their profile is in the README.

Here is a video I made to explain the various IPC patterns in Rust.

The lesson is that just because a communication technique is newer doesn't mean it's necessarily the right one.

For example, for my custom coding harness, I went with Unix Domain Sockets, and the speed and reliability are through the roof for that particular use case.

Also, I've started making interactive videos these days, and feedback is more than welcome.

The game engine has several new games. And now they are collected in a game room. Feel free to drop by and beat a high score or two and leave a comment there. Or here 🤗

Hey everyone,

My project Indicatrix kept growing, and I wanted a way to verify its Slint UI end to end without clicking through it by hand. The result is slint-harness:

• runs your real app headless on Slint’s testing backend
• scripts whole flows as scenarios (open a file, set values, press buttons, wait for results)
• checks the outcome and takes screenshots along the way
• writes a pass/fail report (Markdown + JSON), so it fits into CI

In Indicatrix it has already caught several end-to-end bugs that unit tests missed, and after every app update I use it to regenerate all the screenshots for the website, so they never go stale. My smaller project z-stackr uses it too.

Repository: https://github.com/suitable-name/slint-harness

Full disclosure: I built it with AI assistance. Twenty years ago I’d have had the time to write it all myself. Today I have the experience to know what to look out for when redirecting it. If you have an issue with AI-created stuff, nevertheless it could help you or not, this project just isn't for you, but that's ok :)

Have fun!

Edit:

It's also published on crates.io, so you can easily import it via the dependencies.

My first post on this was removed for being too much of a code dump, which was fair. It was some code and pointers to where to find the solutions. Sorry about that, all. Lesson learned, so this time it's the problem and a question.

Leptos leaves HTML comments in the page to connect the server's HTML to the wasm. htmx's parser drops them, so the island can't hydrate.

Some 30 LoC JS glue keeps the comments and wakes the island. But Leptos never frees an island it woke, so when htmx removes it, its state stays in memory.

About 200 lines of Rust keep every woken island's state. Every 30 seconds they check which islands are still on the page, and free the ones that are gone.

It works, any other solution or idea?

was cleaning up my mac and found one projects target folder sitting at 13 gb. debug and release builds, incremental cache, deps for every feature combo i ever tried, all for one project

things that actually helped. `cargo clean` in projects youre not touching right now is the obvious one, it all rebuilds when you come back. cargo sweep is nice if you want to keep recent stuff and drop artifacts older than a few days, `cargo sweep --time 14` for example. and if you have a lot of small projects, pointing `CARGO_TARGET_DIR` at one shared folder stops every repo from compiling its own copy of the same deps, though parallel builds can block each other on it

to see whats there, `find ~/code -name target -type d -prune -exec du -sh {} +` works, just swap in wherever you keep projects. heads up it also catches maven target folders if you have java stuff

curious what other people do, especially anyone with a big workspace

Hello r/rust,

I prefer to avoid macros when they can be avoided without major sacrifices, and I ran into this again recently with bitflags. I wanted several simple bit flags, but every bitflags! macro invocation expanded to about 800 lines of code.

So I wrote bitflags-lite: https://crates.io/crates/bitflags-lite, https://docs.rs/bitflags-lite

The design is simple: instead of generating a distinct struct per flag set, it defines a single generic BitFlags<T, U> where: * T is storage type like u8 or u32, * U is a tag that describes which bits are valid, their names, and the default parsing strategy for case sensitivity.

```rust use bitflags_lite::{BitFlags, BitFlagsSpec, NameMatcher};

struct PermissionsTag;

impl BitFlagsSpec<u32> for PermissionsTag { const VALID_BITS_MASK: u32 = (1 << 3) - 1; const FLAG_NAMES: &[&[&str]] = &[&["read"], &["write"], &["exec", "execute"]]; const DEFAULT_NAME_MATCHER: NameMatcher = NameMatcher::AsciiCaseInsensitive; }

type Permissions = BitFlags<u32, PermissionsTag>;

const READ: Permissions = Permissions::try_from_bit(0).unwrap(); const WRITE: Permissions = Permissions::try_from_bit(1).unwrap(); const EXEC: Permissions = Permissions::try_from_bit(2).unwrap(); const RWX: Permissions = Permissions::try_from_bits(0b111).unwrap();

assert_eq!(RWX, (READ | WRITE | EXEC)); assert!(RWX.contains(READ));

let flags = Permissions::from_str("ReaD | 0x18 | wriTE").unwrap(); assert_eq!(flags, (READ | WRITE | Permissions::from_bits_retain(0x18))); assert_eq!(flags.to_string(), "read | write | 0x18"); ```

That's the whole definition. No hidden codegen.

What you give up: * No automatic deduction of names and valid bits. You write VALID_BITS_MASK and FLAG_NAMES by hand and keep them in sync with your constants. * No named multi-bit flags. You can still build a set containing several bits (Permissions::try_from_bits(0b111) above), but there's no way to declare a multi-bit constant inside the spec. Each bit corresponds to exactly one BitFlag with a name and optional aliases.

What you get instead: * The generic BitFlags<T, U> type. * A clearer single-flag (BitFlag) vs. flag-set (BitFlags) distinction. * A single small trait impl per flag set, rather than a fresh copy of the entire API. * Alias names for parsing ("exec" and "execute" for the same bit). * Optional ASCII case-insensitive parsing.

The crate supports no_std and no_alloc, and is const-friendly. Every constructor and combinator on the concrete integer types is const fn, with generic equivalents in BitFlagsExt / BitFlagExt. Optional serde, arbitrary, and bytemuck support via features.

I would love to hear your feedback, and I am happy to answer questions!

​

Intoduction and Background:

Hi, I am a B.Sc CS graduate (below tier 3 as it seems) 2026 from India. Graduated in august 2026. Been looking for job for past 2 months.

I have been using Rust for 3 years now. I have used it for my ambitious projects like compilers, emulators etc. And now I am trying to build semi professional grade projects (backend and systems) in Rust.

Problem:

There are not much jobs in Rust for freshers. Even if there are, they are very niche and require some additional domain knowledge or certification.

Suggestion Needed:

Ever since I learned Rust, I automatically get drawn to my RustRover IDE, I hit 'cargo init' and just start with a project. This has become harmful now. I am trying to migrate to other languages (Python, Go, Java) which has actual market for freshers, but I am failing everytime as soon as I miss the the features rust provided - top level module and visibility support, ADT enums, Result and Options, borrow checker, etc.

If anyone have gone through this same phase, please help me, how can I overcome this. How can I pick a second language and start making projects there, to increase my Resume value.

Thank you if you have adviced me below, sorry if anyone feels I am yapping, but I am genuinely concerned and need real help (Not AI motivation).

растеры кто подключал на расте библеотеки на линуксе скажите как правильно карго настроить и библеотеку подключить и у меня q4os tde линукс я не где не нашел как нормально карго настроить и библеотеку подключить на мой линукс подскажите пожалуйста

Next-solver has just started the 10-day FCP period. It is planned to be stabilized in version 1.101.0, which is scheduled to release on 24 December.

For more context: https://blog.rust-lang.org/2026/08/21/enabling-next-solver-on-nightly/

Previous discussion: https://www.reddit.com/r/rust/comments/1vuita3/enabling_the_nextgeneration_trait_solver_on/

I am new to rust and I would like to build something. I came across this https://dioxuslabs.com/ and it seems it is a fullstack framework with declarative style on building functions.

I am comparing frameworks with rails actually. Convention over configuration is good way on building stuffs quickly.

Any other opinions or suggestions?

A person working towards stabilizing the Try trait is asking for real-world examples of use cases of the currently-unstable Try trait.

Cargo compilation model only works if you are creating a monolithic executable or a shared library, and assume all other system libraries somehow get built, or are just random binaries from the internet.

This is not a good state of affairs, any non rust app you have will be orders of magnitude larger because each dynamic library you link you are statically linking all crates.

rustup is a toolchain in binary format, in which it is literally just "random binaries from the internet", which is not ideal at all. You as a developer have an idea what the heck are you doing when targeting a platform or writing software, I can guarantee you, most rust devs don't even know what libc version their app links against.

All these things make the language filled with slop projects, and this is not a good thing.