Forem: Rose Media House

Writing C++ VLC alternative on Windows, Rose Player

Rose Media House — Wed, 04 Jun 2025 18:50:07 +0000

I had good days with Celluloid back in 2019, on Linux Mint. I'd argue, it's still the king of video players available today. I will not forget the fluid frame updates when I held down arrow keys. Those who consume lots of movies on Linux, might resonate with me.

Fast forward a year, I had to switch away from Linux, and move back to Windows on my laptop, and I had only one. But the memory of Celluloid struck with me, and I was no longer satisfied with VLC. I needed a better one, and I found one very close. It was called KM Player.

Time passed. Life was happy with KM Player. Then I got a job. And I forgot about leisure time, so I had not touched it for straight six months. One day, as our team just delivered the project we were working on, we were granted 2 weeks of paid leave. That night, I torrented a bunch to binge watch a TV series. And I opened KM Player after good six months.

Oh no. KM Player is infested with ads and it feels nothing like it's older self. performance sucked, UX sucked. I un-installed it.
I literally felt betrayed, and I also find out, no one cares about making a Windows app with great UX like mac or even linux, because the love is not there. Microsoft itself does ridiculuous things with their documentations that make you ultimately confused and run back to shitty world of Electron apps.

Back in 2022, I could make a React website, but certainly not a C++/C# desktop app. So I just let the good dreams and expectations go away, and be content with subpar experience with VLC.

But there is a saying, you do not forget your first love, and in my case, it was Celluloid. I dreamt of it, I was totally lost in it.

I was a pretty mediocre developer. And I think the best outcome of AI was for me, is that it bridged the gap between mediocre and rare breed of 10x devs. Everybody with a taste and burning passion can be a developer. I just needed enough heart to take on fulfilling my dream: port Celluloid experience to Windows.

I had a few many options at hand.

-> Go with familiar web technologies. Tauri and project mpv command line output in Webview (works on all platforms, theoritically)
Tried, but I was not successful at this.

-> React Native (The thing Windows 11 start menu is built with): A solid candidate, but few days ago I just completed a React Native mobile app, the experience was hellsih and performance was so so. So I passed on it. I didn't bother with flutter because dart is one of my least favorite lang to work with.

-> GTK/QT route: I hated QT interfaces. One of the reasons I never touched KDE linux. I love GTK, but after trying it out, the interface on Windows felt out of place. And in my mind, I was not going to settle for anything less than a great UX, even at the cost of non-existing DX.

-> The Windows native route: (WinUI/XML/C++): This should have been developers preferred way of building native apps for windows. Unfortunately for us, Microsoft always seems confused. In 2025, I needed to write the UI in XML(!), hook event listeners to UI and in a separate C++ file, manipulate the UI. No state management at all. This seemed hectic for me, and I knew it would become extremely hard to track variables later on when code gets bigger. But I chose the pain, to build something great.

I won't go into details how the development journey was, it was a wild ride. I got full control over my dream of making the perfect video player, and I gave Rose Player everything VLC and now KM Player does not have.

Timeline hover previews: for a 2 hours FHD movie, generates all the previews in ~35 seconds (roughly 1500 preview images), so when movie opens, within half a minute you are able to browse the whole timeline. This is such a basic feature that is not available on both VLC and KMP, which feels insane.
Smooth Frame Updates with rapid seek: This was my biggest gripe with VLC, it always felt choppy. KM Player was better at this, and Celluloid was the best of all, like ultra fluid. My goal was to reach Celluloid level, and I think I am close to achieving it.
Smooth dragging by slider: An issue I see with all video players, some of them (like Celluloid) freezes the screen until drag ends. It's bad UX. People want to know what they are skipping. VLC shows you what parts you are skipping but shows only a few frames. I tried my best so Rose Player actually tries to show most frames that you skipped with minimal dropped frames.

Rose Player is now mostly stable, its hosted on Microsoft Store Now. I do periodical updates, and research on how to make it a better experience for myself and others.

Download Rose Player:
Download from Microsoft Store

Want Promo Code? Follow and DM me on X

Let me know your thoughts on comments below :)

Find best bus seat to avoid the sun while traveling

Rose Media House — Sun, 22 Oct 2023 15:28:57 +0000

www.SitInShade.com

This is so specific this is hilarious. Some clever guy made this and shared in a reddit post

sitinshade.com

Meet Fred: The most awesome Redis client for Rust.

Rose Media House — Wed, 18 Oct 2023 16:00:30 +0000

TLDR

aembke / fred.rs

An async client for Valkey and Redis

Fred

An async client for Valkey and Redis

Example

use fred::prelude::*;
#[tokio::main]
async fn main() -> Result<(), Error> {
  let config = Config::from_url("redis://localhost:6379/1")?;
  let client = Builder::from_config(config)
    .with_connection_config(|config| {
      config.connection_timeout = Duration::from_secs(5);
      config.tcp = TcpConfig {
        nodelay: Some(true),
        ..Default::default()
      };
    })
    .build()?;
  client.init().await?;

  client.on_error(|(error, server)| async move {
    println!("{:?}: Connection error: {:?}", server, error);
    Ok(())
  });

  // convert responses to many

…

View on GitHub

Back Story

The goto Redis client for Rust is called redis-rs. It has over 3k stars on Github. but I found it very annoying to use because I quickly found out that if you want to set any value you had to get a mutable reference to the underlying client. Which meant great pain to store Redis client in the global scope. People who do not know what a mutable reference is consider the let keyword in JavaScript. you can mutate or change a variable that is initiated with let.

The other annoyance I had that it didn't support RedisJson which was a bummer because it is very helpful if you store anything other than String key value pair.

Fortunately then I found Fred. Fred is a beautiful piece of engineering. It solved all of the problems I had with the redis-rs package. It is async friendly, it supports RedisJson and most importantly it doesn't require a mutable reference to set value.

It also has a lot of other great features. Consider starring the project and spreading the words!

Neo4j, A Database on Crack 🚬

Rose Media House — Sun, 15 Oct 2023 17:08:37 +0000

Lol What?

It's good. I mean it. You do not have SQL like rigid tables holding your data, foreign keys to map relation. It's not plain key-value pairs like Mongodb, either. Instead, you have this:

The connecting line is the "Relation" between two objects (or Node), which is a foreign-key in sql, or reference in Mongodb. But the difference is, you define the relation just as is:

CREATE (you:Person)-[relation:LEARNING]->(js:Language)

Any Superpowers?

Yes. It's relational, but at the same time free of the rigidity that comes with SQL tables. It's nosql (cypher), but free from the lacking of proper relationship in Mongodb. it's the best of the both worlds.

Tell me more

Everything is a Node. You draw lines to connect them. And that's relationship. This is how a Node looks like:

This is how you connect these Nodes:

Why isn't it everywhere?

Performance sucks compared to Postgres and Mysql.
Important features like Sharding and Live Backup - are behind a very expensive corporate license.
Their cloud service (Aura) starts at 65$/month. The service was announced in 2021. It's fully managed, and getting good traction.
No support for querying nested properties/fields like MongoDB. Manually parsing JSON string is the way to go.

Give it a go

Query a Neo4j database using Cypher - Getting Started

A high-level overview of the graph query language Cypher.

neo4j.com

WTransport - WebTransport library in Rust 🦀

Rose Media House — Fri, 13 Oct 2023 15:12:47 +0000

WebTransport is a modern update to Websockets, transmitting data between client and server using http3.

WTransport is an implementation http3 WebTransport written in Rust.

BiagioFesta / wtransport

Async-friendly WebTransport implementation in Rust

WTransport

WebTransport protocol, pure-rust, async-friendly.

Introduction

WebTransport is a new protocol being developed to enable low-latency, bidirectional communication between clients and servers over the web It aims to address the limitations of existing protocols like HTTP and WebSocket by offering a more efficient and flexible transport layer.

Benefits of WebTransport

🚀 Low latency: WebTransport is designed to minimize latency, making it suitable for real-time applications such as gaming, video streaming, and collaborative editing.
🔄 Bidirectional communication: WebTransport allows simultaneous data exchange between the client and server, enabling efficient back-and-forth communication without the need for multiple requests.
🔀 Multiplexing: With WebTransport, multiple streams can be multiplexed over a single connection, reducing overhead and improving performance.
🔒 Security: WebTransport benefits from the security features provided by the web platform, including transport encryption and same-origin policy.
🌐 Native Browser Support: WebTransport is natively supported…

View on GitHub

Benefits of WebTransport:

🚀 Low latency: WebTransport is designed to minimize latency, making it suitable for real-time applications such as gaming, video streaming, and collaborative editing.
🔄 Bidirectional communication: WebTransport allows simultaneous data exchange between the client and server, enabling efficient back-and-forth communication without the need for multiple requests.
🔀 Multiplexing: With WebTransport, multiple streams can be multiplexed over a single connection, reducing overhead and improving performance.
🔒 Security: WebTransport benefits from the security features provided by the web platform, including transport encryption and same-origin policy.

WTransport's simple API

WTransport comes with both server and client implementaton. Here is how it looks:

Server

#[tokio::main]
async fn main() -> Result<()> {
    let config = ServerConfig::builder()
        .with_bind_default(4433)
        .with_certificate(certificate)
        .build();

    let connection = Endpoint::server(config)?
        .accept()
        .await     // Awaits connection
        .await?    // Awaits session request
        .accept()  // Accepts request
        .await?;   // Awaits ready session

    let stream = connection.accept_bi().await?;
    // ...
}

Client

#[tokio::main]
async fn main() -> Result<()> {
    let config = ClientConfig::default();

    let connection = Endpoint::client(config)?
        .connect("https://[::1]:4433")
        .await?;

    let stream = connection.open_bi().await?.await?;
    // ...
}

Get Started

The repo has a full example, where you launch a server and a chrome instance to communicate with each other over h3 WebTransport protocol. Here you can find it:
https://github.com/BiagioFesta/wtransport/blob/master/wtransport/examples/full.rs

⚡Socketioxide - SocketIO server powered by Rust! 🦀

Rose Media House — Tue, 10 Oct 2023 18:37:34 +0000

Rust is hard, so is writing networking code in it. But who doesn’t want its blazing fast speed? Socketioxide fills the gap. It’s socket.io, but with speed and safety, that helps you achieve unimaginable while keeping it dead simple.

Socket.io is a massively popular websocket/polling framework with about 60k stars on github. Socket.io server is officially written in Node.js, which was ported to Python, Go (upto v1.4), Java and Swift by the community. Now, there is a Rust port as well, Socketioxide:

Totodore / socketioxide

A socket.io server implementation in Rust that integrates with the Tower ecosystem and the Tokio stack.

`Socketioxide` 🚀🦀

A socket.io server implementation in Rust that integrates with the Tower ecosystem and the Tokio stack. It integrates with any server framework based on tower like Axum, Warp, Salvo, Viz or Hyper. Add any other tower based middleware on top of socketioxide such as CORS, authorization, compression, etc with tower-http.

Features

Integrates with
- Axum: 🏓echo example
- Warp: 🏓echo example (Not supported with socketioxide >= 0.9.0 as long as warp doesn't migrate to hyper v1)
- Hyper: 🏓echo example
- Salvo: 🏓echo example
- Viz: 🏓echo example
Out of the box support for any other middleware based on tower
Effortless horizontal scaling with plugable adapters:
- Redis / Valkey
- MongoDB
- More to come...
Remote cluster communication with Socketioxide-emitter
Namespaces and Dynamic Namespaces
Rooms
Ack and emit with ack
Binary packets
Polling & Websocket transports
Common (default) & Msgpack parsers
…

View on GitHub

🎉 Latest Release (`v0.8.0`)

v0.8.0 was released on Dec 12. See the full release note here: https://github.com/Totodore/socketioxide/releases/tag/v0.8.0

💎 Socketioxide Features

Integrates with:
- Axum
- Warp
- Hyper
- Salvo
Out of the box support for any other middleware based on tower :
Namespaces
Rooms
Ack and emit with ack
Binary packets
Polling & Websocket transports
Extensions to add custom data to sockets
Memory efficient http payload parsing with streams
Api that mimics the socket.io JavaScript api as much as possible
Well tested with the official end to end test-suite
Socket.io versions supported :
- protocol v5 : based on engine.io v4 under the feature flag v5 (default), (socket.io js from v3.0.0..latest)
- protocol v4 : based on engine.io v3, feature flag v4, (socket.io js from v1.0.3..latest)

🪄 Power of Rust + Simplicity of Socket IO

The thing about socket.io is that it’s so simple, that someone who just learned JavaScript can get started with it. Write an html page, bring the client and hook some event listeners.

On the other hand, Rust is a language with powerful type system and runtime speed. Programs written in Rust are more memory safe than C, C++ etc. That makes Rust a great choice for both mission critical and general purpose software development.

Now that you can combine the simplicity and power together, Socketioxide emerges as a great choice for realtime apps.

🧑‍💻 How to get started with it?

This is an example of socket.io echo server with Socketioxide and Axum

use axum::routing::get;
use axum::Server;
use serde_json::Value;
use socketioxide::SocketIo;
use tracing::info;
use tracing_subscriber::FmtSubscriber;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    tracing::subscriber::set_global_default(FmtSubscriber::default())?;

    let (layer, io) = SocketIo::new_layer();
    io.ns("/", |socket, auth: Value| async move {
        info!("Socket.IO connected: {:?} {:?}", socket.ns(), socket.sid);
        socket.emit("auth", auth).ok();

        socket.on("message", |socket, data: Value, bin, _| async move {
            info!("Received event: {:?} {:?}", data, bin);
            socket.bin(bin).emit("message-back", data).ok();
        });

        socket.on("message-with-ack", |_, data: Value, bin, ack| async move {
            info!("Received event: {:?} {:?}", data, bin);
            ack.bin(bin).send(data).ok();
        });

        socket.on_disconnect(|socket, reason| async move {
            info!("Socket.IO disconnected: {} {}", socket.sid, reason);
        });
    });

    io.ns("/custom", |socket, auth: Value| async move {
        info!("Socket.IO connected on: {:?} {:?}", socket.ns(), socket.sid);
        socket.emit("auth", auth).ok();
    });

    let app = axum::Router::new()
        .route("/", get(|| async { "Hello, World!" }))
        .layer(layer);

    info!("Starting server");

    Server::bind(&"127.0.0.1:3000".parse().unwrap())
        .serve(app.into_make_service())
        .await?;

    Ok(())
}

If you want to build a chat app, here is an example to get you started: https://github.com/Totodore/socketioxide/tree/main/examples/src/chat

If you are planning to use a frontend framework like React, Angular or Svelte, consult the official docs: https://socket.io/docs/v3/client-initialization/

Try it out and star⭐ on Github!

Forem: Rose Media House

Writing C++ VLC alternative on Windows, Rose Player

Find best bus seat to avoid the sun while traveling

www.SitInShade.com

Meet Fred: The most awesome Redis client for Rust.

TLDR

aembke / fred.rs

An async client for Valkey and Redis

Fred

Example

Back Story

Neo4j, A Database on Crack 🚬

Lol What?

Any Superpowers?

Tell me more

Why isn't it everywhere?

Give it a go

Query a Neo4j database using Cypher - Getting Started

WTransport - WebTransport library in Rust 🦀

BiagioFesta / wtransport

Async-friendly WebTransport implementation in Rust

WTransport

Introduction

Benefits of WebTransport

WTransport's simple API

Server

Client

Get Started

⚡Socketioxide - SocketIO server powered by Rust! 🦀

Rust is hard, so is writing networking code in it. But who doesn’t want its blazing fast speed? Socketioxide fills the gap. It’s socket.io, but with speed and safety, that helps you achieve unimaginable while keeping it dead simple.

Totodore / socketioxide

A socket.io server implementation in Rust that integrates with the Tower ecosystem and the Tokio stack.

Socketioxide 🚀🦀

Features

🎉 Latest Release (v0.8.0)

💎 Socketioxide Features

🪄 Power of Rust + Simplicity of Socket IO

🧑‍💻 How to get started with it?

`Socketioxide` 🚀🦀

🎉 Latest Release (`v0.8.0`)