I've been working on a project called Rustyfin, an open-source media server written in Rust that aims to be a lightweight alternative to Jellyfin.
The idea came from a simple question: how much of a media server do we actually need just to stream movies and TV shows on a local network?
Jellyfin is a great project, but I wanted to explore a different approach: less memory, faster startup, simpler architecture, and compatibility with existing Jellyfin clients.
No need to build another mobile or TV app.
The benchmarks surprised me
I ran a series of benchmarks comparing Rustyfin v0.17.5 against Jellyfin 12.4.0.
Both servers were tested on the same machine, using the same media library and container resource limits.
Here are some results:
| Metric | Rustyfin | Jellyfin |
|---|---|---|
| Idle RAM | 11 MiB | 391 MiB |
| Startup time | 0.6s | 6.0s |
| Initial scan (30 GB) | 3.0s | 57.7s |
| API throughput (50 connections) | 2,353 req/s | 54 req/s |
| Direct Play throughput | 182 MB/s | 78 MB/s |
That's roughly:
- 35x less RAM at idle.
- 10x faster startup.
- 19x faster library scanning.
- 43x more requests per second on the tested API endpoint.
- 2.3x higher Direct Play throughput with a single stream.
These results came from a controlled environment with 4 CPUs, 4 GB of memory, and a library of 18 video files totaling approximately 30 GB.
They're not universal performance guarantees, and there's still plenty to test on different hardware and larger libraries.
The complete methodology and results are available here.
What's under the hood?
Rustyfin uses a fairly straightforward stack:
- Rust + Axum + Tokio for the HTTP server and asynchronous operations.
- SQLite in WAL mode for the media library and user data.
- HTTP Range Requests for efficient Direct Play.
- FFmpeg for remuxing and transcoding.
- Intel and AMD GPU acceleration where supported.
One of the main design decisions was to prioritize Direct Play.
When the client can handle the original media format, the server shouldn't have to transcode it. It should just deliver the requested bytes efficiently.
Rust also helps keep the runtime lightweight. There's no garbage collector, and the memory management model makes it easier to reason about resource usage.
Of course, Rust alone doesn't make software fast. Avoiding unnecessary file reads, database queries, and allocations matters just as much.
In fact, benchmarking Rustyfin helped uncover performance issues in the media scanner that I ended up fixing.
What about Jellyfin compatibility?
This is probably the most interesting part of the project.
Instead of creating another client ecosystem, Rustyfin implements the Jellyfin API so existing apps can communicate with it.
I've already tested playback with Moonfin on Android and Samsung Tizen, including Direct Play and seeking. Compatibility testing with other clients, such as Swiftfin and Findroid, is still ongoing.
Rustyfin also supports HLS, subtitles, library management, multiple users, and a web administration panel.
That said, it's not a complete replacement for Jellyfin yet.
Features like live TV, DVR, DLNA, SyncPlay, and Jellyfin's plugin ecosystem aren't supported. The current focus is local media streaming, especially on machines with limited resources.
What's next?
I'm still actively developing Rustyfin, improving client compatibility, testing different hardware configurations, and working on the features that matter most for everyday use.
If you have an old laptop, a mini PC, a NAS, or just enjoy experimenting with self-hosted software, I'd love to hear what you think.
The project is open source under the MIT license.
GitHub: https://github.com/mensonones/rustyfin
If you use Jellyfin, what features would you consider essential before trying an alternative?
Feedback, issues, and contributions are welcome!



