r/madeinrust • • 4h ago

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

Thumbnail
gallery
9 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 • • 7h 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 • • 5h 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 • • 9h 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 • • 19h 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 • • 13h 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 • • 5h ago

Majority AI Coded Canban - A Kanban-based workflow for coding agents, built with Rust, NSH, Ghostty VT, and Herdr

1 Upvotes

Hi! I built Canban, an native Rust desktop app that turns Kanban cards into automated coding workflows without replacing native agent CLIs.

If you've tried running multiple coding agents across terminals, you probably know how exhausting it gets to switch between tasks and keep track of their context and progress.

My workflow:

  • Discuss a feature with an agent on a Kanban card.
  • Drag the card into Develop to trigger a GitHub Actions-like workflow.
  • Automatically dispatch coding agents in isolated Git worktrees.
  • Deliver completed changes through a local merge queue.

All feature discussions, context, and progress stay on the Kanban board.

Highlights:

  • Git worktrees & merge queue - Isolate parallel tasks and merge changes through a serialized local queue.
  • Native agent CLIs - Run Claude Code, Codex, and other CLIs through Herdr without replacing their native interfaces.
  • Restart-safe execution - Keep coding agents running even when Canban restarts or upgrades, without interrupting ongoing work.
  • Remote machine support - Connect to remote Linux machines via SSH/Tailscale and run coding agents remotely.
  • GitHub integration - Turn GitHub Issues and PRs into Kanban cards and run workflows on them just like local cards.

Rust tech stack:

  • longbridge/nsh — Native macOS (AppKit/Metal) and Linux (GTK4) UI
  • libghostty-vt — Terminal emulation
  • herdr-core — Persistent agent sessions
  • Rust — Application, workflow engine, and backend

One design choice is to keep native agent CLIs intact. Canban runs Claude Code, Codex, and other CLIs through Herdr, preserving their original TUI, permissions, and features. Agent sessions also survive app restarts.

Both canband and herdr-core can run headlessly on Linux for remote execution.

Open source under Apache-2.0.

Website: https://canban.dev
GitHub: https://github.com/jjyr/canban

I'd love to hear feedback!


r/madeinrust • • 5h ago

Majority AI Coded I built Phoxite, a free, open-source PHP/Laravel language server written in Rust (VS Code, Neovim, Helix, Zed…)

Thumbnail
reddit.com
1 Upvotes

r/madeinrust • • 7h ago

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

Thumbnail reddit.com
0 Upvotes

r/madeinrust • • 13h 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 • • 1d ago

AI Assisted mddog: view Markdowns in the terminal as if you're on GitHub or Obsidian

49 Upvotes

I look at Markdown files a lot for work and prefer to just stay inside the terminal without switching out of it, so this has been a game changer.

mddog basically works by drawing Markdown as the way GitHub shows it using macOS CoreText and CoreGraphics engines. It then sends that page to the terminal as image strips.

I'm learning a lot about the terminal, Rust, and the kitty graphics protocol throughout this process and having a lot of fun. If you give it a try, let me know how you like it!

brew install qu8n/tap/mddog

Docs: https://mddog.pages.dev

Repo: https://github.com/qu8n/mddog


r/madeinrust • • 11h ago

Majority AI Coded I built an app that hosts Zed's editor inside another app and we are open sourcing it. openOrchestra is a native macOS app to run Claude Code and Codex in parallel git worktrees

Post image
1 Upvotes

r/madeinrust • • 13h ago

Majority AI Coded Big update for my rust-kotlin launcher

Thumbnail gallery
1 Upvotes

r/madeinrust • • 20h ago

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

4 Upvotes

r/madeinrust • • 20h 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 • • 16h 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 • • 21h 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 • • 17h ago

AI Assisted Spent way too long on this: a self-hosted login + gateway thing that also limits what AI agents can do

Thumbnail
reddit.com
1 Upvotes

r/madeinrust • • 17h ago

Majority AI Coded Komora: I made a “moving box” for my Windows apps, so reinstalling Windows doesn’t hurt anymore

1 Upvotes

You know the drill. Fresh Windows install, and then two evenings of “what was that tool called again?”, digging through bookmarks, and downloading installers one by one.

So I built Komora (Ukrainian for “storeroom”). It’s a little tray app that remembers your software (apps, links, reposetories, authors etc.) for you.

How it works

  • You add your apps: paste a GitHub, GitLab or Codeberg link, or pick from ~70 everyday programs (Steam, Discord, OBS, 7-Zip…) that install through winget.
  • Mark the ones you can’t live without as My kit.
  • New PC or fresh Windows? Open Komora, hit Install the kit, go make tea. ☕ Your apps come back, and so do your Windows tweaks and the apps’ own settings.
  • The kit travels by a secret GitHub Gist or a single zip file (with Komora in it).

And while it’s sitting in your tray anyway

  • It checks for updates and installs them, with signature and checksum checks.
  • Windows tweaks with an undo button, plus a heads-up when a Windows update quietly resets them (it will).
  • One-click fixes for the classics: shader cache, DNS, a stuck Windows Update, sfc/DISM.
  • A hardware page that tells you what’s in your PC and where to get its drivers.

The Rust bit: one ~4.7 MB exe, no Electron. Just windows, webview2-com and serde, with the UI in WebView2. 9 languages, GPL-3.0.

It’s young, so some installers haven’t met the real world yet. If something breaks, please yell at me in Issues. 🙏

https://github.com/Fenderenko/Komora


r/madeinrust • • 1d ago

Majority AI Coded Skif 0.9: caching Oxc parse results in a Rust monorepo linter

2 Upvotes

I maintain Skif, an MIT-licensed Rust CLI that checks workspace manifests, dependency versions, and unused JavaScript and TypeScript code. It uses Oxc to parse source files and reads tool configuration statically.

In 0.9, the disk cache is enabled by default. It saves per-file parse results so the next run can reuse them for unchanged files. The rest of the pipeline still reads and hashes the source, builds the module graph, and evaluates the rules. That distinction shows up in the CI results.

RepositoryDisk cache offWarm disk cacheSpeedup
Angular857 ms445 ms1.9×
VS Code2,566 ms1,377 ms1.9×
n8n5,079 ms3,801 ms1.3×
Next.js795 ms610 ms1.3×

These are whole-process timings on the same pinned checkouts. The workflow also compares cached and uncached reports across seeded edits: all 66 report pairs matched. See the full benchmark tables and reproduction instructions.

I’d be interested in how others test cache invalidation in static-analysis tools, especially cases where a manifest or config change affects the graph without touching the source file. Source · 0.9 changelog


r/madeinrust • • 21h 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 • • 1d ago

Majority AI Coded Native Rust implementation which supports Dataweave scripting language

4 Upvotes

If you've ever worked with MuleSoft (a Salesforce product), you probably know DataWeave (DW). It is a concise DSL built for transforming and reshaping JSON, XML, CSV, and other formats without writing tons of boilerplate.

Until now, using DataWeave inside a Rust binary meant either shelling out to MuleSoft's data-weave-cli or wiring up JNI to invoke the official Scala/Java runtime. Both options pull in the JVM, which defeats the point of shipping a standalone Rust tool.

So I built Rustweave, a native Rust clean room implementation focused on actual usability without the JVM overhead. It covers the core runtime and the most common standard library functions (map, filter, groupBy, orderBy, etc.).

Basic usage:

let output = rustweave_core::run(
    r#"%dw 2.0
import * from dw::core::Arrays
output application/json
---
{
  total: payload.orders sumBy $.total,
  paid: payload.orders filter $.paid map $.customer,
  byRegion: payload.orders groupBy $.region
}"#,
    &[(
        "payload",
        r#"{"orders":[
            {"customer":"ana","region":"north","total":120.5,"paid":true},
            {"customer":"ben","region":"south","total":80,"paid":false}
        ]}"#,
    )],
)
.unwrap();

println!("{output}");

Output

{
  "total": 200.5,
  "paid": [
    "ana"
  ],
  "byRegion": {
    "north": [
      {
        "customer": "ana",
        "region": "north",
        "total": 120.5,
        "paid": true
      }
    ],
    "south": [
      {
        "customer": "ben",
        "region": "south",
        "total": 80,
        "paid": false
      }
    ]
  }
}

Here is the Rust implementation

A few caveats on the current state:

It covers core transformation workflows, not 100% of DW's full standard library yet.

Error messages and some edge-case type coercions are still rough.

I've been using DW in my day job for years and wanted a way to bring it into my Rust CLI projects. If anyone else deals with messy data transformations or comes from an integration background, give it a spin and let me know if anything breaks or feels unidiomatic.


r/madeinrust • • 1d ago

AI Assisted Diffler: vi-like magit inspired diff viewer, PR reviews, MCP and more

Thumbnail gallery
3 Upvotes

r/madeinrust • • 1d ago

AI Assisted File Manager (like Windows Explorer) in rust

Thumbnail
reddit.com
2 Upvotes

r/madeinrust • • 1d ago

AI Assisted venti - a terminal multiplexer built with ratatui

5 Upvotes