r/madeinrust • • 22h ago

Majority AI Coded TerminalLynx update: the same Rust core (russh + iroh + SQLite CRDTs) now runs on Android

3 Upvotes

A couple of weeks ago I shared TerminalLynx, my first Rust project after ~20 years of Python backend work: a local-first SSH/SFTP connection manager that syncs your devices and shared team vaults directly peer-to-peer over iroh (QUIC) with no central server or cloud account.

Today I shipped the 1.3.2 beta (including the first Android APK), and wanted to share the Rust parts that were the most interesting to build since last time:

  • Same Rust core on Android (russh, iroh, sqlx/SQLite). The core crate compiled for aarch64-linux-android via Tauri v2's mobile support with almost zero changes to the SSH, SFTP, or sync code. Most of the platform work was around Android's lifecycle: a Kotlin foreground service holds a wake/Wi-Fi lock so the Tokio runtime and active russh sessions aren't killed when you switch apps, plus fighting soft keyboards (especially Samsung's)
  • Reaching AndroidKeyStore directly from Rust via jni and ndk-context**. On desktop, the keyring crate stores the device's root secret in the OS keychain. On Android, instead of bouncing through an async Tauri Kotlin plugin, Rust calls java.security.KeyStore and javax.crypto.Cipher (AES/GCM/NoPadding) directly over JNI on the calling thread. Hardware-backed AES-256-GCM (StrongBox where available, otherwise TEE) seals the 64-byte identity secret with the user ID as AAD and writes the sealed blob to disk—so it works synchronously during startup and from any Tokio task.
  • Ephemeral peer state alongside a signed CRDT log. Everything durable in TerminalLynx syncs as Ed25519-signed, HLC-stamped operations in an append-only SQLite outbox log. For 1.3.1 I added "Open tabs on your devices" ("what's my desktop got open right now?"). Putting tab churn into the CRDT op log would bloat the log forever and broadcast your personal tabs to teammates. Instead, open tabs travel as a separate ephemeral message type over the already-authenticated iroh QUIC session—only between your own paired devices, never signed into the op log, with only the latest snapshot kept per device.
  • Fixing multi-NIC mDNS in minutes with [patch.crates-io] I hit a known upstream issue where iroh-mdns-address-lookup only binds to the OS's default multicast interface. On Windows (and macOS/Linux machines with WSL/Hyper-V, Docker, or VPN virtual adapters), the lowest-metric interface is often a virtual NIC, so LAN discovery silently failed. Cargo's [patch.crates-io] made it trivial to vendor iroh-mdns-address-lookup and pass every non-loopback IPv4 interface to swarm-discovery's add_interface_v4 whenever endpoint addresses change, without waiting on an upstream release.
  • Offline recovery kits (argon2 + chacha20poly1305 + qrcode). Since there's no server to reset your account if your only device dies, the app now generates a recovery kit (encrypted with Argon2id + ChaCha20-Poly1305 and rendered as a printable SVG QR code in pure Rust via the qrcode crate, no image libraries needed) alongside rolling encrypted backups you can point at a NAS or Syncthing/Nextcloud folder.

Between how painless [patch.crates-io] is, sharing one crate across desktop and Android, and the speed and memory footprint, Rust is seriously making me rethink some Python services I deployed at work this year.

There's a free tier (25 connections, 3 devices) on Windows, macOS, Linux, and now Android (beta APK behind the "Show the latest beta" switch on the download page): TerminalLynx (docs: https://terminallynx.com/docs, changelog: https://terminallynx.com/changelog/).

I probably should have waited on the Android app because I did not realize how much of a challenge that was going to be. Writing enterprise backends and creating connecters between various vendor platforms to allow them to talk to each other is easier than making an Android app work the way you want it to.

Happy to answer any questions!


r/madeinrust • • 10h ago

AI Assisted ~450k lines of Rust for an IaaS control plane: numbers and regrets

Thumbnail
0 Upvotes

r/madeinrust • • 18h ago

AI Assisted I got tired of File Explorer and built my own file manager for Windows. Yes, with AI help. Here's what that actually means.

Thumbnail gallery
1 Upvotes

r/madeinrust • • 23h ago

AI Assisted I built BatteryDock: a 4.4 MB native Rust taskbar pill for Windows that tracks all your wireless peripheral batteries without G HUB / Synapse / iCUE (free & open-source) [PORTING TO LINUX/MACOS]

Thumbnail gallery
1 Upvotes

r/madeinrust • • 10h ago

Majority AI Coded openfd: lsof-style fd scanner in Rust that streams /proc (3 MiB RSS at 100k fds)

7 Upvotes

I got tired of lsof being slow and memory-hungry on boxes with lots of open fds, so I wrote openfd, a Linux fd scanner in Rust. It streams /proc instead of building a snapshot in memory, so RSS stays flat and the first rows show up while it's still scanning.

Example: finding deleted files that are still held open, and how much disk they pin:

$ openfd -d | head -3
chrome   15198 sergey   5 file  /home/sergey/.config/.../BrowserMetrics-6ADED192.pma (deleted)
chrome   15290 sergey  31 file  /tmp/.com.google.Chrome.Auk2yT (deleted)
openfd: 168 deleted file(s) hold 342770063 reclaimable bytes

Benchmark, 100k fds, full scan (hyperfine, Ubuntu container, static musl build):

toolwall timepeak RSS
openfd0.71 s3.2 MiB
lsof 4.99.42.05 s41.8 MiB
lsfd 2.41.32.83 s140.0 MiB

Methodology and harness: BENCHMARKS.md

On a normal desktop a full scan is ~20 ms. Filters are pushed into the scan, so -p <pid> never opens other processes' fd dirs (15 ms).

Other things I use it for:

  • --watch: live open/close events
  • --top N: cheap fd-leak check
  • --wait --path app.lock: blocks until nothing holds the file
  • -j / --csv: machine-readable output for scripting

It's not a drop-in lsof replacement, it covers roughly 20% of the flags. Linux only, no NFS details. Unsupported flags error out instead of being silently ignored.

Install:

cargo install openfd
brew install saromanov/tap/openfd

Which lsof flags do you use in scripts? And does it bother you that rows from different processes can interleave in a parallel scan?


r/madeinrust • • 22h ago

Majority AI Coded I’m building Fexu, a modular Django-inspired web framework in Rust. Looking for early testers and honest feedback.

Post image
14 Upvotes

Hey r/madeinrust!

I've been working on Fexu, an experimental, open-source web framework written in Rust.

GitHub: https://github.com/Iam-Sanja/fexu-rs

There are already some interesting Django- and Rails-inspired frameworks in Rust, such as Cot, Runique and Loco. I'm not trying to claim Fexu is better than them. I'm exploring a slightly different direction.

The idea: Build what you need

My personal philosophy is simple:

Build your application. Decide what you need. Extend it when necessary.

Need an API? Fexu provides model-driven REST endpoints.

Need an admin? There's a native, server-rendered admin you can build upon.

Don't need an admin? Build an API-focused application without depending on the admin UI.

Need more complex business logic? Extend your application with your own Rust code, forms, views, permissions and workflows.

Why am I building this?

I personally develop business applications that are less focused on selling products and more focused on managing information, processes and business intelligence.

I want the admin interface to become more than a basic CRUD dashboard.

The long-term goal is an extensible workspace where users can find the information, tools and workflows they need to do their jobs, without requiring a separate frontend for every internal application.

At the same time, I don't want developers to be forced into using that interface.

What currently exists?

Fexu is built around Axum, Tera, SeaQuery, SQLite and PostgreSQL.

The project currently includes:

  • Typed models, database queries and migrations
  • Model-driven REST APIs and OpenAPI support
  • A native, server-rendered admin
  • Authentication, permissions, sessions and MFA
  • Forms, templates and reusable CRUD views
  • Background jobs, caching and file storage
  • SQLite and PostgreSQL support

Internationalization is another important part of the direction. English and German support and locale switching already exist in parts of the framework. The broader goal is to let developers enable multiple languages and eventually translate their own application labels and records through the admin.

A note about the early releases

I initially developed Fexu with a strong German-language focus. As a result, the early published versions, including v0.1.2, still have German-heavy areas, particularly in the UI and documentation.

I've since been moving the project toward English-first development, while keeping German as a supported locale.

Important: v0.1.2 is available on crates.io, but the main branch contains substantial newer work that hasn't been published in a new release yet.

If you want to evaluate the latest development version, please use the GitHub repository rather than assuming the crates.io release represents the current state.

What I'm looking for

Fexu is still experimental and not production-ready.

I'm looking for Rust developers who would be interested in trying it, reviewing the architecture, or building a small test application.

I'm especially interested in feedback on:

  • Does the model and application architecture feel natural in Rust?
  • Is the admin useful for real business workflows?
  • What would you expect from a customizable Forms/ModelForms system?
  • Does the modular approach make sense, or am I adding too much complexity?
  • What would stop you from using Fexu for a personal project?

Bug reports, criticism, ideas and contributions are all welcome.

I'm actively working on making forms more customizable and improving the developer experience.

I'd genuinely appreciate feedback, especially from people who have experience with Django, Rails, Axum, Cot, Runique or Loco.

GitHub: https://github.com/Iam-Sanja/fexu-rs

Thanks for taking a look!


r/madeinrust • • 23h ago

Majority AI Coded I wrote a Rust runtime that runs an LLM's tool-call script in parallel

2 Upvotes

I built Weave. The model writes one short script in a small Python subset, and a Rust runtime executes it: independent reads at the same time, writes in a safe order based on declared effects, and only the printed output goes back to the model.

The Rust part is the actual product. Python bindings are how most people will call it (pip install weave-lang), but the scheduling, isolation, and the write gate live in the runtime.

I'm the author. Source: https://github.com/AtharvRaotole/weave

Measured against native function calling, same model and tools, pre-registered:

  • Fan-out on real services (SQLite, git, files, HTTP, PyPI): 40/40 vs 27/40, 2.1 to 2.7 s vs 4.3 s, 0.45 to 0.50x the cost.
  • BFCL v4 multi-turn, fresh tasks: 159/378 vs 140/378 at 0.91x cost, p = 0.07, not significant.
  • GPT-5.4 mini lost an earlier BFCL round, 18/60 vs 27/60.
  • tau-bench retail: a draw.

Happy to answer questions about the effect tags or the runtime.


r/madeinrust • • 15h ago

Majority AI Coded Big update for my rust-kotlin launcher

2 Upvotes

It's a hybrid launcher with rust core and kotlin shell

Give a wonderful performance in backend task like search engine

Still in development. It needs polishing.

https://github.com/bazidasi/kayumarz-launcher


r/madeinrust • • 8h ago

Majority AI Coded I built Bach, a Windows installer builder in Rust and GPUI

Post image
3 Upvotes

Bach is an open-source Windows installer builder. It packages an existing app folder into a single Setup.exe using a TOML configuration. The installer supports light and dark mode, 19 languages, silent installs, and updates from an optional feed. Apps install per user by default. System-wide installation is available. The build CLI runs on Windows, macOS, and Linux.

The source is MIT-licensed, and the repo includes a small example you can package yourself: https://github.com/usebach/bach


r/madeinrust • • 11h ago

Majority AI Coded Tablo: admin panels

5 Upvotes

I've been building Tablo, an admin toolkit for Rust built on Toasty and Topcoat. For each model you describe its list, its form and who can do what and you get CRUD for free. Pages are rendered on the server, with no JavaScript to write and no frontend build.

impl Resource for PostResource {
    type Model = Post;
    type Form = PostForm;

    fn declare() -> ResourceDef<Self> {
        let col = Post::columns();
        ResourceDef::new()
            .policy(access::policy(Domain::Blog))
            .table(Table::new((
                col.title.text().searchable().sortable(),
                col.published_at.date().sortable(),
            )))
    }
}

It borrows the most from Filament (resources, tables, forms, actions, tenancy).

Demo

Website

Code


r/madeinrust • • 15h ago

AI Assisted aws3: a fast command compatible with aws s3, written in Rust

4 Upvotes

https://github.com/itchyny/aws3
I created a fast command compatible with aws s3, in Rust. The goal is a drop-in replacement for `aws s3` and `aws s3api`.


r/madeinrust • • 6h ago

Majority AI Coded Open Cereal Workshop - Complete foss rewrite of FL studio in rust for windows+linux

Thumbnail
gallery
13 Upvotes

https://github.com/areoseek/open-cereal-workshop

It extracts all of the resources that are proprietary from the FL Studio free demo installer file, you'll need to download that and point it to it on first startup if you want any of the FL Studio sounds and presets.

I will actively be working on this so I'll report any issues or bugs on the GitHub

I built this out of frustration and when switching my recording studio over to Linux. I'm not a senior software developer or even a good hobbyist software developer so this is mostly AI written but I have done my best to review it with my limited knowledge.


r/madeinrust • • 23h ago

100% Human Coded A relational database built in Rust as a learning project, supporting the SQLite binary file format.

5 Upvotes