Hi everyone!

I wanted a fast, frictionless way to dictate text on Windows without relying on clunky built-in tools or expensive subscription-based software. So I built Aura — a lightweight, native helper written in Rust (Tauri).

It runs in your system tray, listens to a global hotkey (like Alt + V), and transcribes your voice directly into any active text field.

GitHub Repository: https://github.com/malashkadev/aura

https://i.redd.it/z5xmkblmmgbh1.gif

Key Features:

• Global Hotkey & Tray Integration: Hold to talk, or short-press to latch recording (toggle mode). Esc cancels.
• Dual Engines:
  • Local: Fully offline transcription using whisper.cpp (automatically downloads Tiny/Base/Small/Medium models).
  • Cloud: Gemini, OpenAI, or Groq (Whisper + Llama) for near-instant execution.
• AI Cleanup: Automatically formats transcripts, removes filler words (like "um", "uh"), fixes grammar, and structures paragraphs.
• Privacy Focused & No Subscriptions: You use your own free-tier API keys (e.g. Groq/Gemini have massive free tiers) or run 100% locally.
• Focus Guard: Ensures that if you switch active windows while the transcription is processing, the text won't be typed into the wrong window.
• Open Source: Fully licensed under AGPLv3.

Why build this?

Most voice dictation software either sends all your telemetry to unknown servers, locks basic features behind a subscription, or types raw transcription files filled with "uhs" and "ums" without formatting. Aura acts as a system-wide wrapper that pipes your voice to the engine of your choice, cleans it up, and simulates typing instantly.

I'd love to hear your feedback, feature requests, or contributions! Feel free to check out the repo and grab the pre-compiled installer.

the direct deps in my Cargo.toml I sort of track. maybe 20 lines, I picked each one, I roughly know what they do. Then cargo update rewrites the lockfile and cargo tree comes back a couple hundred crates deep, and those transitive ones are what actually gets compiled into the binary.

'audit your dependencies' gets said like the tree is one flat list. It isn't. the crates you chose and the crates pulled in three levels under them are two separate awareness problems, and I only have a real handle on the first. the second layer just quietly accretes every time some direct dep bumps its own deps.

what gets me is the only moment a transitive crate ever enters my head is a failed build or a cargo audit hit. so my early warning system is basically 'it already went wrong'.

so do you actually review the transitive layer, pin it, read anything at all about the crates two or three levels down. Or is it settled-until-it-isn't, which is honestly where I've landed.

I'm looking into creating a CAD-like application (though extremely domain-specific). Is it possible to use some GUI framework like Qt or Gtk and host a view running the Bevy engine for visualization and manipulation? Or would I have to create all the UI in Bevy?

I'm the author, sharing this here because it's a narrow, annoying problem most of us have hit on an engagement: the attack box's clock drifts from the DC's, Kerberos throws KRB_AP_ERR_SKEW, and the usual fix (ntpdate or rdate against the DC) needs root and clobbers your whole system clock, not just Kerberos. Other processes, logs, TLS all shift too, and on a VM the hypervisor often stomps your fix a few seconds later unless you also disable host time sync.

skewrun finds the DC's real time by talking to it directly (CLDAP, SMB, NTP, Kerberos, or NTLM), then wraps your target command with libfaketime via LD_PRELOAD, so only that process sees the corrected time. The machine's own clock never changes.

Since v0.9.0 it's split into a pure Rust library (ad-time) and a CLI (skewrun) built on top, so the protocol sources are usable standalone in other tooling.

One thing from this release that might be useful to others doing packet-level OPSEC work: the Kerberos AS-REQ till field isn't computed by Windows, it's a hardcoded constant (20370913024805Z, Sept 13 2037) since at least Server 2003, confirmed via a Heimdal KDC bug report with real captures and the leaked Windows Server 2003 source. Computing now + jitter instead of hardcoding that value is a detectable difference. Full writeup and two more similar decisions (SMB dialect list, CLDAP baseline) are in the repo's ADRs.

Install: cargo install skewrun (or a static musl binary in releases, no toolchain needed)
Repo: https://github.com/JVBotelho/skewrun

Feedback and issues welcome, especially if anyone has actually captured traffic to confirm or refute the till finding, that part's still on my list.

This is a follow-up post for when I created ratatuefi (https://www.reddit.com/r/rust/comments/1uiyqe5/ratatui_app_running_baremetal_uefi_application/), a crate providing a no_std UEFI backend for Ratatui.

Using ratatuefi, I have now created a sort of rudimentary bootloader application.

It simply scans for .efi-files in discovered filesystems and presents them in a TUI. The goal is to eventually create something rivaling Ventoy, where you can directly boot into ISO files.

For now, I think it does its job very well, let me know if you find it useful!

• efimux: https://github.com/sermuns/efimux

• ratatuefi: https://github.com/sermuns/ratatuefi

I've been using Rust for a while now, but one thing has been bugging me ever since I started - the Copy trait exists on some structs without any explicit surface level warning/annotation.

I initially brushed it off, thinking that there must be a reason why it is the way it is, you can just remember the basic Rust types that implement it.

But then you get to libraries. Does a certain struct implement Copy? Well, in VSCode you can peek the implementation, see if Copy is in the derive block. Not the most ergonomic solution, not too bad either.

But that's bulletproof. When I was working with a very popular library (don't remember the exact one, might've been rusqlite), Copy wasn't in the derive block, so I assumed that it wasn't implemented. Wrong. It was implemented somewhere at the bottom, because they were making a custom implementation - found that out later. This means that really you should peek every implementation and Ctrl+F for "Copy" to be sure.

So with that in mind, don't you think that right now Copy is too hidden/implicit? This is more about rust analyzer rather than Rust itself. On-hover tooltip could show "implements Copy" at the top, or show all traits at the bottom, or have a separate button to list all traits.

To me personally it still feels very wrong that in a language where we always explicitly track data ownership, we have this thing that fundamentally affects ownership and requires a multi step workflow to check for.

Also, what's your solution/workaround to this? The most workable one I found is the setting in rust analyzer to show moves explicitly in your code. Though I don't use it. Don't want the added verbosity, I just need to check specific structs, so for now I'm still using the peek + Ctrl+F (which honestly sucks, too much friction for checking something this important).

I want to improve my rust skills by contributing to OSS projects on a consistent basis.

My professional work involves a lot of rust but it's limited to web development. I want to explore other areas (Databases , AI toolchain , agent frameworks)

Is there anyone here who would like help on their project. Would love to collaborate.

A mini-lesson about the stack, registers, memory, and breaking stuff.

Ok so I am a professional Go dev of 10 years. I've worked with Java and Python in a previous life. My background is mostly infrastructure and cloud, but I also work a lot with technologies like Kafka and AMPQ. I'd say my career has had a lot of variety. More importantly I've been working with Zig for side projects for about 2 years now. And I am a HUGE Zig fan. I'm just making this clear so you can understand my perspective.

So my history with Rust is an interesting one. I've actually been interested in Rust for 10 years (about the same length of time I've been working with Go). But I think there had been a lot of disqualifiers in the past. Some were silly (lack of IDE support 10 years ago) and others were that I didn't really find a use for Rust. I knew I didn't want to use it for simple API programming. I hadn't seriously done low level dev. And I felt Go fit a lot of things better.

But I recently found a good use case a few months ago. I decided to take the plunge and learn Rust through a serious project. I wanted to build a KV store from scratch. Its something I had been wanting to do for years at this point. And I felt this was a valid use case for Rust. So I went and tried to wrestle with the language. I haven't finished my project but I've written about 1000 lines of code. And its on a fairly complex domain, so I think it gives me some understanding of the language

Things I really like:

Cargo! Oh my God do I love cargo. I also love Rust-analyzer. It is super helpful when navigating the languages.

Despite Go having more market share Rust ecosystem and toolchain feels a lot more cohesive and mature

The compiler is very very helpul. Great error messages and sometimes links to the problem

Complex, but also feels pretty easy to learn

I like the error handling. This I haven't go into much

Standard library seems fairly small and simple to navigate.

I find documentation amazing. Despite Go being more popular, its documentation is lacking in many places. Its even WORSE for Zig. The documentation made me think more about my Java days. It feels like I'm dealing with a very mature language despite it being relatively young.

What I don't love or hate but find "interesting":

Trait bounds and trait composition. I can see where some interesting architectural design can emerge from it. But it makes things overly abstract

Derive macros are interesting to work with. Working with Serde and using derive macros can feel more ergonomic than the more explict approach of Rust and Zig

Rust ships with its own LLDB implementation

Ok things I don't like:

Borrrowing and ownership. It feels like a puzzle at every step. This is where I get "stuck" and need to look things up or ask AI to explain. But I don't feel I am building a good intuition behind these rules. Like I kind of get it, but it still feel like I'm navigating a minefield

Personal preference. APIs for libraries are fairly easy to use, and the Rust community keeps a high standard for documentation. But in both Go and Zig, there is a tendency to look under the hood to see whats going on. I feel Rust SDKs and libraries really don't promote this. I find it hard to understand most of the time.

Rust doesn't have hidden allocations. But that's understood through convention and rarely something entirely obvious unless you have certain assumptions about the language itself.

I praised rust-analyzer but it does get distracting. Often times slows down neovim quite a bit. It can get very intrusive. I can imagine that it can get very irritating if I had a better handle of the language

Rust can be a bit verbose. Verbosity to me is not a bad thing. Go and Zig are both quite verbose. Zig is probably even more verbose. But I think the reason "why" its verbose matters. Zig is verbose because its trying to tell you everything happening under the hood in a very explicit way. Go is verbose because its trying to communicate clarity. Rust verbosity feels more ceremonial. It feels its verbose because the compiler demands you be. And it can feel like I'm performing for the compiler and less because I trying to communicate intent.

Final assessment:

I still have a ton to learn. But due to building a KV store from scratch I am able to confront some of the more complex aspects of Rust. With that said I find that it has a great toolchain, tons of educational material, and a very helpful compiler. It makes it fairly easy to learn. Even with the impetus borrow checker, it feels the language gives you everything you need to learn.

I find it enjoyable and fun in many places. I can see why the community has very vocal and strong supporters. But I will say that I just enjoy Zig a lot more. It may have less safety but it fits the way I like to code a bit more.

However I can see myself using both languages for different purposes. So my overall score is a strong 7/10. I am still getting tripped up by the borrow checker but the language is really fun to work with.

What resources would you recommend for learning Async Rust? Books, blogs, videos, GitHub repos, courses—anything that’s helped you.

Im building reverse proxy. Is there any other helpful crates for http-parsing and modifying headers.