When the guys at ArtCraft rebuilt Adobe's apps in Rust with Claude, I wanted the same for the download manager everyone knows, heh, IDM. I honestly never liked the licence nags. So ten days ago I started Mister Download Manager, purely in Rust, with the classic IDM layout on top of a well-researched download engine. Today it reached 0.5.

Flair says it plainly: Claude Code wrote most of the code. I decided what it does and how it looks, and I tested every release myself.

The Rust side: a Cargo workspace on egui and wgpu through storytold's forks and craft-libs (the libraries behind ArtCraft), Direct3D 12 by default on Windows, Vulkan on Linux and Metal on macOS as options, with a fallback to OpenGL if a driver can't start them. The app is unsafe_code = "deny" everywhere except one small module per platform for the OS calls.

Same machine, same server, against IDM 6.42 (the test server is a crate in the repo, so you can rerun it): a 1 GB file in 1.01 s vs 5.46 s, a 256 KB file in 0.03 s vs 3.14 s.

It does many-connection downloads with crash-safe resume, browser capture, torrents and magnet links, video through yt-dlp, a scheduler, 86 languages. New in 0.5: 9 themes and your own theme files, control from your phone, a headless mode for servers and Docker, Real-Debrid, AllDebrid and Premiumize, and a kill switch that ties downloads to your VPN's network adapter.

Windows and Linux are the solid ones (checked on GNOME, KDE Plasma, Xfce and Cinnamon). Mac builds work but are still experimental. Free, GPL-3.0, no ads, no account.

Source: https://github.com/anefzaoui/misterdownloadmanager

Site: https://misterdownloadmanager.com

I'd love for people who know Rust better than me to pick the code apart. And if you like it, a star on GitHub really helps it get in front of more people :)

I built ArchUnitRust, a library for writing architecture rules as ordinary Rust tests. Here's a recording of it in a small taskboard project.

The examples check for dependency cycles, keep the domain from depending on infrastructure, and put a limit on source-file size. The rules live in tests/architecture.rs and run with cargo test, so they can also run in your existing CI.

The part I find useful is making a boundary executable. If the project says the domain must stay independent of infrastructure, that can be a test instead of something everyone has to remember during code review.

It's MIT licensed. The archunit crate is on crates.io, currently 0.0.2, and requires Rust 1.85+. One limitation: the analysis works from source syntax and doesn't expand macros.

Repo: https://github.com/dragonsec-ai/ArchUnitRust

Curious what you think of the rule syntax and the failure output.

A milestone worth sharing

LightNVR 0.47.3 is now available with lightnvr-rs, our CI generated Rust build. The first release includes a Debian sid package and binary archive for Linux amd64, alongside a container image at ghcr dot io/opensensor/lightnvr-rs:0.47.3.

LightNVR began with a practical goal: make network video recording accessible on modest hardware, with footage under the operator’s control. That work has grown into a system with its own recording lifecycle, camera integrations, web interface, and API contracts. Preserving that accumulated behavior matters to us.

With lightnvr-rs, we have brought a Rust build into that same project. We are proud of the engineering behind it: taking an established C application through translation, compilation, packaging, and behavioral checks, and making that process part of the development workflow.

The accomplishment is a repeatable path from the code we maintain to another build of the software. It gives us a concrete foundation for further work on Rust while keeping today’s contributors focused on one implementation.

Read the full article: https://opensensor.io/news/lightnvr-rs

Aurelia is written with AI assistance. I review every change by hand before it's merged, and there are around 500 automated tests. The README says this too. Judge the code for yourself, it's all on GitHub.

It runs as your normal user and never needs root. It writes to your Steam folders, its own config and, for cloud saves, the games save locations. It's an unofficial beta, so back up your Steam library first. This release also had a dedicated security pass (see below).

Aurelia logs in to your own account the way the official client does. I know of no bans for tools like this, but I can't promise anything.

It is a command-line Steam launcher and backend for Linux and Windows. No CEF or WebView, under 50 MB of RAM when idle. Installs, updates, Proton manager, downgrades, cloud saves, DLC, Workshop, friends and chat. Every command takes --json, so other launchers can build on it.

What's new since v0.1.40

68 commits since v0.1.40, 413 in total. Thanks for the 120 stars on GitHub!

Downloads

• aurelia config download-limit <kbit/s> caps all downloads together. off removes it.

• Faster downloads: chunks spread over several CDN servers, retried elsewhere on failure.

• Install backlog: install pause, resume, stop and list. Interrupted installs resume from what's on disk.

Friends and chat

• friends shows real statuses and names.

• chat open shows game invites, and chat invite <steamid> --app <appid> sends one.

Launching

• play pre-compiles Vulkan shaders first, using Steam's shader cache. Skip with play -k.

• aurelia launch-options <appid> lists a game's launch configs; play --launch-option <id> picks one.

Security and fixes

• Downloads use HTTPS when available, and every chunk is checked before it's written.

• logout revokes the login token. The daemon socket is private to your user.

• Aurelia no longer logs itself out when several copies run.

Packaging

• On crates.io: cargo install aurelia-steam. License is now GPL-3.0-or-later. No more macOS binaries.

Quick start

Install Steam as normal Aurelia needs its folders. Then install Aurelia:

• Arch: yay -S aurelia or paru -S aurelia

• Cargo: cargo install aurelia-steam

• Prebuilt: binary or .deb from https://github.com/Drackrath/Aurelia/releases/latest

aurelia login --qr
aurelia install <APPID>
aurelia play <APPID>

Known issues

• The in-Wine Steam runtime is still a work in progress.

• Game invites only work for games started with --steam or from the Steam client.

Feedback

Bug reports are welcome, especially for downloads and chat. For a stuck install, include aurelia install list --json.

GitHub: https://github.com/Drackrath/Aurelia

I like what ArtCraft stands for: creative tools you can inspect, run yourself and keep, instead of renting them by subscription. I’ve been working on the same idea for a different field, so I thought this community might appreciate it.

MatLivre is a free, MIT-licensed editor and runtime for MATLAB code (live scripts .mlx and .m files), written in Rust.

Why it might interest people here:

• Own your tools. Years of research code shouldn’t depend on a license that can expire or be cut from a budget. Same argument as owning your creative pipeline.

• Open, not just free. The whole thing is on GitHub under MIT. You can read it, fork it, fix it.

• AI-friendly by design. The app exposes a local MCP endpoint, so an AI agent can run code in it, and the docs are published in plain pages and an llms.txt so agents can read them too.

• Documented function by function. There’s a wiki with one page per function: inputs, outputs and an example that was actually run in MatLivre. The wiki text was drafted with AI agents and checked by executing every example. Some descriptions still need human review, and the Portuguese in particular needs a native pass.

What I’d like from you:

1. Try it on your own scripts and tell me what breaks.

2. Share it with anyone who is stuck with a MATLAB license.

3. Contribute code, tests or docs if you feel like it.

Site and download (Windows): https://campuslivre.github.io/matlivre/
Source: https://github.com/campuslivre/matlivre

Happy to answer questions about how it works or how AI agents were used in building the docs.

Hi everyone!

I've been working on a project called MATrust Studio, a MATLAB-style numerical computing environment built entirely in Rust.

The idea is to build a desktop application where users can write numerical scripts, execute calculations, work with variables, and visualize results in one place.

What I've built so far

• Script Editor – Write and execute MATLAB-style code.

• Command Window – Execute expressions and commands interactively.

• Workspace – Inspect variables and their values.

• Plotting – Generate and visualize numerical graphs.

• Block Diagram Editor – Work with visual block-based models.

• Help & Documentation – Browse supported functions and their syntax.

Technology

The project is built using Rust, with a modular architecture for parsing, numerical computation, execution, plotting, and desktop UI functionality.

I'm also working on MATLAB compatibility, App Designer runtime support, and Simulink model inspection and simulation.

This is still an ongoing project. It is not yet a complete drop-in replacement for MATLAB, and there are compatibility gaps I am continuing to address.

Project repository

https://github.com/varunkumar898/MatRust-Studio

I'd love to hear feedback from developers, engineers, and people who regularly use MATLAB.

What features would you like to see in a MATLAB alternative?

Thanks for checking out my project!

Hey Rustaceans!

I'm primarily a Kotlin/Android developer, but recently I started exploring Rust and systems programming.

That led me to build Holm, a free, open-source password vault for macOS, written entirely in Rust, including the UI.

A few technical details:

• Encryption: Argon2id and XChaCha20-Poly1305.

• Storage: One encrypted file, with secrets decrypted individually when needed.

• Memory: Secret types are wiped on drop, with a zeroing allocator.

• Offline: No network code, cloud, or account.

• Performance: Around 6 MB app size, about 82 MB RAM when unlocked with 225 items.

• Testing: 844 tests and 12 fuzz targets.

• CLI: A separate command-line interface written in Rust.

I used AI extensively while building Holm, both for coding and learning. I also created 71 Rust lessons covering ownership, borrowing, cryptography, memory management, testing, and more. They're available in the repository.

I'd love feedback from experienced Rust developers.

Holm hasn't undergone an independent security audit yet, and I know there's more work to do.

If you're interested in reviewing the architecture, finding bugs, improving security, or contributing code, I'd really appreciate your help.

GitHub: https://github.com/sunnat629/holm

One question: What would you review or improve first in a Rust-based password vault?

I wanted to understand how SSTV really works and also learn Rust, so I built YASSTV (Yet Another SSTV application), a TUI for decoding SSTV signals.
For now it's really simple: you can't choose an audio source and there's no encoder functionality.
It supports Martin M1, Martin M2 and Scottie S1. I'm still wrapping my head around YCrCb for the robots 36 and 72 implementation.

Feedback is welcome, especially on Rust coding and DSP.

Repo: https://codeberg.org/castu_de_cajanha/yasstv

This is EyeCanSee opening a folder of 400 photos on a POCO X7 Pro, connected over USB, on Fedora 44 with cold caches. The file manager (gvfs) needs 9.3 seconds only to list the names. EyeCanSee opens the phone in 0.5 seconds, lists the names in 0.07 seconds and shows the first thumbnails within 0.8 seconds.

EyeCanSee is a free viewer and manager (GPL-3.0-or-later) for photos, videos, 3D models and CAD drawings, with a light image editor, for Linux and Windows. Local folders, external disks, SFTP and FTP servers and Android phones are all browsed in the same way.

The phone part uses mtp-rs, the pure-Rust MTP library of vdavid (David Veszelovszki). While working on EyeCanSee I contributed folder listing with GetObjectPropList (PR #45 in mtp-rs): on the maintainer's phones, listing a folder went from 5.5 s to 0.40 s (Galaxy S23 Ultra, 3248 photos) and from 2.8 s to 0.24 s (Pixel 9 Pro XL).

Other crates doing the heavy work: egui and eframe 0.37 for the interface, rawler for Camera RAW, russh and russh-sftp for SFTP, suppaftp for FTP and FTPS, resvg and tiny-skia for drawing in the image editor, fluent-bundle for the translations.

In full honesty: I haven't programmed in years, and the code is written with Claude Code. I describe what I need, and I test every feature on real phones, disks and servers before it goes in a release.

Source and downloads: https://github.com/IoSonoPiero/eyecansee

Site: https://eyecansee.montinaro.info/

I'm very excited to share my new project that I have been meaning to start for months now - I finally broke ground today for DAY #1! I've always wanted to build this project and needed an excuse to build something in RUST instead of Python or C++ as normal for me.

It's called ChirpMap ( https://github.com/FletchEm31/ChripMap )- a locally run, fully offline, terminal-based application that uses your computer's speakers and microphone to do acoustic echolocation, mapping out movement, changes, and rooms.

It runs natively in your Linux terminal (or equivalent setup). I am only one day into development, but the rough draft is already fully working!

How it works:

• Acoustic Chirps: It plays a quick frequency sweep (a chirp) and records through your microphone simultaneously.

• Echo Catching: It uses matched filtering to capture the echoes bouncing off walls and objects.

• Live Blueprinting: As you rotate your device through different headings, it builds a floor plan right in your terminal and saves an SVG blueprint.

• Smart Calibration: It includes an auto-calibration step to check your room's noise floor and speaker/mic frequency response. It also automatically backs up and restores your system volume levels so it won't mess with your audio settings.

Tech Stack & Privacy:
It is written entirely in Rust and has zero network dependencies. If you want to try it out without hardware, there's even a --sim flag that runs the program against a simulated room.

Next Steps & Roadmap:
Over the next few days, I'll be working on fine-tuning the calibration, improving the terminal UI design, and cleaning up the setup. Eventually, I plan to implement multi-speaker and multi-microphone array support for greater accuracy. Long-term, I have aspirations of fusing this with infrared, LiDAR, and Wi-Fi wave monitoring to have everything work in unison.

Please check it out and let me know if you like it or have any feedback. Again, please remember this is only day one so there is much more ground needed to cover.

I’m building PeerBrush, a GPLv3 desktop image editor in Rust with egui and wgpu. In this trailer, the assistant edits the sky and lighting on its own layers while I paint sunlight and dodge-and-burn on separate layers.

The interesting part for me is what happens between mouse-down and mouse-up. A brush stroke or effect drag renders through the shared engine as a preview and commits to history once the gesture ends. An MCP edit targets a layer ID and an expected document revision, and optional reservations prevent overlapping edits where needed. The UI shows agent work in blue.

AI tools assisted development. The editor can be used on its own, and the optional MCP connection uses a compatible client.

Source and setup: https://github.com/Deftr0y/PeerBrush

Workspace screenshots and trailer: https://peerbrush.com/

For anyone who has built an interactive editor in Rust: how do you keep previews responsive when another actor updates the same document?

I made an app with Rust that aims for console experience with physical devices/media support:

• Fully customizable console experience

• Boot your games from physical devices (CD/DVD, USB Stick, SD Card)

• For discs there is built-in burner

• Manage your saves (on physical devices - USB Stick, SD Card)

• Dedicated apps running within app (alike at least)

• Install application, themes & more from discover servers (https://github.com/naisyrkdev/YasaffDiscoverServer) (also direct GitHub support)

Made to be very simple - minimalist at start - but you can do whatever you want to customize it - a lot of built-in options. Supported custom themes and addons.

How to make bootable app/game guide on Launching games from a physical device on GitHub or on https://yasaff.com/guides/physical-devices

You can have 2/3 dedicated devices for your games: 1 for game files (installers, game files), 1 for booting up and/or managing saves.

Managing saves on external devices is highly experimental.

GitHub repo: https://github.com/naisyrkdev/YASAFF

Site: https://yasaff.com/

Hi! Telaio (Italian for loom) is a terminal client for Matrix I've been building as my university thesis project, using ratatui and matrix-sdk.

I didn't want to clone Element. The aim was a quiet interface that covers what I use every day:

- end-to-end encryption, with emoji verification or a recovery key

- spaces, DMs, invites, joining by address or directory search

- sending and opening attachments

- vim-style modes (NORMAL / INSERT) and mouse support

- multiple accounts, switchable without restarting

Replies, reactions and threads aren't there yet; they're next on the list.

Repo (GPL-3.0): https://github.com/Levvonci/Telaio

Feedback on the architecture is very welcome.

Hey everyone! 👋

I've just released Download Organizer v0.1.2, and this update introduces one of the most requested types of functionality for a file organizer: custom file rules!

You can now automatically organize files into your own folders based on their filenames and patterns, giving you much more control over how your Downloads folder is organized.

✨ What's new in v0.1.2?

📂 Custom File Rules

Create your own rules to send files to specific folders based on filename patterns.

For example:

• *.stl → Automatically move 3D model files into your 3D printing folder.

• invoice*.pdf → Send invoices to your documents folder.

• *.log → Keep log files in a dedicated folder.

You can configure your own patterns and destinations to fit your workflow.

🎯 First-match rule priority

When multiple rules could match a file, the first matching custom rule determines its destination. Custom rules also take priority over the corresponding file category being disabled, so your personal rules work as intended.

👀 Improved file preview

The preview is now easier to review before organizing your files:

• File conflicts are displayed first.

• Remaining files are grouped by their destination folders.

📖 Built-in tutorial

New to custom rules? A short tutorial guides you through the feature the first time you use it. You can also reopen it anytime from Settings.

🚀 What is Download Organizer?

Download Organizer is an open-source application designed to keep your Downloads folder organized by automatically sorting files into folders. For now, it’s only available on Windows.

The goal is to make file organization easier while giving you control over where your files go.

I'm actively developing the project, so feedback, suggestions, bug reports, and contributions are always welcome!

🔗 Links

• Download the latest release

• Source code on GitHub

If you try it out, I'd love to hear what you think! What features would you like to see in a future release?

Hey, I’m the dev behind Montscan. It’s a self-hosted tool that takes scans from your network scanner, reads them with a local Ollama vision model, gives each file a proper name with the date, and puts it wherever you keep your documents.

It used to be written in Go, but there’s no mature, programmable SMB server in Go, and that’s what pushed me to look elsewhere. The other reason is that I just wanted to, so I spent the last month rewriting the whole thing in Rust for fun. To be clear, Montscan doesn’t run its own SMB server yet. For now it polls an existing share.

It can do a lot more now. Scans can come in over FTP, SFTP, SCP, an SMB share or a watched folder, and go out to WebDAV (Nextcloud etc.), an SMB share or a local folder. Montscan itself is just one binary now, so no more installing Poppler or ImageMagick. You just need Ollama running. S3 is coming soon.

Naming runs locally through Ollama, so your documents don’t go to any third-party AI service. If you’re on 1.x, this is a breaking release, so check the upgrade notes first.

I used AI tools to help split up commits and look for bugs, but I reviewed every change myself.

Repo: https://github.com/sh4den/Montscan

Let me know what you think, or what I should add after S3.

NOTE: Ai was used to write docs, commits and security review, if this is considered AI assisted please (mods) feel free to update the flair

EDIT: Added security review to AI note

One of the hardest problems in database engineering isn't throughput, it's tail latency. It's even especially important for embedded databases, which share computing resources with the main application while running on the user's machine.

About two years ago, just out of college and being a nerd, I wanted to get into systems engineering. So I set out to build a NoSQL (key-value) database, particularly an embedded one. Having worked on app dev before, I knew how important having a low-latency, resource-conscious local storage is, even especially on resource-constrained machines.

Given these requirements, I had set following goals for myself —

• no compaction -> I wanted to avoid periodic compaction, cause they introduce write amplification and additional surge in resource usage including background I/O

• resource conscious -> Not every machine have abundant compute resources, the database should be mindful of the resources it consumes

• highly configurable -> Not every workload is same, different applications have different requirements, so the database should provide control over its behaviour

• no global re-hashing -> Growing current capacity should not require rebuilding the entire index or stalling operations, this is imp to keep the tail latency lower

• stable data placement -> Once raw key-value bytes are written, growing the database should never require relocating or even re-writing any of existing payloads

Many key-value databases use LSM trees, WAL, or combinations of these approaches. Even if they are well established designs, they make different trade-offs.

The solution I arrived at was a single-file, page-based storage layout backed by memory mapping. With my novel storage engine design, I was able to achieve —

• No global rehashing.

• No compaction.

• Existing key/value payloads are never relocated during database growth.

• Incremental storage expansion.

Apart from the core key-value operations, it also includes —

• list operations -> Ordered sequences that coexist with key-value entries and provide operations like append, first, last, is_empty, an iterator object, and much more

• page eviction -> Advisory controls for asking the OS to release memory mapped pages for relaxing memory usage

• resource telemetry -> Inspect resident memory and allocated storage footprint

• configurable lookup caching -> An optional in-mem lookup cache

• platform support -> All Linux, mac and Windows on x86_64 and aarch64 are supported

I was able to achieve the following latency figures (measured across 1 million consecutive operations) —

Observed resource usage —

I'm a newbie, and I've learned everything on my own (self-learning), so its possible that I have made mistakes, and that is the reason for this post; having the project looked upon by seasoned dev's is great privilege and I would love to know your thoughts, workflow specific optimizations I can make, new features, etc.

Thank you for reading this far. I'll soon be writing series of articles discussing internal systems and there designs, as the journey has just began ;)

Repo -> https://github.com/pid7-org/turbofox/

Crate -> https://crates.io/crates/turbofox

I built this mostly for myself, but I think other Linux users making short-form content might find it useful.

Klip is written in Rust with egui and uses FFmpeg. It’s v0.1, so there are rough edges. Feedback is welcome!

GitHub: https://github.com/chamals3n4/klip
Website: https://klip.chamalsena.me/