tokio VS iced

That's it. Everything else — async/await, actors, work-stealing executors, lock-free data structures — lives in the ecosystem (tokio, rayon, crossbeam, actix, etc.).

Building LlamaStash brought me back to a lot of that, but the ground has shifted. ratatui (the maintained fork of tui-rs) is a real, polished framework now. tokio makes async daemons boring in a good way. hyper gives you a respectable HTTP server in a few hundred lines. crossterm handles the cross-platform terminal mess. sysinfo covers host metrics. The pieces are all there and you have LLMs to help you speed up everything to 10x.

The async ecosystem has matured to the point where this is actually enjoyable to build now. Tokio is the async runtime most production Rust services are built on, and Axum gives you an ergonomic HTTP layer that won’t make you miss Go’s simplicity quite as much as you’d expect.

Tokio — Async runtime para Rust — Runtime más usado para servicios de red y concurrencia en Rust.

Understanding the internals won't change how you write async Rust day to day, but it changes how you think about it. That mental model helps when you find you're on one of Rust's sharp edges. If you want to go deeper, the tokio source, this blog post by Priyanka Yadav, and Jon Gjengset's async Rust series are the best next steps.

In fastjson-api, I leveraged Rust’s async capabilities with tokio to handle thousands of simultaneous connections efficiently. The project demonstrates how Rust’s zero-cost abstractions can lead to a lightweight, high-throughput API server.

https://github.com/tokio-rs/tokio/pull/7622

The tests do not appear to simulate the queue in Loom, which would be a very, very good idea.

This stuff is _hard_, and I almost certainly made a mistake in the above. In practice, the queue is probably fine to use, but I wouldn't be shocked if there's a heisenbug lurking in this codebase that manifests something like: it all works fine now, but in the next LLVM version an optimization pass which breaks it on ARM, and after that the queue yield duplicate values in a busy loop every few million reads which is only triggered in release mode on Graviton processors.

Or something. Like I said, this stuff is _hard_. I wrote a very detailed simulator for the Rust/C++ memory model, have implemented dozens of lockless algorithms, and I still make a mistake every time I go to write code. You need to simulate it with something like Loom to have any hope of a robust implementation.

For anyone interested in learning about Rust's memory model, I can't recommend enough Rust Atomics and Locks:

https://marabos.nl/atomics/

Asynchronous Processing: With the power of tokio, the server handles DNS queries asynchronously, with no blocking, improving scalability and latency.

It's definitely a bit contrived, but to me it's also emblematic of the issues with async Rust.

The note on mpsc::Sender::send losing the message on drop [1] was actually added by me [2], after I wrote the Oxide RFD on cancellations [3] that this talk is a distilled form of. So even the great folks on the Tokio project hadn't considered this particular landmine.

[1] https://docs.rs/tokio/latest/tokio/sync/mpsc/struct.Sender.h...

[2] https://github.com/tokio-rs/tokio/pull/5947

[3] https://rfd.shared.oxide.computer/rfd/0400

Asynchronous programming has seen considerable adoption, and Rust's Tokio runtime provides an excellent framework for writing asynchronous code. Utilizing async/await syntax in Rust allows for efficient concurrent execution in I/O-bound applications.

I tried out numerous audio tagging apps (Kid3, Picard, …) and wasn't happy with any of them. They all try to work with some kind of library system of have a really bad UX (single line input for Lyrics???).

Therefore I decided to build one that is simple, fast, with great defaults: https://github.com/ad-si/Taguar

It's built with Rust's [Iced] and [lofty].

Looking forward to your feedback!

[Iced]: https://iced.rs

for serialization along with plain text. A single line is a message.

The client is built with [iced](https://github.com/iced-rs/iced), so it is a

Rewrite Muscurdi - Password Manager in Rust with iced, dioxus and/or tauri ❌ Did not any of those, but I have explored tauri and I am some ideas on some other sideprojects with it. I did a little todo-app in tauri and svelte with a little persistence layer and it is lovely.

With the new PopOS Cosmic and them dumping GNOME for their own UI framework based on Iced (and based on rust), I have high hopes that things will move to more linux (especially for folks here who are rust-heads).

[0]: https://iced.rs/

> When you start needing things like undo/redo you suspiciously start architecting something that smells like the elm architecture.

Well Iced itself claims to be inspired by the Elm Arch, so that checks out (see the first line under the Overview section of the Readme https://github.com/iced-rs/iced )

It seems like trading applications tend to be what demands the performance to push R&D like this for Rust GUI. My team at Kraken worked on https://iced.rs/ which powers https://www.kraken.com/desktop, a very similar application. You can definitely feel the difference in a Rust GUI vs. a web view. It can maintain high frame rates doing so much on the screen at once.

Elsewhere on the thread there there was a mention of this issue for the underlying GUI toolkit: https://github.com/iced-rs/iced/issues/552

In the meanwhile changing the font size and colors/theme might be the best option:

https://halloy.chat/configuration/font.html

https://halloy.chat/configuration/themes/index.html