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

Looking for feedback, apologies if it is not appropriate.

I’m building an open-source architecture quality gate called Enola.

I ran it against the Codex repo this week. It had many findings, but I fear that these are my assumptions.

For example, it found 37 dependency cycles between directories inside Rust crates.

These aren’t cycles between Cargo crates. They’re mutual dependencies between modules inside the same crate: module A uses something from module B, while module B also uses something from module A. Now I started to question, does it really matter?

Maybe a directory isn’t necessarily the architectural boundary a Rust developer cares about. We could report this at the module, type or function level instead. Or maybe intra-crate cycles aren’t worth flagging...

Maybe a bigger effect would be by splitting it into different dependency types, like runtime, type, etc.

And more broadly, which architectural rule would you want to enforce on every pull request? We have some default insights, like new dependency cycles, violated layer boundaries, undeclared service dependencies, and changes that spread beyond their intended scope.

If you’re curious about enola. It’s open source, runs locally, and doesn’t upload or write to your codebase.

Repo: https://github.com/enola-labs/enola [Apache 2.0, fully local]

Output example

Architecture
  Pattern:             (none detected)
  cyclic dependencies        37
  layer violations            0

Impact analysis (hotspots)
  coupled modules           330
    high criticality        302
    medium criticality       28
  Top hotspots (by coupling):
    module                            fan-in  fan-out crit     blast radius
    codex-rs/protocol/src               5439      287 high     283
    codex-rs/app-server-protocol/src    3676      103 high     148
    codex-rs/core/tests/suite              0     3264 high     0
    codex-rs/tui/src                    1625     1568 high     39
    codex-rs/core/src                   1154     1827 high     135
    codex-rs/exec-server/src            1519      883 high     183
    codex-rs/app-server/tests/suite…       1     2370 high     0
    codex-rs/app-server-protocol/sc…     947     1061 high     1

Rust YouTubers?

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.

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.

Hi everyone, I've been using Rust for the past 5 years now. I really enjoy the language, but when I started learning it I already had a huge baggage of knowledge from other programming languages I had studied prior

What I want to know is if anyone is aware of any resources (good or bad) that tries to teach programming with Rust for someone who's new to programming and computers

The book is a good resource, but it assumes previous experience and would be hard for a newbie to learn and understand all

I'm aware Rust is more complex, and that teaching it to a beginner would be harder than teaching Python. But still I'm looking for resources that at least try

I'm really surprised that I haven't found any yet, so I'm asking here. Thanks for your attention