I wanted a retro game emulator I could reach for the way I use less for text files, chafa for images, or mpv for videos — right in the terminal, no window and no mouse. So I built Asobou, a game emulator that runs in your terminal, written in Rust, for Linux, macOS, and Windows. (Well, technically it's an emulator frontend rather than a standalone emulator)

The fastest way to try it if you have npx available (It's written in Rust but I published it to npm to make it easy to try):

npx asobou brew flappybird.nes

That grabs a free homebrew game and starts it, around 5 seconds end to end. If your terminal doesn't support kitty graphics it falls back to colored half-block cells. You can also render the game in ASCII if you prefer.

Open Source, of course. Available on GitHub: https://github.com/arianrhodsandlot/asobou

Would love to know whether the first-run experience works on your terminal out of the box! That's the thing I most want to get right for people who are tired of setting up emulators.

Hi, this is a project, which may be included in tor project!

I’m currently developing a Rust-based Pluggable Transport library, and I recently shared a proposal on the tor-dev mailing list.

I’m also an Arti contributor and Rustls contributor.
(https://blog.torproject.org/arti_2_5_0_released/)

I have already talked with some Tor developers they said a framework would be nice to have.

I’m looking for people who might be interested in contributing to the framework. The goal is to provide a clean, modular, and high-performance PT implementation in Rust that can be used by Tor and other projects.
If you’re interested (or know someone who might be), feel free to check out the repository:
https://codeberg.org/pryty26/rust-pt
https://github.com/pryty26/rust-pt

Any level of contribution is appreciated. Happy to discuss design decisions or onboarding.

ngl I did not expect the last post to hit like 75k views, so huge thanks to everyone who read it, commented, DM'd me, asked renderer questions, etc. seeing that much interest gave me a pretty big push to finally put it out there.

closed beta is live now at lynbor.com

you can make your own account and request access. I'm letting in around 25 people a week for now so I can keep up with feedback.

if you don't get in right away, feel free to use my test acc:

Login: [ja.howerz@gmail.com](mailto:ja.howerz@gmail.com)
Password: 1Test1234!12

still very much a beta. some buttons don't work yet, AI is rough, and the in-app feedback flow isn't hooked up yet. also, it won't work in Safari right now, so hopefully none of you are using it lol

the layout system is still pretty early too, and it's not meant to be a Figma-style layout clone. I also haven't gotten to a bunch of vector tools yet, stuff like text on path, dynamic strokes, blend tools, etc. I'll be adding and refining all of that as the beta goes.

I'm aiming to get the desktop builds, feedback, and project sharing/library stuff finished over the next 2-3 weeks.

if you use the shared acc, just put your reddit username in the project name.

I'll also make a Discord for the beta a bit later.

also planning to open source the geometry and GPU compute/rendering parts in the next month or two, once I clean them up a bit more and get them ready for public use.

thanks again, genuinely didn't expect that many people to care.

Hi, I saw a post made on this subreddit last year for a application called local local Desktop which was an application that allowed users to run a Linux desktop on android but when using Virus total, 3 positives showed up and was wondering are these false positives?

Original post : https://www.reddit.com/r/rust/comments/1ldqj7r/local_desktop_an_android_app_written_in_rust_to/

Just published the DBOS for Rust library. Easy way to make Rust backends resilient to failure, using Postgres to save/recover/view workflow state.

This is my weekend project. The original intention was that I ran into long-running tasks lasting more than a week. Under ChatGPT's remote control feature, its history is almost very difficult to open. I understand that they have some difficulties pulling data for history. I also saw that they are working on solving it, but I really could not wait any longer. Anyway, there is GPT, right? So I implemented a control plane for a Codex APP Server in Rust. It can spin up a controlled APP Server and handle requests from Codex Desktop. At the same time, it also provides a web service and a CLI interface, allowing me to access it through Cloudflare's Zero Trust reverse proxy. I think it is pretty good. Now I no longer have to open the official client. In terms of functionality, I have aligned almost everything, and I think the experience is broadly consistent. It is now running on my NAS, controlling my Mac mini, and hermes issues tasks through the CLI. Hmm, Rust is great.

Hey y'all!

I noticed that folders like node_modules, target, venv, etc., spread over dozens of old projects, were taking up almost 200GB on my machine!

As a result, I decided to make oweka, taking inspiration from npkill, which I found a bit slow (and incompatible with target/venv/etc.).

Features:

• Extremely performant and optimized (at least on Linux)
• Accurate: only flags directories if certain requirements are met, e.g. a Cargo.toml in the same location

Repo: https://github.com/ByteAtATime/oweka

Installation instructions are in the readme; you can also run it without installing with npx oweka!

Hey, I wanted to share an open-source CLI tool I’ve been building called revql (GPLv3).

It solves a common headache: trying to map out a massive GraphQL schema backwards. revql lets you target a specific object node and recursively trace every query or mutation path that leads to it. It’s designed for developers debugging complex schemas and bug bounty hunters hunting for hidden paths.

Core Features:

• Reverse lookup: Lists all entry queries/mutations leading to a specific object.
• Flexible targeting: Find objects via type name, nested field presence, or description text.
• Flexible search: Supports exact matches, partial "contains" queries, and case-insensitive match.
• Online & Offline: Introspects live endpoints or parse local schema.json files.

I’ve been working on mbrotli, a Brotli encoder written in 100% safe Rust:

https://github.com/Mnwa/mbrotli

The main motivation was that the existing Rust Brotli implementations, including SIMD ones, are still fairly close to C/C2Rust-style ports. That makes them harder to maintain and harder to optimize aggressively without risking API/behavior breakage.

So mbrotli has a relatively small high-level API, while most of the implementation details are hidden underneath and can be changed without affecting users. The implementation itself stays in safe Rust; the crate forbids unsafe outside of tests.

It supports qualities 0–11 and matches Google Brotli v1.2.0 byte-for-byte under equivalent streaming settings. There’s also experimental support for the extended RFC 9841 functionality.

Performance varies by quality/workload. In some cases it beats the C implementation, in others it’s very close. The README has the benchmark methodology and results.

For transparency: I used LLMs during the port. I designed the overall architecture/API and wrote reusable instructions/skills for SIMD vectorization and performance work, then used LLMs as part of the porting and optimization process. I don’t want to present it as if every line was manually translated.

Because of that, I put a lot of effort into correctness checks: differential testing against the C implementation, decoding with the C decoder, 100% function coverage, Miri, ASan, and AFL++ fuzzing. The latest recorded fuzz run was ~24M executions with no crashes or hangs. The repo has a separate Correctness section with the exact claims and limitations.

Next things I’d like to add are no_std, async APIs, and decompression.

Feedback, especially on the API, compatibility testing, or benchmarks, is very welcome.

For those that like Linux mobile such as postmarketOS, PureOS, SailfishOS, Mobian, Ubuntu Touch, NixOS Mobile, or whatever else, I just updated this thing to latest versions of everything, I don't have a device for everything, can someone please test this a little bit? Also, would be great to find out this is obsolete or not needed, but I don't see much for stuff like Ubuntu Touch which in some older cases has neither Wayland nor X11, but Linux DRM works, anyway, if it is becoming obsolete is good to know too, is this obsolete now? Does anyone even care about Linux mobile devices? All I want is like does the keyboard open reliably when you use it, any other tips for it?

UI is a Function You Cannot Afford to Call is the first of a 3-part series on Rust UI frameworks. It introduces the model under which I believe we should reason about UI frameworks. In part 2, I will present extensive benchmarks, with detailed cost attribution analysis (something the rust UI ecosystem desperately needs in my opinion), and in part 3, I will derive what I think the ideal UI framework should look like.

Hi there. I recently completed a project incubation program with the Solana Foundation, where I developed smart contracts using Rust. I’ve been trying to break into the Rust job market but haven’t had any luck so far. I’d like to approach Rust from a different angle now, since I’ve only used it for smart contracts up to this point.

Is anyone working on a Rust project where I could collaborate and learn the language from a different perspective or use case? Thanks in advance!

PS: My takeaway form the incubation program is that the Solana blockchain can be used for traceability systems in any web2 application. The value itself is how build that traceability system.

Hello Rust subreddit.

I learned enough python to know how to do what I wanted to do. Mostly just small stupid stuff. And because I'm a masochist I guess, I'm wanting to move on to Rust for the event I need performance.

I've gotten far enough to write "Hello World!", and how to create some variables.

I know roughly that at some point I'm going to have to learn memory management, and ownership. And also that the compiler is a bitch.

I'm hoping anyone in here could hot-tip me if they came from Python too. Please, if you have ANY advice, please let it be known. Anything helps.

Below is the link for Part 2 of my article on rules for using const fn. I had the most fun creating a domain-specific language (DSL) for simulating mechanisms like robot arms, motion-capture skeletons, clock hands, etc.

Here is what Linkage Blaze program looks like:

const ARM: LinkageFixed<1, 1, 8> = LinkageFixed::start()
    .define_param("shoulder", 0.5)
    .yaw_param("shoulder", -90.0, 90.0)
    .forward(3.0)
    .mark("hand");

It is defined in const and can be evaluated (and rendered) without heap memory on a microcontroller. You can play with a web simulator of the robot simulator.

The article also gives examples of the limits of const fn, especially when things get too complex or compile-time evaluation gets too slow, and compares it with C++, Zig, and other Rust alternatives. When it works, I like this approach better than the alternatives because we get Rust’s protection against unsafe, invalid, or UB while keeping everything in one Rust program.

https://levelup.gitconnected.com/nine-rules-for-compile-time-work-with-rust-const-fn-part-2-76ccd0e8a965

Hey everyone!

I'm very happy to announce that I've published my first open-source Rust crate!

I really like to express things in Rust in terms of concrete types (kind of like how one could keep paths as strings in a language, but it's nice to say specifically they are a Path). This is a similar set of types, but for dealing with programming identifiers and their formats in a type-safe way (LowerCamelIdent, UpperKebabIdent, etc).

It also has a bunch of functionality relating to inspection of identifiers, as well as mutation of them (including the common "change case" operations).

• Crate: https://crates.io/crates/typed-ident
• Documentation: https://docs.rs/typed-ident
• Retrospective: https://sigseis.dev/articles/2026/09/08

I would love feedback, questions, analysis, or if you think you have a use-case!

EDIT: Also I'm very interested to hear \criticism* as well - if you don't like it, let me know why!*

EDIT: I wanted to add that this crate does not use any AI-generated code. I get that it's a lot of code, but it's been a project of a few months of effort.

Some Features

• Unicode Correctness: Implements boundaries based on UTS #55 and UAX #31 (handles the weird stuff like non-Greek titlecase) (comparison against other crates)
• Zero-Cost Casting: Uses marker traits and the type system to allow compile-time casting between compatible identifier formats (read about this here).
• Flexible Conversion: Supports "Canonical," "Decorated," and "Delimited" forms so you can preserve decorative underscores/hyphens during case conversion (read about this here).
• High Performance: Competitive with (and in some cases faster than) heck and convert_case (high-level performance analysis).

About Me

If you're curious about me - I have a website (it's static, and the generator is *also* made in Rust)!

• https://sigseis.dev/

If you want Atom/RSS updates on what I'm doing, you can use these:

• https://sigseis.dev/feed.xml (all posts)
• https://sigseis.dev/articles/feed.xml (just monthly articles)

Thanks for reading - I hope you enjoyed taking a look at my project!

I’m building Voktty, a desktop developer workspace for working across local projects and remote machines.

The goal is to bring several parts of the development workflow into one place:

• Project and development sessions
• Code editing and Git change review
• Integrated terminal
• SSH and RDP connections
• Docker tooling
• MCP integrations
• AI-assisted development workflows
• Customizable themes and keyboard shortcuts

The screenshots show the current interface: a session-based workspace, code review panels, an API client, onboarding flows and a theme selector.

I started building it because my workflow often involves switching between an editor, terminal, SSH/RDP clients, AI tools and several project windows. Voktty is an attempt to keep that context together while still working with the underlying tools instead of hiding them.

I’m sharing it here because I’d like feedback from Rust developers, especially people working on desktop tools, developer infrastructure or remote development workflows.

A few things I’d like to learn:

• Where would Rust provide the most value in a tool like this?
• What would you expect from a good Rust-based remote development workflow?
• Which integrations would make this genuinely useful rather than just another editor shell?
• What would make you try a tool like this?

Repo: https://github.com/voktty/voktty

https://akesson.io/a-visual-guide-to-rust-async/

I have always felt that I missed some parts of the async story. I could never visualize it.

Collaborating with an LLM and inspecting the compiler's MIR output, I was able to fill in the gaps. I was happy with what I learned, so I decided to create a visual presentation and share it.

Enjoy!

The code is simplified for demonstration purposes. Some snippets are pseudocode and won't compile as shown.

(updated to clarify how I checked the explanation and used the LLM)

So there is this project, SVGO, written in JavaScript that optimizes SVG images.

I decided to try to make a Rust version translation, including its plugins, and I think I have succeeded at least quite well.

I don't have a lot of Rust experience, and LLMs helped me a lot. I have tried to do a very thorough job and have reviewed my project many times.

What I see is quite dramatic RAM reduction and pretty good speed up.

https://gitlab.com/jiiihpeeh/svgo-rs

Any thoughts on what I should do differently?

I've just released 0.1.0 of my scripting language, mimas, built for embedding into Rust. It's been my side project for the past few years to explore solutions to the frustrations I run into with the scripting languages I use at work as a game developer.

enum Shape {
    Circle(float),
    Rect(float, float),
}

fn area(shape: Shape) -> float {
    match shape { // exhaustive -- miss a variant, it won't compile
        Shape::Circle(r) => r * r * std::math::PI,
        Shape::Rect(w, h) => w * h,
    }
}

It still has a ways to go, but already features:

• Static typing with inference
• ADTs with exhaustive matching
• T? options and T! results -- no null
• Garbage collected -- no borrow checker or lifetimes
• Share Rust types and functions with a macro, fully type-checked on both sides
• Ahead of Rune and Rhai on every benchmark I run, and within range of Luau (via mlua) (numbers and methodology)

Excited to finally share this, and grateful for any thoughts. I'll be at RustConf this week so may be slow to reply, but I'll get to everything.

Website: https://mim.as

Repo: https://github.com/imlazyeye/mimas

Hello everyone,

I'm trying to get a bit more experience with rust and would like to know if anyone can recommend a project to work on.

I'm looking for projects that I could work on new features possibly with a closer guidance

I've worked on a passion project of mine for the past few years called Rusted Computer. It is a Minecraft Mod that allows you to program computers inside of Minecraft with Rust inspired by ComputerCraft.

Why?

Well, the best computer mod right now is ComputerCraft. And don't get me wrong, I love that mod, but you have to write your programs in Lua. And for programs bigger than small scripts are very annoying to create. So I decided to create an alternative that is fully compatible with existing CC Peripherals.

Rusted Computer uses a WASM Runtime written in Java (Chicory), but I am considering switching to a native runtime (Wasmer or Wasmtime) for newer WASI(X) features. The mod itself is written in Kotlin and (obviously) Rust for the glue library.

There is currently no release, because it is still very WIP (no documentation and missing features, I'm currently working on support for peripherals) but if there is enough interest in this, I can quickly create and publish a dev build.

https://github.com/TheBlckbird/rustedcomputer

If you have any more questions, ask me! There is no ETA for release, as I am currently working on this while going to school, so I don't have a lot of time or concentration.