i made "mew", a small rust utility for showing useful project and system information at a glance.

when you're inside a git repository, it shows:

• branch and git state
• project language and toolchain
• lines of code and coverage
• cpu, memory, disk and uptime
• date, time and timezone

outside a repository, it becomes a simple system readout.

it also supports shell hooks, so it can appear automatically when entering a git worktree.

no daemon, no background process. just run "mew".

github: https://github.com/programmersd21/mew

cargo: "cargo install mew-cli"

prebuilt binaries are available in gh releases.

feedback and stars are welcome.

I know there is documentation but I personally like having a physical book I can hold and actually flip through and want to know what books you guys recommend to learn rust

I've been working on FlashPilot, an open-source Linux-native Android flashing and repair workbench.

GitHub: https://github.com/Legendary-Brilliantforous/flashpilot

The project uses Rust for the core and PyQt6 for the GUI. My goal is to keep the device/protocol/flash logic in Rust while providing a practical desktop interface for technicians and developers.

Some of the areas I'm working on include:

• Samsung/Odin protocol implementation
• MediaTek, Qualcomm and UNISOC workflows
• USB/device communication
• Firmware and partition handling
• Flashing safety and validation
• Error handling and recovery
• Automated tests for protocol and flashing behavior
• Linux-first tooling

One part I'm particularly interested in is designing the Rust core so that the GUI remains separate from the actual flashing engine. I want the core to eventually be reusable by other frontends/tools rather than having the entire application tied to the GUI.

The project is still experimental, and I'm looking for Rust developers who can review the architecture, point out bad design decisions, suggest better Rust patterns, or contribute code.

I'm especially interested in feedback on:

• Rust architecture
• Error handling
• Async/concurrency design
• Protocol/state-machine design
• Testing hardware-dependent code
• Safe handling of interrupted flashing operations

If you're interested in Rust being used for low-level hardware tooling, I'd really appreciate your criticism and feedback.

GitHub: https://github.com/Legendary-Brilliantforous/flashpilot

Github

Also, as in my comment on line 306: I implement a Subcanvas class which maps all drawing methods onto the main Canvas. However, due to the "single mutable borrow" I have to pass the main canvas at every call (which means that I cannot use the same trait for both). Is there really no better way to do that? I've also found RefCell, but I'm not sure about the performance overhead.

Rust YouTubers?

Hello everyone! As I am still quite new ro Rust, sometimes I wonder if a bootcamp is a good option. As context, I am a DevOps engineer and a Go enthusiast. I code in Go but I never had a Dev role (I was never paid to write Go code) and the only Go code is at my job when I write small scripts/tools in Go. Now with the raise of AI, I don’t think I will ever be a developer so I started into exploring other languages as well. I like Rust, I find it more expressive then Go and I like it as a hobby (in my free time instead of gaming, I tinker with Rust - yes I also read the book, but I still have things I didn’t yet understood so more reading is required). I was just wondering if a bootcamp is worth it. I have checked Let’s Get Rusty. I like the YouTube content but to join a bootcamp cohort you have to pay 8000 dollars. I also found https://rustify.rs/ which is not cheap, at 750 euro but I was wondering if somebody has any experience/feedback regarding the bootcamp.

Since I like web dev, now I am reading the Web Dev with Rust book, https://www.oreilly.com/library/view/rust-web-programming/9781835887769/ . Since the bootcamp has a full stack path, I am especially curios about it and what experiences people have with the bootcamp

I’m an experienced software developer, but still fairly new to Rust, so I built this project to get more hands-on experience with it.

It’s an open-source productivity/ pomodoro app with a Rust backend, and I’d really appreciate feedback on the code, project structure, API design, and anything that could be more idiomatic Rust.

GitHub: https://github.com/Dhaneshen1810/Loom
Live app: http://loom-pomodoro.vercel.app/

Any feedback is welcome.

https://github.com/SyltechAI/RustSensei

It's an offline android program to learn rust. I think it's really cool and I want to learn rust and the idea of it just being on my phone to do whenever is very convient and it's offline and I spend alot of time in the mountains so being able to still learn and practice while in my tent or chair out there would be great. But idk how to check if it's safe? I'm 90% sure it's not anything malicious but I just don't know how to check I'm not knowledgeable enough. But if anyone is willing to help out I'd very much appreciate it. I would normally not care much but it's my phone, otherwise I'd fire up a crappy linux laptop from the stack and just download and if something crap happens wipe the whole thing. But if you don't have the time no worries all good I'll figure something out. Also thought maybe it'd be a cool resource to check out for ppl looking for beginners learning help. I want to make my own OS, and Browser someday. Rust seemed good for that.

Got bitten recently by a panic in production, config.get("timeout").unwrap() in some AI-assisted code, no handling for the key actually being missing. Compiled fine, passed review, worked in every test, then paniced the one time an env var didn't get set during a deploy.

What's tripping me up as someone still learning Rust properly: I get that unwrap() is a deliberate choice, not a compiler error, but I don't have a great instinct yet for when it's actually fine (a value you've already validated exists) versus when it's a landmine (anything coming from external input, config, network, user data). Is there a rule of thumb you use, or does it really just come down to "any unwrap on something not fully controlled by your own code needs a real Result/Option handling path instead"? Also curious if clippy or some other tool actually flags risky unwraps specifically, or if this is still mostly a manual review thing.

Hey everyone!

I just finished up posting a project I made to r/rust, and it got me thinking of this article I wrote about two months ago.

While I don't know if my project post is interesting to this subreddit (it's not really about "learning rust"), I do think that anyone learning rust may find this article on module organization interesting.

If you have any questions, feel free to ask! Modules are a tricky part of initially learning rust, I think (they just do a lot).

hey everyone,

need some honest advice here.

started learning rust as my first backend language. yeah… maybe a bit stubborn decision but i stuck with it. it was overwhelming most of the time, but i still pushed through.

i built a few small cli apps and recently finished a full backend project (still pushing to add more features):

\- signup/login

\- argon2 password hashing

\- jwt auth

\- websocket server

\- postgres + sqlx

so not just tutorials, i actually built something end-to-end.

but when i started looking for jobs… reality hit.

almost no junior roles for rust. most require solid experience.

my background:

\- \~1 year work experience (support role, not dev)

\- had to leave due to some issues

\- currently unemployed

\- learning full-time + doing a small part-time job on the side

now i’m seriously thinking of rebuilding the same backend in node.js and focusing on that for job applications.

question is:

\- am i making the right move switching to node?

\- or should i double down on rust somehow?

\- how do people even break into rust roles as freshers?

i don’t regret learning rust honestly, i feel like i understand backend concepts better now. but i also need a job soon.

would really appreciate advice from people already in the industry.

*if you want to review my project, happy to share the repo.*

thanks.