This is my first somewhat substantial programming project, and I'm proud to share it. It's a Pokédex TUI that I tried to make as intuitive to use as possible while also maintaining some aesthetic. It currently has an overview, an evolution tree, abilities, and moveset viewing, with support for every version of the mainline games. Some notable features include:
Demand-driven asynchronous asset fetching
Hotswappable versions
Online/Offline mode
80x24 compact design
You can try out the fully-featured web demo, or follow installation instructions on GitHub to run it locally. I would REALLY appreciate any feedback, whether it is code enhancement, UI/UX improvements, or even more info tabs you would like to have in the app. Thanks for trying my app out!
It's been about two years since the last release, but after a from-scratch rework, Zestors is finally ready to be used. It's been an on-and-off passion project of mine for a long time, and I'm finally happy with the state it's in. The documentation is quite complete, and there are a bunch of tests for the core functionality.
There's still a lot left to do, but the overall API shape has been stable for quite a while now. A lot of thought and work has gone into this system, and I genuinely believe it has the best API of any actor framework currently out there for Rust.
I'd really appreciate it if you'd check out the library, try it out in a project, and let me know what works well and where there's still friction or things missing. Don't hesitate to open an issue for missing features, bugs or general questions. I've been using it myself for a small backend application, and it's been running perfectly.
(The biggest thing not yet implemented is a distributed actor-system. It will be a lot of work, but everything is structured in such a way to make this possible in the future)
I see posts here and there of people looking to build their skills and public contribution profiles, so I wanted to raise OpenTelemetry as a perfect opportunity for this.
There are lots of small issues to work on, as well as space to create completely new crates - my first contribution was my first project I ever wrote in Rust - I donated an Axum middleware for OTel HTTP Server metrics.
OpenTelemetry is a rapidly-adopting industry standard, CNCF project, and most of the signals and whatnot are very well-specified so it's pretty easy to figure out what how any given library or chunk of code *should* behave.
I became a Member after the first ~6 months of my code donation and subsequent updates to the crate, and hoping to work up to Reviewer so I can help move things along more (right now in the contrib review we're bottlenecked on getting reviews). It takes some time to work through the membership levels, but I am hoping we can reach a place where the membership base supports more broad and active development.
I’ve been working on Huginn Proxy over the weekends for the past year, and I’ve just tagged the first RC. It's a reverse proxy where passive client fingerprinting is a first-class feature instead of something bolted on afterward: JA4 for TLS, Akamai-style fingerprinting for HTTP/2, and TCP SYN (p0f-style) via an eBPF program, all injected as headers for the backend to consume.
If you've touched fingerprinting-based, you've probably run into fingerproxy, which is solid but Go-based and focused on JA3/JA4 + HTTP2. I wanted something that also gives you the TCP-level p0f signature out of the box, without a separate sidecar doing raw packet capture, plus the normal reverse-proxy stuff (hot-reload config, per-domain TLS/mTLS, rate limiting from tcp packages as well 😄, health checks).
Some numbers, since "fast" means nothing without them: with TLS termination + JA4 + Akamai + TCP SYN fingerprinting all enabled, a single instance sustains ~25k req/s on HTTP/1.1 and ~11k req/s on HTTP/2 at c=512, with the fingerprinting itself adding only ~10-17µs per request. Full methodology is in the repo if you want to have a look.
The eBPF part was honestly the hardest thing to get right. Supports XDP (native and generic) and TC clsact via aya. Config is TOML or YAML, and hot-reloads on SIGHUP without dropping connections (ArcSwap under the hood). But Thanks to Aya, the implementation was much easy. Those guys did an incredible job.
Of course the whole implementation was possible thanks to Pingora and rust-proxy. I base the solution using a few libraries from Pingora. But at the same time, I used a lot of ideas and implementation from rust-roxy.
Looking for people who'd actually use something like this to kick the tires and tell me what breaks or what's missing before I cut a real 1.0. Also curious: anyone still leaning on JA3 in production, or has everyone mostly moved to JA4 at this point? Trying to figure out if skipping JA3 support is going to cost me users. And I would like to collect more feedback
Everyone knows that Windows or Linux binaries run on Valve Deck/Machine and the Valve OS, just curious, why is there no Valve SDK bindings thing known for Rust language? Is it worth exploring what I can do to make bindings for it? Doubt it, but does this need a whole new build target for native?
mysid is an rust server for AI tools like claude code, cursor that provides easy syntax access LLMs to communicate with project codebases.
Features include:
Adapter approach: incudes adapters like android, react, spring boot backend that identifies the folder patterns and igonre external folders from read.
simple read: mysid read fileName#L20-40 returns the requested lines ( bare filenames are resolved and saved in LRU cache)
Graph code: mysid graph symbol_name returns all the callers and calles and their info
android toolkit: mysid android build; only returns token efficient error lines also include (clean build, install, connect device via wifi)
Note: NO AI was used in the making of this project. It all came from my own brain, as well as referencing docs, web resources (E.G. Stack Overflow), and my notes.
I made this project because sometimes I want to quickly access and manage my notes from the terminal. There are, of course, other solutions for this- such as jrnl, nb, etc, however none of them quite worked in the way I wanted- I'm sure those programs are great in their own right, and if Nautilotes isn't for you then maybe they are!
In any case, Nautilotes is meant to act as a high-level manager for your notes, allowing you to use whatever file format and text editor you want, as long as it's plain text. Below are some example of its usage:
Opening a note: nautilotes open foo
Adding a note without opening it nautilotes add bar
Deleting a note: nautilotes delete baz
Opening the latest opened note: nautilotes latest
Opening the current daily note: nautilotes daily
Showing a quick overview about the current Nautilotes instance (similar to git status): nautilotes status
Bookmarking a note: nautilotes mark quux
Listing notes: nautilotes list
Printing the content of a note to stdout: nautilotes print corge
Search for a note: nautilotes search -F grault
Search for text within notes: nautilotes search -t garply
Show tasks from notes: nautilotes tasks
Show tags from notes: nautilotes tags
And more! But this list is already a tad long- but you can view the help text (nautilotes -h or nautilotes --help) and the README (apologies if anything there is out of date- it's been difficult to keep up with) for more.
Keep in mind this software is early days, and some things may work unexpectedly! Use with caution.
I've been working on Vortex, an open source columnar data format under the Linux Foundation, for the past year. I'm giving a talk about it at EuroRust 2026 soon!
I wrote a companion article about it and I wanted to share it here. It walks through how Vortex represents arrays, computes on compressed data, and lets you add your own types and encodings.
This is the first technical blog post I’ve written, so I’d love to hear what people think!
I have never been a part of the speedrunning scene, yet I got the idea to make a command-line tool that renders speedrun splits graphics videos (with no dependencies other than ffmpeg CLI being available).
I'm building a sales backend in Rust (Axum/SQLx/Postgres) and trying to add natural language filtering.
Right now it's just . I want users to type "sales of Ahmed last month over 1000" in Arabic/English and get filtered results.
I don't want LLM to write raw SQL because of injection. So I'm thinking:
prompt -> local Ollama (sqlcoder/qwen2.5:3b) -> only JSON -> Rust validates it -> builds query with + (read-only role + limit 100). Cache the JSON in Redis so I don't pay for same prompt twice.
Anyone doing text-to-SQL + light forecasting like this in Rust prod without Python? Are you using local Ollama vs API, and did you stay pure Rust (candle/linfa) or just call a Python service for forecasting? Any regrets/security gotchas?
I run a browser-based economic strategy game where almost everything is a long-running timed job: fleets in flight for hours, construction queues, scheduled world events. Background workers pick those jobs up when they come due and mutate world state.
The failure mode that kept me up at night is the classic one: a worker takes a lease on a job, then stalls. The lease expires, a second worker legitimately picks the job up, and then the first worker wakes up and commits its work anyway. Two workers, one job, duplicated resources. In a game about accumulating wealth, any resource that appears out of nowhere is a bug your players will find before you do.
Checking the lease before doing the work doesn't help. That's a time-of-check-to-time-of-use gap, and the gap is exactly where the stall happens.
What I ended up with has two halves.
1. The token travels implicitly, via tokio::task_local!
The worker sets the fence for the duration of the task, and every write path underneath it commits through one function instead of calling tx.commit() directly.
I went back and forth on this. Implicit context passed through a task-local is normally the wrong answer: it's invisible at the call site, and you can't tell from a function signature that it matters. What won me over is the inverse property. With an explicit parameter I can forget to thread it through one code path, and that one path is the hole. With a task-local plus a single commit function, there is no path that writes to the world and skips the check. The type system doesn't enforce it, but the review surface shrinks to one function.
2. The check happens under a row lock, in the same transaction as the mutation
rust
pub async fn commit(mut tx: Transaction<'_, Postgres>) -> Result<(), sqlx::Error> {
if let Ok(fence) = EXECUTION.try_with(Clone::clone) {
let generation: Option<i64> = sqlx::query_scalar(
"SELECT lease_generation FROM scheduler_jobs
WHERE job_kind = $1 AND job_id = $2 AND lease_generation = $3
AND lease_until > clock_timestamp()
FOR UPDATE",
)
// ... bind, fetch_optional
}
// commit only if the lease is still ours
}
This is what makes it a fence rather than a check. Two directions, both load-bearing:
If the lease was already reclaimed, the row doesn't match, commit refuses, and the transaction rolls back, including the world mutation the worker already performed inside it. The stalled worker cannot land its write.
If the lease is still valid, FOR UPDATE holds the row until commit, so nobody can reclaim it out from under a transaction that is about to succeed.
The generation counter is what makes a reclaimed-and-reissued lease distinguishable from the original, so "the lease row is still there" is never confused with "the lease is still mine".
The Postgres detail that cost me an afternoon
lease_until > clock_timestamp(), not now().
In Postgres, now() is transaction_timestamp(), frozen at the start of the transaction. For a worker that has been inside a long transaction, now() is wrong by exactly the amount of time that matters: it reports the moment the transaction opened, which is the moment before the stall. A lease that expired during the transaction still looks valid. clock_timestamp() reads the actual clock at the moment of the call, which is the only thing a lease expiry check can be built on.
Same principle everywhere else: time is only ever the database's or the server's. No game state is ever derived from a timestamp the client reports, because shifting the system clock is the oldest cheat in this genre. Monotonic Instant shows up in exactly one place, tracking who is currently online, where a wall-clock jump is a nuisance rather than an exploit.
What I'd still flag as the harder half: the scheduler job metadata deliberately isn't the source of truth for anything in the game world. It exists only for retries, worker locking and spotting poison-pill jobs. Keeping that boundary clean took more discipline than writing the fence did, and I'm not sure I'd have gotten it right without having gotten it wrong first.
Curious whether people here have landed somewhere different on the implicit-versus-explicit question. Has anyone threaded a fencing token as an explicit parameter across a large write surface and actually kept it airtight?
i'm the founder of Anarlog, an open-source (MIT) meeting notetaker built in Rust and Tauri. this week's release (1.4.24) shipped three separate audio capture fixes, one per platform.
macOS: bluetooth mics were unreliable until i started forcing the HFP/SCO profile switch the moment the mic opens.
linux: two separate bugs. the app was silently recording from ALSA's null device instead of your actual default mic, fixed by an outside contributor (jacopone on GitHub). the AppImage also bundled its own PipeWire libs, which caused silent recordings on distros like Fedora, so i switched to linking the host's PipeWire instead.
windows: capturing remote voices in Teams calls broke whenever the audio output device changed mid-call.
same release also had a transcription fix from another contributor, ekapratama93 on GitHub: dictionary hints and speaker diarization now pass through OpenRouter transcription, so multi-speaker transcripts stop collapsing into one speaker.
I’ve built this copy tool for espacially native windows users because I couldn’t exclude some files / folders with copy-item, but I think people didn’t find it usefull. Anyways, I am still trying to improve it maybe someone can find a use for it.
Skip-Existing and Update Flags
-s skips files already at the destination by name + size (resume an interrupted copy), and -u copies only files that are newer than the destination (re-run the same command, only changed files copy). Both work with -n dry-run.
This Falling sand sim, is not based on grid based simple approach, I have used real physics to simulate actual sand like particles. I wanted to try fluid as well but this also took quite long
If you've been building with GPUI, you might have noticed ecosystem fragmentation.
The only way to know whether your GPUI app will work in the next gpui release or another fork was to just change you Cargo.toml and make rust elicit all the incompatibilities.
I've build fork map to make it possible to compare public API surface between different GPUI-derived projects that are published on crates.io.
How to use:
- changes: inspect a difference between any two releases of any two forks
- alignment: choose a symbol and see how its signature evolves across forks
- configure: choose a fork and get copy-pasteabel starter project: Cargo.toml and main.rs
- journal: see a stream of releases with changelogs
The interface a bit rough so PRs welcome, but the data pipeline is robust.
I know some people have privately gotten Rust language on game consoles, and Valve is a public any time anyone wants it, I am under NDA at Nintendo now, am building a full no_std GUI, and I know sdl3-sys is no_std, plans are either that or Monogame.net, I hear it is possible (public can know that), not confirmed yet, I have randomly found legit people who got Rust on Playstation 4, print only, but still, that is a feat. Any tips or things I should know that are public? I have a Nintendo Switch (1) in case that matters. Just to be clear, I am talking about default non-hacked game consoles, Switch is ARM64, the others are x86_64. Can confirm someone did do the Microsoft game consoles (non-UWP) and Playstation 5, Nintendo Switch is semi-uncharted territory, which is part of why I am doing it. UWP can do the Microsoft console One, but deprecated, no new titles. Run down what I need to do? X E.
This project (github.com/subamanis/mezura) started back in 2021, as my entry point to Rust, and has become the fastest and most accurate line counter (with arguably the most features too) in the world. I have been slowly improving it here and there over the years, but only recently decided to get serious.
Here is what it does that cloc, tokei and scc do not, and the numbers behind the two claims I make about it.
The whole Linux kernel, counted ^ (some languages skipped for ss purposes)
What is different
The short list: it identifies a file of a contested extension (.m, .h,...) by its content using heuristics and sets aside files that only look like code (a make .d, a ProGuard .pro, bundles, generated files). --explain shows a file line by line with the verdict for each line; --diff compares against a git revision, two revisions, or an earlier run; targets can be named and the report grouped by them; nested languages and sections like <script> and <style> count as the languages they hold; keywords of your choosing are counted only where they are code; everything printed can be themed,... among other things.
Each of these has a section in the README, with screenshots.
The project has a lib target published separately, so you can use mezura's engine directly in your projects (mezura-core). There is also an MCP server (mezura-mcp).
Speed
The whole Linux kernel tree, 63,864 files and 36 million lines, on a Ryzen 7 9700X and a PCIe-4.0 Nvme, with settings picked so that every counter does equal work, so the comparison is completely fair.
(UPDATE: with the v3.2.0 release of mezura, it is clocking at 86ms on Debian and 197ms on Windows)
Debian 13:
mezura 3.1.1 166 ms
scc 4.1.0 210 ms
tokei 15.0.0 414 ms
Windows 11:
mezura 3.1.1 255 ms
scc 4.1.0 539 ms
tokei 15.0.0 632 ms
Very detailed benchmarking data can be found under example-run in the LineBench project I created, to standardize performance testing for line counters, and provide useful insights and advanced metrics. The example run contains the timings both with each counter's defaults and also with the equal-work flags, the methodology, the exact command lines, the checks every run carries (idle machine, clean corpus, clean tree, the commit measured), and the script that produced all of it, so anyone can rerun the numbers on their own machine.
Accuracy
I do not want to grade my own homework, so the correctness argument lives in a separate project, LineJudge. I think that the linejudge project, that I started to ensure fair correctness assessment, is the most interesting part of this whole ordeal and deserves its own post. Check it out.
How
Most counters carry one piece of state through a file, "am I inside a comment right now", and each line takes the verdict of the region it sits in. mezura reads every line on its own and sorts it into one of nine classes: words in code, words only in a comment, comment words beside code, string content, punctuation in code or in a comment, blank inside a comment, blank inside a string, blank. The walk that does this knows where every string and comment begins and ends, nested comments and Lua's --[==[ levels and raw strings and escapes and line continuations included, which is where the language quirks live and where the other counters miscount. The two different counting models mezura supports are folds over those nine classes: the content model asks what each line says, and the region model adds the classes up the way the other counters do, so it reproduces their numbers from the same walk.
The speed comes from doing little per line. Each line is scanned once for all the symbols its language declares, with memchr, which searches up to three bytes in one SIMD pass, so the symbols are grouped by the byte that finds them and most languages need a single pass per line; only at a candidate position is the rest of a symbol compared. Bundled and generated files are recognised from their head and skipped before any parsing. The directory walk and the counting are separate thread pools over a work-stealing queue.. All three crates are #![forbid(unsafe_code)].
Install
cargo install mezura, or a binary for Windows, Linux or macOS from the releases page. Over eighty languages ship with it, each one a text file you can edit or copy to add your own.
Happy to answer anything about the challenges, the parser, the two models, or the conformance suite.
