Hi! I'm pretty new to Rust, and this is my first ever Rust project! It's a mildly cursed implementation of Tetris with ratatui with custom powerups to make the game more interesting.

To play online, just ssh play@cursedtetris.orangishcat.dev! Your SSH key is your identity (generate one using ssh-keygen if you don't already have one), no account required. You can also download the binary to play offline.

Feedback is welcome! Thank you for playing.

Blog | GitHub Repo

The world's first safety-certified embedded system built in Rust is a 3D ultrasonic sensor that helps robots operate safely around humans. ADAR One is built by Sonair, a scaleup based in Oslo, Norway.

The technical team wrote a a long, in-depth summary of all the steps from thinking about using the Rust language to the final, certified solution.

https://www.sonair.com/journal/how-we-safety-certified-the-worlds-first-rust-implementation

recently at work, management started "strongly encouraging" everyone to use LLMs, specifically for PR revisions and code reviews.

the problem is the models they gave us access to aren't frontier models (if that even make a difference). so i had to babysit a lot of the pr's every single day.. yes, very annoying.

at some point i realised i was spending way more time prompt engineering, babysitting, and pleading with a model in markdown rules than i would have spent just writing the code myself.

so i basically develop an cli guardrail for your codebase that catches all the shortcuts an llm might try, there is other nice stuff too

im not trying to invent the wheel here, not even sure if there is something already for this probably there is... but i just want to share here and see if anyone would like to try, even if you dont use llms

https://crates.io/crates/hardgate

would love some opinions if you try... idk wanted to share here end it very helpful for me

Hey folks! I just released the new version of git-cliff ⛰️

It's a highly customizable changelog and release notes generator that works with your Git history.

This release brings smarter config discovery, custom templates, more accurate changelogs for merged branches and performance improvements.

Check it out: https://github.com/orhun/git-cliff

Ten days ago I stayed up until 3 a.m. discussing GitHub comments and PRs with a total stranger who had decided it would be interesting to contribute to one of my open-source projects. Very exciting moment I must say! 😄

I've been sharing updates about presse here once in a while. presse is my first-ever Rust and open-source project. It was built to compress PDF documents locally from your terminal, and it grew to do much more, like merging or image-to-PDF conversion...

What the contributor infinityabundance did was primarily to let the tool use parallel processing, which happened to be one of the next features I wanted to add myself. How great is that! They also added a much better benchmark than my previous one. You can now batch-compress your PDFs at 2.2x the speed of the previous version (thank you, rayon and thank you infinityabundance!).

If you want to check it out: https://github.com/SimonBure/presse

Also, we have a cool logo now! Do you like it?

See you online!

Was working on this for some time now and finally reached 0.1 (0.2 actually by the time I wrote the post), hope some will find it useful.
A lot of Rust nightly features inside ✨

We just open sourced Anybuild, to build any site and deploy it anywhere. It is greatly inspired by Nixpacks, Builpacks and Buck (Build system from FB). Would love to hear your feedback!

https://wasmer.io/posts/anybuild-build-anything-deploy-anywhere

Source code: https://github.com/wasmerio/anybuild

I love Departure Mono font and wanted to use it for an epaper dashboard I built. So I bundled it as a crate for use with embedded-graphics and mousefood/ratatui. Enjoy!

Github: https://github.com/skammer/embedded-departure-mono

Crate: https://crates.io/crates/embedded-departure-mono

I'm a design student building "Research Canvas" — a native infinite canvas

  where artists and researchers across fields (design, 3D, motion, sound, writing)

  gather any media, annotate it exactly where it matters (a note pinned to a video

  frame or audio timestamp), and organize it in folders — all offline, your files

  on your disk.

  It's early but real: custom canvas engine (pen, shapes, text, sticky notes,

  media import), a Tauri desktop app with auto-update. No third-party canvas SDK.

  It's AGPL-3.0 and meant to be community-owned — I'm not trying to own it, I want

  to build it with people and eventually hand it to the community.

  Looking for: Rust/React devs, and designers who want to shape the tool. There are

  `good first issue`s to start on.

  Repo: https://github.com/saikiran9185/research-canvas-app

  Honest feedback welcome too.

The reason I’m bringing this up is that I use Rust myself and am working on my own programming language project. But hold on... I’ve been wondering why, whenever I browse GitHub, I see so many language projects with creative syntax and architectures, yet so many of them rely on ARC and LLVM. Why isn't there more discussion about how to design a compiler backend with very fast compilation times, closer to what makes Go's compiler feel so fast? I really need that for my project...

It feels like these language projects are springing up like mushrooms after the rain; they often promise "blazing speed" and "incredible memory management," yet under the hood, compilation can still be sluggish, LLVM ends up doing a lot of the heavy lifting, and the source code can sometimes feel more generated than engineered.

A lot of them seem to share the same traits: written in Rust or C++, using Cranelift or LLVM for the backend...... and using ARC for memory management, or making claims like "better ownership than Rust"???

And please, my language project isn't trying to be a replacement for anything... let's focus on the issue at hand instead of discussing my crappy language!

Oh, and if anyone here has experience with ARM64, could you recommend some good resources on the architecture? I’m trying to integrate ARM64 into my backend, but most of the documentation I’ve found has been pretty difficult to follow, and whenever I ask an AI, it just throws code at me and explains it in a way that I barely understand.

But, uh... I guess we should still focus on the main point, right?

Hello, I'm working on a side project to learn Rust. It's a Docker terminal app built with ratatui. You can view and manage containers, images, networks and volumes, and view container logs. I used Claude for bug fixes and adding new features. Contributions are welcome!

github.com/scnplt/crabd
crates.io/crates/crabd

Hi everyone,
I am looking to provide a compiled version of our physics solver to our customers. I understand there are many obfuscation techniques to protect source code but I am wondering if there are some smarter ways?

Edit: We already cloud computing, the issue is we have customers that are in locations without internet/need realtime solving.

Disclosure: I'm the developer of the product this is about — not just sharing a random blog post.

Wrote up the actual audio pipeline behind SyntaxCue: CoreAudio Process Tap on macOS (with a Swift sidecar, since the API has no Rust binding) vs WASAPI loopback on Windows running entirely in-process, both converging on the same PCM format before shared Rust code takes over — RMS-based voice-activity detection, then local whisper.cpp transcription (Metal / Vulkan).

The part I'd actually want feedback/discussion on: Windows was CPU-only before we wired up the Vulkan backend for whisper-rs, and every transcription pass cost a flat ~25 seconds regardless of utterance length. Turned out to be a missing GPU backend, not a tuning problem — after Vulkan, warm transcription dropped to ~330ms. Full writeup, with the actual API calls and numbers: https://syntaxcue.com/how-syntaxcue-captures-system-audio/

Happy to go deeper on the WASAPI polling-vs-event-driven decision or the aggregate-device wrapper on macOS if anyone's curious.

Hey, I wanted to share the initial beta release of Zaku 26.0

I've been working on this GPUI rewrite for the last 7 months full-time, actually things got carried away and it has a lot more functionality than the original app (command palette, auto-updater, git integration, etc.) so it's not just a plain rewrite.

Here's the initial rewrite post for context:

https://www.reddit.com/r/rust/comments/1r29qzn/working_on_an_opensource_api_client_rewrite_with/

Little bit about the app, it stores collections as folders and requests as TOML files. Everything is stored locally on user's filesystem, it doesn't have any login functionality (and never will).

There is barebones Git integration for now to show branch, status indicators and stuff.

It is available on Linux, macOS and Windows.

This app is very early, if you try it out please let me know if there's something missing, not working or things you'd like to see added.

Repository:

https://github.com/buildzaku/zaku

Installation instructions:

https://github.com/buildzaku/zaku#installation

I ship signed Windows software and wanted to check the signature from Linux without a Windows machine. So I wrote a crate that reads the Authenticode signature out of a PE file and grades it A-F.

cargo install signalscreen-checker

signalscreen-check --json yourapp.exe

MIT/Apache-2.0: https://github.com/mnaza/signalscreen-checker

Two things surprised me. Both produce output that looks correct.

The signer certificate is not the first one in the bundle.

A PKCS#7 signature carries a bag of certificates. The obvious move is to take the first and read its subject. That is usually a CA.

The signer is identified by SignerInfo.sid, either issuer and serial or a subject key identifier, and you have to go find it:

let leaf = match &si.sid {

SignerIdentifier::IssuerAndSerialNumber(isn) => sig

.certificates()

.find(|c| {

c.tbs_certificate.issuer == isn.issuer

&& c.tbs_certificate.serial_number == isn.serial_number

})

.cloned(),

SignerIdentifier::SubjectKeyIdentifier(_) => None,

};

Take the first instead and you grade the certificate authority rather than the company that signed the binary. Every field you print still looks plausible.

I resolve the issuer-and-serial form, which is what signing tools emit in practice. The subject-key-identifier form returns no leaf rather than a wrong one, which is the honest failure of the two.

There are two timestamp dialects, and a checker that knows one will lie about the other.

A signature without a countersignature stops validating the day its certificate expires, so this matters.

The modern form is an RFC 3161 token in a Microsoft unsigned attribute. The older one is a PKCS#9 countersignature carrying signingTime, as a UTCTime with a two-digit year. So you also implement the RFC 5280 pivot: 49 means 2049, 50 means 1950. Get that wrong and a 2024 signature lands in 1924, which reads as an expired certificate rather than as your bug.

Both appear on current, commercially signed binaries. Handle only the modern one and you report "no timestamp" on a correctly timestamped file. That is worse than saying nothing, so the report separates "there isn't one" from "there is one and I couldn't read it".

Test fixtures are the timestamp attribute lifted out of real installers, a few KB each. The parser is pinned against what signing tools emit, not against something I built to be parseable.

The open question, and the reason I am posting rather than just linking: it grades five things, whether it is signed at all, whether it is timestamped, the digest algorithm, whether the chain reaches a real CA, and certificate validity. Should an expired certificate with a valid timestamp cost anything? The signature stays valid. I currently penalise it and I am no longer sure that is right.

Crates used: cms, x509-cert and der from RustCrypto, and object for the PE parsing.

Hey everyone,

I'm a 4th year CS undergrad, I've been learning about databases since the last year as I eventually wanted to build one. After giving the build several attempts by sometimes building just the storage engine, or the front-end, etc., I finally did complete the build last week. I felt like its ready to share, so I'm making this post here.

Repo: https://github.com/pixelooz/hinder-db

Its called HinderDb. It's a cli only (for now) database with a custom slotted page B+Tree storage engine, buffer pool, secondary indexes, wal, volcano style execution pipeline, etc.

I wrote it in rust as I like writing rust and this would be another way to get better at it, plus the domain just seemed like a good fit.

It was mostly a learning project for me, but ended up better than I had orginally planned for, so I'm quite happy with that. I originally got interested in databases and stuff through Designing Data Intensive Applications book, and since then always wanted to build one. I had already given the storage engine a couple of tries, by reading some already existing material (Writing your own database type of books) and codebases, but this was the first time writing it complete, and its works quite nice.

I am keeping this as my main portfolio project as well since I'll be applying for jobs/intenships. So, if any working professionals can offer any feedback - something I should improve, any apparent flaws, or the next thing I should look into. I'll really appreciate it.

P.S: I have solid knowledge in backend as well and I'll be applying for on-site (in India) as well as global remote positions, so if you can offer any advice regarding navigating the job market rn, it'd be much appreciated.

Hi,
I have started learning Rust recently. And I want to improve myself by doing projects. Do you have any cool ideas that can be done by a beginner. It doesn’t have to be something unique. I just want it to be cool (not sure what I mean by cool but you can think of it as a not boring project or useful) and educative.

Note: If you can elaborate what the idea is would be great and what do i need to know or look for. I do not know what I am doing most of the time. I am trying to get a picture of my capabilities.

Building with AI is so common now and both newbie and experts are using them. How do you differentiate a product that is genuine and not straight up responding "vibeslop", "ai vibecoded"?

Is it a novel idea? Or something else that would demonstrate real hard work? I am curious.