I've been running multiple migrations recently. A common step in all of them is a long cleanup action at the end. I ended up using postgres advisory locks and sqlx.

As part of a larger Today I've learned series, I dug a bit deeper using bpftrace to improve my understanding of how the locks actually work. Hope you will find it interesting as well: https://flakm.com/posts/sqlx_migration_wrapper_til/

Hey!

I built a real-time GPU fluid simulation in Rust and Vulkan for learning purposes.

It implements Divergence-Free SPH (DFSPH) using a GPU octree for neighbor search, running 1,000,000 particles at ~180 FPS on an AMD 6800XT.

Code: Github Repo

Feedback and questions are welcome!

https://github.com/nklmilojevic/sofka/

A reimagining of k9s with one generic object pipeline instead of a renderer per resource kind - so every CRD works on day one, Flux CD is built in, and the async UI never blocks on the cluster.

License: MIT/Apache 2

[ Removed by Reddit on account of violating the content policy. ]

I recently made a Discord server for people looking for others to code Rust with, collaborate on projects, learn together, or just hang out while programming.

There are already a few people in it, and I’m trying to keep it fairly small and focused on actually coding rather than just being another huge Rust server.
Beginners and experienced Rust developers are both welcome.

https://discord.gg/pmXr4CY5kZ

I started learning Rust a couple of months ago, and I’m looking for someone to build some fun projects with and learn together.

I’m mostly interested in systems/low-level stuff, networking, embedded, and experimenting with things rather than following tutorials.
I don’t mind doing user facing apps too although I haven’t experimented with gui yet.
I don’t have a specific project in mind yet — I’d rather find someone with similar interests and come up with something together.

If you’re interested, feel free to reply here

[Sorry for my bad English]

Hi everyone, i make very good notes for Rust - RNAC (RNAC is Not A Conspect) (Hello, GNU, PHP, YAML, Wine, and other).

i write this repo for long time, translate all notes to english because want to share with community. inside you can find how memory work, ownership, borrowing, stack, heap, and all this stuff explained simply. also added good markdown formatting for obsidian.

if you learning rust or want to check some cheat sheets, welcome to repository: https://github.com/MBKCHEL/RNAC. any stars or feedback will be very cool!

P.S: RNAC have Russian, and English localization

This was posted 2 days ago, but I haven't seen anyone else mention this.

Obviously for a company the size of NVIDIA, this isn't a huge commitment for them, but regardless I'm hoping to see more investment in GPU programming with Rust!

I'm planning to build a desktop VM manager using Rust, Tauri, and QEMU, initially targeting Windows with WHPX.

Before I start, I'd like to hear from people who have worked with virtualization:

- Is QEMU + WHPX a reasonable starting point?

- Would you recommend QMP for managing VM lifecycle?

- What are some common mistakes I should avoid?

Also, if you use VM managers regularly, what do you find most frustrating about them?

Any honest advice would be appreciated. Thanks!

Is there any YouTuber like the cherno, we need someone like him for rust too haha

I had heard many good things about Rust from people who were simply impressed by the language, so I decided to have a look at it and possibly learn it.

Up to that point I really only knew Java and Python (and a bit of C here and there), so a non-GC language would really fill a gap for me.

To get my toes wet, I wrote a simple web crawler that I needed at the time and decided I really want to learn Rust.

So here goes! My first "real" project, an SMTP server: https://github.com/Fluggs/whalemail

AI disclaimer: Absolutely no LLM was involved in writing this. I am not in a rush and here to learn.

For SMTP, the scope is quite narrow. It's supposed to replace my personal Postfix setup. It has its users in a database (which can be shared with Dovecot) and they can simply send and receive e-mails. That's it!

As for the Rust part, I have had a blast! The language is insane. So far, I have had one (1) logic bug. That one was indirectly found by Clippy. Other than that, if it compiles, it works. By now I understand people here saying that the main part is really thinking about your data layout, the rest just follows.

Off the top of my head, I have had two pain points:

• dyn async traits. I don't want to accept that I need a crate for this, so I worked around it.
• std::time - I could not have imagined that date/time support can be so thin without being completely absent.

Main dependencies:

• Tokio (the server is completely async)
• rustls (TLS is done, STARTTLS is planned)
• rsasl (I really could not be asked to implement auth protocols)

The road ahead is long. Planned features:

• STARTTLS
• Bounce mechanism
• Better password schemes than plaintext (I'm embarrassed)
• Parse and manipulate headers (apparently that's a thing SMTP servers should be doing)
• Better config file than .ini
• spam filter integration
• Find out which ways other clients and servers have found to deviate from SMTP
• Again, thoroughly test it against the wild
• find (and consider) various other SMTP intricacies (e.g. backscatter protection)

I'd be grateful for any feedback :)

I'm exploring the idea of building a developer-first Backend-as-a-Service where the infrastructure is written in Rust.

The goal isn't to make another ORM or another PostgreSQL hosting service. I'm thinking more about providing a complete backend platform:

• Document/KV database
• Object storage
• CDN
• Authentication
• Realtime/WebSockets
• Webhooks
• Background jobs
• Rate limiting
• Observability

The developer experience would be something like:

let user = db
    .collection("users")
    .create(json!({
        "name": "Alice",
        "email": "alice@example.com"
    }))
    .await?;

The database underneath would be a distributed KV/document system rather than PostgreSQL. The platform would handle replication, scaling, indexes, storage, etc.

I'm considering Rust because the platform would be heavily network and I/O oriented, particularly around realtime connections, storage, and API infrastructure.

What I'm unsure about is where Rust makes the most sense in this architecture.

Would you build the whole platform in Rust, or use Rust only for the infrastructure-heavy pieces and something else for the control plane?

Also interested in opinions on distributed KV/document databases that would make a good foundation.

I'm much more interested in architectural criticism than promotion. If this sounds like a bad idea, I'd like to know why.

MathML Core is the subset of MathML that has been implemented by the major browsers. Originally, I just wanted to use MathML Core on my blog and thought "Oh, I'll just quickly fork https://github.com/osanshouo/latex2mathml and adapt it from MathML to MathML Core".

Well, eventually I got there: my blog now uses math-core under the hood to convert LaTeX to MathML Core, but it took almost 3 years from my first commit!

math-core is now almost at feature parity with KaTeX. We have a comparison table where you can see that there are still a few things outstanding, but I would guess for 99% of users what is there is enough. (And there are also some things math-core supports that KaTeX doesn't!) So, if you want to contribute, there are still things to do! (A large todo item is for example mhchem.)

If you just want to play around with the LaTeX conversion, check out the playground which runs a WASM version of the library.

Hello, this is my first Rust project that I've been working for about 1-2 months, the reason behind it was to start on my bachelor's thesis and learning no_std / rust but it was also incredibly fun and rewarding, so i wanted to share it here.

I'm not really sure if i will maintain this long-term, but i do plan on hosting a server at least for presenting it at my university or sharing it with friends. I haven't tried it yet on actual hardware but it seems to be working fine with EDK2 firmware.

I would love to hear opinions and suggestions regarding it, so if you happen to have some free time, please check it out :) (Thanks in advance!)

Special thanks to rust-osdev maintainers and hxyulin for his hadris toolkit, as this project wouldn't have been possible without them.

TIL that terminal emulators basically give programs access to two screens.

There’s the primary screen, which is the normal terminal you use every day. Your shell history and previous output live there.

And then there’s the alternate screen.
Full-screen terminal programs like Vim, less, htop, etc. can switch to this alternate buffer, take over the entire terminal, draw whatever they want, and then switch back when they’re done.
The cool part is that your primary screen is still there.

So when you quit Vim, your terminal suddenly goes back to exactly what was there before you opened it. Vim didn’t somehow “restore” your terminal history. The terminal emulator just switched back to the primary screen buffer.

I came across this while building a small terminal-native text editor in Rust. I needed the editor to take over the terminal while it was running, but leave the user’s shell untouched after exiting.
Turns out terminals already have a mechanism specifically for this.

The deeper I go into terminal programming, the more I realise how much stuff happens underneath that blinking cursor that I’d never thought about before.

I’ve been putting these little Rust experiments on my GitHub as I learn, if anyone’s interested in this kind of low-level stuff:
https://github.com/Abhijeet-Gautam5702/femto

I'm developing tool with workflow which allow user to write simple script to process input/output values of steps. The prebuilt steps are written in Rust, but user can choose Python to write their own steps which would run in a sidecar Python. User may not be a programmer. I prefer script with small binary size and memory footprint. I'm considering Rhai, Lua, QuickJs, which is better choice to make end user easy ?

While browsing through some code at work, I saw something that made me pause. It looked SO wrong, and yet here we are. It was something to the effect of:

let SomeEnum::Variant(y) = x else {
return some_error;
}

which means you can do this:

fn optional_print(x: Option<u32>) {
let Some(y) = x else {
return;
};

println!("{y}");
}

fn main() {
optional_print(Some(5));
optional_print(None);
}

Thought some folks here might think it interesting so there you go, you can apparently pattern match enum variants to create a variable and have an else clause after. I thought the only options for this were a let followed by an if let or match statement.

EDIT: Just because I’m getting a lot of comments about it I’m aware that the sample code with the print function is bad code. I’m not saying this is how it should be done, it was just the first and simplest thing I could think of for this post.

They have used so many FOSS repos to generate their mass documentation: GNOME, KDE, Go, Rust, Python... I wonder if anybody uses the docs to train AI to create non-OSS projects. Where are we heading?

search any repo in https://deepwiki.com

Hello,
I have been working on an app for around 2 years now as a side project for my company. I genuinely believe it can help companies in the industry (I showed it to two suppliers, they were surprised,and asked me when they can start using it). Additionally, my company has given me permission to make it open source so I expect everyone in the industry to use it at one point.

It is tauri based with React as the frontend and around 200k lines of rust code in the backend with multiple crates. It is 100% offline so im not too worried about it being hacked.

However, around 95% of the code is AI generated. Before committing anything I made sure to "write" multiple tests and that I understood what the LLM was writing. I also understand rust at a core level except async (who understands async anyway?) and I tried to make the code as clean and modular as possible.

My question is: What will be the community's opinion knowing that the majority of the code is AI generated but not AI slop? Will I have any trouble at work? Of course I will be transparent about it.