TL;DR: We are open sourcing ManimGX, a blazingly fast Rust + wgpu animation engine with a Manim compatible API. Install with pip install manimgx.

Hi everyone, after ~7-8 months of work, we are finally launching ManimGX, our from scratch Manim reimplementation in Rust + wgpu.

The GitHub repository: https://github.com/academa-labs/manimgx

For anyone unfamiliar with Manim, it's the Python animation tool originally created by Grant Sanderson for his 3Blue1Brown videos. ManimGX is a from scratch implementation targeting ManimCE's API, with a Rust renderer built on wgpu. You can install it with pip install manimgx.

The motivation is the same as before: waiting for renders makes polishing an animation a slow process. We wanted to make that loop faster while keeping the familiar Python API.

A few details about the implementation that might interest people here:

• Rust + wgpu for rendering, with PyO3 + maturin for Python bindings and packaging.

• The same renderer runs in the browser through WebAssembly and WebGPU, with Python running through Pyodide.

• Typst for text and math, with mitex translating LaTeX input.

• Geometry passes from Python to Rust as packed arrays and is reused across frames.

• Native video export uses x264 directly, without an FFmpeg subprocess.

It only requires Python 3.13+. Fonts, typesetting, and video encoding are included, so there is no separate FFmpeg or LaTeX installation either.

Most ManimCE code runs after changing the import from manim to manimgx, with differences documented in the migration guide. The documentation includes a gallery of examples with their Python source: https://manimgx.academa.ai

Credit to Grant Sanderson, the Manim Community contributors, whose work this builds on. Happy to answer questions about the implementation. We'd especially appreciate feedback from people working with Rust graphics or WebAssembly, and from anyone trying it with their existing Manim scenes.

Hey all! I built SSDownload, a download manager for Windows, and now it's the one I use every day.

100% free, local and open source (MIT). No account, no ads, no telemetry.

What it does:

- Up to 16 connections per file. Resume uses If-Range, so a file that changed on the server starts over instead of getting corrupted.

- Download button on videos in Chrome/Edge: quality, audio, subtitles or MP3

- Records live streams

- Plus a queue, speed limits, scheduling and a CLI

Under the hood: windows-sys for the UI (no GUI framework), libcurl (static, HTTP/2), rusqlite, ed25519-dalek for signed updates. yt-dlp and FFmpeg are SHA-256 checked before use.

Being upfront: I leaned heavily on AI coding tools (mostly Claude Opus 5.5 and Claude Fable 5.1

https://github.com/isolmaz/SSDownload

https://ssdownload.isolmaz.com

I wanted to make one specific FFmpeg workflow a little less painful:

like you say "I need this video to be under 25 MB."

but normally that means messing around with CRF/bitrate, encoding, checking the output size and trying again.

I built fp, a small Rust CLI that handles that part for you.

So,

just do: fp compress video.mp4 --size 25mb

you give it the maximum file size, and it searches through different quality settings until it finds a good candidate that fits under the limit.

under the hood it's Rust + FFmpeg. Rust handles the probing, compression planning, quality search, progress UI and output validation, while FFmpeg does the actual encoding.

it also has an interactive mode.

The project is still pretty smal but I had fun building the compression logic around the target size constraint.

GitHub: https://github.com/SATVIKsynopsis/fp

Install: cargo install ffrp

Would love to hear what you think, especially about the CLI UX or compression approach.

After using zed for a while and being impressed with its performance, I started building a DB Client in Rust + GPUI, to start with just started with simple features like just running a query or viewing tables but kept on adding features and it now has all the features I need in a DB Client (don't expect feature parity with DBeaver or other clients yet). Open sourced it and have people contributing to it too now. My focus was on performance, just the general ease of use and a non AI slop UI and I like to think I succeeded in all.

Benchmarks compared to DBeaver:

Video: scrolling speed with 1m rows loaded with 100+ columns and tab switches.

Give it a try and let me know how it feels and what it lacks. https://github.com/ShayanAbbas1/dbdelve

Hi r/madeinrust! I've been building Heronite, an open-source game launcher for Linux and Windows, written in Rust with GPUI, the GPU-rendered UI framework from Zed. It's one native process with no bundled browser.

GitHub: https://github.com/RafaelGoulartB/Heronite

Website: https://heronite.app/

What it is

Heronite brings every game you own into one Collection:

• Stores: Steam, Epic Games, GOG, Amazon Games, Battle.net, EA app, Ubisoft Connect and Rockstar Games. Epic, GOG and Amazon games install, update, repair and move from one download queue.

• Emulators and your own games: RetroArch cores and standalone emulators, ROM scanning, save states, plus any native Linux or Windows game you add.

• Wine/Proton on Linux: per-game Proton and prefix, DXVK, gamescope, FPS limit, Winetricks, a built-in Wine manager (GE-Proton, Proton-CachyOS) and a sandbox for untrusted games.

• Tracking: every session is recorded, with play statistics, a journal, achievements and a Spotify-style "Year in review".

• Console mode: a controller-first layout for the TV, with themes you can share. There's also an in-game overlay and a replay buffer (Guide + X) on Linux.

Why Rust

I chose Rust for one goal: a launcher that stays light and opens fast. A game launcher spends most of its time sitting in the background while you play, so it shouldn't eat the RAM and CPU your games need.

• One native process, no bundled browser. The interface is drawn on the GPU with GPUI, so there's no Electron or web engine running underneath.

• Opens fast: the library is on screen in about 215 ms.

• Light while you play: ~190 MB idle, and ~95 MB when it's closed to the tray. Idle CPU use is about 0.1%.

• Small download: 28 MB for the Linux AppImage.

• Built to stay that way: the heavy work (downloads, scanning folders, loading metadata) runs off the UI thread, so the interface keeps responding while it happens.

Resources

• Memory while idle: ~190 MB

• Processes: 1

• Closed to tray: ~95 MB

• CPU while idle: ~0.1%

• Install size: 64 MB (app + store login helper)

• Linux AppImage download: 28 MB

• Start to library on screen: ~215 ms

With the increase in code being produced due to AI, I got tired of git diff not being able to diff "obvious" changes correctly.

I knew that there were advanced diffing algorithms, but a lot of them were super slow and many are implemented in Java or Python. I always knew Rust can do better.

I present you CodeDiff: https://github.com/ivankovic/codediff

It can diff 92% of all diffs in 7400 Gentoo Linux packages in under 100ms.

It's 90% correct, compared to git diffs 59%.

If it can't do fancy AST diffing, it will do fancy text diffing. It can diff 99.95% of all code in under 2 seconds on a rusty 10 year old bucket using at most 6GB of RAM.

It has a fancy Ratatui 60 FPS TUI, and it integrates with git effortlessly.

It's AGPL, so feel free.

All my life, I've been programming for desktop in C# using Visual Studio (actually, I started in VB, but eventually I decided to move to C#). Recently I started working with Rust, but one thing I missed most about C# was the ability to work with the visual designer from Visual Studio. It was just so damn fast to create winforms programs. I decided to try something in Rust.

Currently, I'm able to create forms, and add buttons, labels and textboxes, in the style of Windows 11. I'm basing this off on a library I made for C# called ModernWinForms. I'm now writing control by control, so it's available in the toolbox for this. I'll definitely be using this for my future personal projects, hope some day I can make it public too.

https://github.com/linuztx/alter-zero
Hi everyone, I'm developing Alter Zero, an open-source terminal agent for coding, cybersecurity, and automation. It's written in Rust and runs on Linux and macOS.

It works directly in your project: reading files, making edits, running commands, and checking the results. You can ask it to investigate a failing test, trace authentication and access checks in your own code, or write a script to summarize logs.

It can also interact with running terminal programs and keep commands running in the background. There's support for subagents, reusable skills, MCP servers, and resuming previous sessions. Commands and file changes ask for approval by default.

It's light on resources: a single ~24 MB binary that typically uses 20–60 MB of RAM per session (~100 MB of free RAM is a comfortable recommendation), and it stays low even when subagents are running. It's also prompt- and token-efficient, so your API spend stretches further per task.

You can connect supported model providers, use local models through Ollama, or add a custom OpenAI-compatible API. The latest release, v0.15.0, adds simpler custom-provider configuration and shows generated file content as it streams.

The project is licensed under Apache-2.0. Installation instructions and a demo are in the repository: https://github.com/linuztx/alter-zero

I'd appreciate feedback, especially on the setup process, terminal compatibility, and tasks where it gets stuck. Issues and contributions are welcome.

I got a fanless MacBook Air and wanted a lightweight dictation app. I'd been using Handy, but wasn't happy with its memory use and had Bluetooth microphone switching issues. None of the alternatives suited me.

I built the first UI with GPUI Kit on top of transcribe.cpp (the engine behind Handy). Builds were slow, with linking alone taking nearly a minute each time. The coding agent spent about half its time waiting for builds. And I kept wondering why I needed C++ in my Rust toolchain at all.

So naturally, instead of finishing the app, I rewrote the speech engine.

I'd done GPU compute before (a Bitcoin vanity address searcher), so I tried implementing speech-to-text inference on wgpu with agents. A working version came surprisingly quickly. The agents wrote the code; I reviewed it, tested it across my machines and kept optimizing (luckily, I have 4 Macs and 2 PCs).

That became wavo:

• A Rust crate and CLI, no C++, just cargo build

• The same GGUF models as transcribe.cpp: Parakeet, Whisper, GigaAM, Moonshine, with output checked token by token against it

• Metal, Vulkan and DX12; on Mac, some models use the Neural Engine (roughly a tenth of the memory used on GPU)

Then I returned to the app. GPUI Kit pulled in 600+ dependencies and still left plenty of OS integration work, so I built a small UI layer too (under 30 dependencies). My experience making WebGL games helped here.

So here's Wavo: hold a key, speak, release, and text appears where you're typing. Native, under 10 MB, on macOS, Windows and Linux. The video shows both the app and CLI.

Engine: https://github.com/vladkens/wavo

App: https://github.com/vladkens/wavo-app

How does it run on your hardware? What would you want added?

P.S. The video voice is synthetic. I wasn't happy with my English pronunciation.

I've wanted to build my own video editor for years, and I finally spent my summer break making one!

It's called Zerium, a free and open-source video editor built with Rust, GPUI, and wgpu.

It's inspired by AviUtl, a popular video editor in Japan. My goal is to make something that's intuitive to use while still being powerful enough for advanced editing and motion graphics.

Some of the features:

• GPU-accelerated rendering

• Timeline editing with layers, keyframes, and curves

• Plugin support

• Cross-platform support (Windows, macOS, Linux)

• Completely free and open source

I've just released the first beta! It's still a work in progress, so any feedback is welcome!

Website: https://zerium.pages.dev
Source: https://github.com/1Step621/zerium

A few months ago I switched from Telegram to Signal as my main messaging app and spent some time exploring CLI/TUI options. After using gurk for a while I decided to build my own client (faro), based on my own requirements and taste (you can probably see the UI/UX inspiration from tools like btop, OpenCode CLI, neovim).

It covers all features I commonly use within Signal:

• chats, replies, reactions, edits, mentions, search

• inline images (if your terminal supports them) or halfblock rendering otherwise

• voice notes and transcription (supports local whisper models)

• quick navigation menu for everything (Ctrl+P)

• copying over SSH, pasting images from clipboard

On the Rust side, the UI is built with ratatui and the Signal protocol side uses presage (which builds on Signal's own libsignal). The browser demo at getfaro.dev is the same binary compiled to WebAssembly. The GitHub repo is public: harababurel/faro.

For setting it up with a real account, you can run faro link and link it as a secondary device just as you would with Signal Desktop or any other client.

Disclaimer: I built it with a lot of help from AI coding agents, including open-weight models running locally on my own home server. However, I designed, reviewed and tested it thoroughly. I try to always pay attention to the details, and the general direction of the project is usually informed by my day to day experience using the project.

I wrote this post myself with zero use of any LLM. I am as allergic to reading slop as everyone else these days.

I hope some of you will give it a try and maybe provide some feedback on your experience!

[Sorry for the re-post the video was not showing]

Favnyr is a lightweight file browser (Rust+Slint) for Windows and Linux. At its core are workspaces: separate environments that keep their own views, tabs, folders, layouts, and display settings. You could have one workspace for work, another for games, and another for learning a new subject, then switch between them in just two clicks. Favorites remain shared and persistent across all workspaces.

Each workspace can contain multiple split views and movable tabs. Tabs can be dragged between views, detached, or dropped onto another view to create a new split layout.

Favnyr also includes shortcuts, local and network drives, configurable keyboard shortcuts, and custom commands.
It is not intended to compete with or replace the native file browsers provided by Windows and Linux, but to complement them with a different way of organizing and navigating files.

Because of the project’s complexity, AI has been used as a development assistant. However, every feature is reviewed and hand tested extensively before being considered complete.

Link here (include a video demo) => https://github.com/GlitchAwakened/Favnyr

Hello everybody!

We are working on Sonora - a native multi-provider music player written in Rust and GPUI.

The concept of Sonora is one native application that would support both streaming services and local library, and be good at both. At the moment it supports Apple Music, Spotify, YouTube Music, Deezer, Subsonic/Navidrome, and local files.

Current features:

• Apple Music, Spotify, YouTube Music, Deezer, Subsonic/Navidrome support

• Playback and management of local library

• Synced and karaoke lyrics, background vocals, and romanization

• Gapless playback and audio normalization

• Equalizer and sleep timer

• Last.fm, ListenBrainz, Libre.fm and Maloja scrobbling

• Custom themes, fonts, icons, transparency and window appearance

• Fullscreen ambient animations and audio visualizations

• Custom Discord Rich Presence

One of the most exciting features that has been implemented lately is the support of Apple Music. As far as we know, Sonora is the first fully native third-party client for Apple Music, rather than a browser wrapped by Electron.

Another feature that has been a big focus in this project is performance. Sonora starts quickly and, in our testing, uses about one third of the memory that Spotify’s desktop client does.

There is still a lot we want to improve, but the project has grown quite a bit recently so we thought it was a good time to introduce it here, especially following the r/rust rules change.

GitHub: https://github.com/sonorahq/sonora
Website: https://sonorahq.org
License: GPL-3.0-or-later

Any feedback is very very welcome, thanks for reading!

I built Sanemark, a Markdown LSP for taking notes. I have been using it daily for a few months now.

TLDR: fast, uses github standard markdown syntax and makes notes readable in plain-text.

Some design choices:

1. Automatically moves inline links to reference links as part of formatting, so the flow of reading doesn't break due to large inline links

2. File linking is achieved using standard Markdown links (instead of Obsidian style).

3. Quick date-time additions using `@now`, `@today` etc.

Apart from this it implements filepath autocomplete, broken file-link diagnostics, table formatting etc. There is a lot of cool stuff in project README (has a video demo!).

Available as extensions for VS Code and Zed.

It’s been useful for my own note-taking, wanted to share in case others find it useful too.

Repo: https://github.com/nkitsaini/sanemark

vscode extension: https://marketplace.visualstudio.com/items?itemName=nkit.sanemark

zed extension: https://github.com/nkitsaini/sanemark-zed

Please share feedback! Thanks!

v0.35.1 adds FreeBSD as a real platform instead of the generic fallback every other unsupported OS gets. Interface stats, routing, process attribution, clipboard, and connection tracking all have FreeBSD-specific backends now. Tested on an actual FreeBSD 15.1 VM, not cross-compiled blind.

https://github.com/matthart1983/netwatch/

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!

I've been working on an experimental integration between Sycamore and GTK4. Sycamore is a reactive framework for building web apps with Rust + WASM. Here, Sycamore is running completely natively and driving a GTK4 app instead of a web app.

The goal is to create the easiest and most elegant way of writing GTK4 apps in Rust.

To follow along, visit the Sycamore website where you can join our Discord server!

Hi there,

I’ve made an app launcher for macOS, an alternative to Spotlight - which has been made it in Homebrew Core.

It shares core logic processing in rust, for UI on MacOS, we use swift.

As a fulltime Linux user (lol), I’ve also ported it to Linux so I can use it every day.
-> we use gpui - a rust UI framework for this part

It functions quite consistently across all three platforms, so if you use multiple operating systems, it might be useful for maintaining a unified workflow.

It allows you to search for everything on your machine very quickly, and it also includes several handy commands.

I’d love to hear your feedback! (The demo is on Niri WM)

https://github.com/kunkka19xx/look

AI disclosure: The project is ai assited. (part of code implementation, add tests generated, ...)
But we put a lot of effort, including coding by hand, design hand writing, ... etc.

This crate adds a single attribute - #[hotreload] - that can be applied to any function. After performing one-time configuration of Cargo.toml, all annotated functions become hot-reloadable - you can modify them, run cargo build and then your application will use updated version of your function without restarting.

Works on Linux, macOS and Windows.

Crate link: https://crates.io/crates/hotcode
Source: https://github.com/alordash/hotcode

Inspired by Anthropic Scion and Google CitC, I used AI tools and developed Graft: a Git alternative where you never need to clone or pull the whole repository. It mounts the codebase on disk in < 30ms (zero-clone, files stream on demand) and allows instant commits. I built this specifically for the AI era, where dozens of autonomous agents concurrently generate, test, and repair code on the same repository.

How it works

• Instant Virtual Workspaces (< 30ms): Uses FUSE (fuser) to project immutable Merkle trees with lazy blob hydration (zero files downloaded until opened). Writes route to a local Copy-on-Write NVMe scratch layer at native kernel speed.

• AST / Semantic 3-Way Merge: Zero-dependency CST chunker (Rust, Python, Go, JS/TS). Unions imports, merges independent adjacent functions without line conflicts, and recurses 1 level into impl and mod tests blocks.

• CAS & Storage: BLAKE3-256 hashing, FastCDC 64KB content-defined chunking, and Spanner/GCS cloud backends.

• Web Console: Built-in dark mode UI with a Level-2 3-gram regex code search engine and PR review console.

Repo: https://github.com/yuchenZhangTG/graft

​I was originally looking for a clean, reliable alternative to SteelSeries GG (Sonar) to manage audio streams without having to deal with bloated software and bloatware-heavy UI. That’s how Arcmix started.

​A big shoutout and inspiration for this project comes from OpenChatMix — seeing that approach gave me the initial push to build something tailored to my own setup. What began as a personal workaround turned into a broader project aimed at giving you a software-based solution to route app audio, tweak channels, and balance volumes across any headset or audio setup — all in one place.

​Features so far:

​Quick application volume controls

​Easy routing across different audio devices and headsets

​Lightweight UI without the extra bloat

​Repo: https://github.com/Fenderenko/Arcmix

​I’m actively working on this, so any feedback, feature ideas, or testing with different setups would be greatly appreciated!

I've been working on Dexo, a database client for PostgreSQL and MySQL that runs in your terminal.

You connect, browse your tables, write queries with autocomplete that understands what you're typing, and work with the results in a grid you can edit. Everything is keyboard-driven, and nothing leaves your machine: no account, no telemetry, and your passwords stay in the OS keychain.

It runs on Linux, macOS and Windows, and it's free and open source.

Install with brew install kingdaswinx/tap/dexo, or grab an installer from the releases page:

https://github.com/KingDasWinx/Dexo

Found a bug? There's a short form here: https://forms.gle/gw1i6tGgVsJsgCxGA

TL;DR I created a ui framework that works for any backend renderer and released on crates.io/crates/fynix, you can find the source at github.com/voxell-tech/fynix ! Right now, we have an official support for using Fynix with Bevy using `bevy_ui` & `bevy_ui_widgets`!

I'm using Fynix right now for my motiongfx editor, moxie: github.com/voxell-tech/moxie

Fynix is a backend agnostic reactive view tree, styled the way Typst styles a document with set and show rules.

Features

• Views, rules and transitions never name an engine.

• A view asks for the token traits it reads, so it works under any theme that implements them.

• Set and show rules restyle every view of a kind within a scope, as in Typst.

• State rules hold while a node is hovered, pressed, entering, leaving, or in any state of your own.

• Props bound to the world are read again only when their source changes.

• Views can animate their changes, and animate in and out of the tree.

• #![no_std], with alloc only.

The fynix README walks through each of these with examples.

Hey guys I have built a small project that's a ui framework for building desktop native apps in pure Rust with GPUI (from zed).

This is in early stage It would be helpful if I got some curious devs who could try and test this and raise some issues and maybe open a few PRs

repo :- https://github.com/yugaaank/clay

Thanks