I Wanted YouTube's Simplicity in VLC — So I Built My Own Media Player

I use VLC because it plays almost everything.

MKV. MP4. WebM. AVI. MOV. Multiple audio tracks. Subtitles. You name it.

But there was one thing I kept wishing VLC had:

A simpler, more modern interface.

Something that felt as easy to use as YouTube, while keeping the flexibility of a desktop media player.

So I decided to build it.

Meet Simple YT Style Player — a lightweight media player inspired by YouTube's simplicity and VLC's versatility, now running on both Windows and Android.

View the project on GitHub →

Before vs After

The idea is easier to understand with a real example.

Imagine you've downloaded a large MKV movie containing:

• Multiple audio languages
• Embedded subtitles
• A long runtime
• A quiet audio mix

Before

You open a traditional media player and start searching through menus for:

Audio Track
Subtitle Track
Playback Speed
Aspect Ratio
Rotation
Brightness
Volume
Loop
Picture-in-Picture

The functionality is there, but the experience can feel unnecessarily complicated.

After

The goal with Simple YT Style Player is much simpler:

Open file
   ↓
Choose audio / subtitles
   ↓
Play
   ↓
Swipe / seek / adjust
   ↓
Keep watching

And when you need advanced controls, they're still there.

The idea was not to remove functionality — it was to make the functionality easier to reach.

What It Can Do

The player currently supports a surprisingly wide range of playback features.

Playback

• MKV, MP4, WebM, AVI, MOV and other formats supported through FFmpeg
• Multiple audio-track selection
• Embedded subtitle support
• Playback speed from 0.25× to 2×
• Configurable skip interval
• Looping
• Resume playback
• Touch scrubbing
• Long-file hour-aware timestamps

Picture & Sound

• 16:9, 4:3 and source aspect ratio
• Video rotation
• Brightness adjustment
• Volume up to 200%
• Reactive audio visualiser with multiple themes
• Picture-in-picture mode

Desktop Features

• File associations
• Auto-hiding playback controls
• High-DPI support
• Keyboard shortcuts

One Player, Two Platforms

One of the interesting parts of the project was making the same player work across Windows and Android.

The architecture is roughly:

             Simple YT Style Player
                       │
                Shared UI / Logic
                       │
              ┌────────┴────────┐
              │                 │
           Windows            Android
              │                 │
        Rust + FFmpeg      Rust + FFmpegKit
              │                 │
              └────────┬────────┘
                       │
                 Media Playback

The project uses Tauri 2 as the native shell and Rust for the core media operations.

The interface itself is intentionally lightweight:

Vanilla HTML + CSS + JavaScript.

No UI framework is required.

Why Rust + Tauri?

The first version of this project was built using Electron + HTML.

It worked, but I wanted the next version to feel more like a real native application.

So version 2 was rebuilt around:

• Tauri 2
• Rust
• FFmpeg / FFprobe
• Vanilla HTML/CSS/JavaScript

This gave me a shared application architecture that could target both desktop and mobile while keeping the core media logic in Rust.

The Android Problem I Had to Solve

One of the more interesting technical challenges was Android playback.

A normal Android file picker can return a content:// URI.

But the WebView-based interface cannot simply treat that URI like a normal local file.

So the application resolves the selected file and serves it through a local HTTP connection.

Why?

Because video playback engines naturally work with HTTP byte-range requests.

Instead of trying to force the player to consume an Android content:// URI directly, the application exposes the local file through a loopback connection and lets the video engine request the parts of the file it needs.

That also means seeking and buffering behave much more naturally.

Subtitles Without Extra Files

Another feature I wanted was support for subtitles embedded directly inside media containers.

For example, an MKV can contain:

Movie
├── Video
├── English Audio
├── Hindi Audio
├── English Subtitles
└── Hindi Subtitles

The player can inspect the container, expose the available subtitle tracks, and allow the user to switch between them without requiring separate .srt files.

The same idea applies to multiple audio tracks.

The Controls Stay Out of the Way

One design choice I particularly like is the auto-hiding control interface.

During playback, the controls disappear rather than permanently occupying the screen.

On mobile, the layout also adapts between portrait and landscape orientation.

The goal is simple:

The video should remain the focus.

Picture-in-Picture

Sometimes you don't actually want the video to stop just because you need to use another application.

The player therefore supports picture-in-picture, allowing playback to continue in a smaller floating window.

This is particularly useful for tutorials, lectures, reference videos and long-form content.

Keyboard Shortcuts

The desktop version also supports familiar keyboard controls:

Key	Action
Space / K	Play / Pause
M	Mute / Unmute
O	Open a file
F	Fullscreen
I / P	Picture-in-picture
←	Skip backward
→	Skip forward

No Account. No Ads. No Telemetry.

This is one of the principles behind the project.

The player is designed to play your files.

There is:

• No account
• No sign-in
• No advertising
• No analytics
• No external backend required for playback

It can work completely offline.

Windows + Android Releases

The current repository provides builds for:

Windows 10 / 11 (64-bit)

and

Android 8.0+ (arm64)

The installers and APK are available from the GitHub Releases page.

Download the latest release →

Build It Yourself

The project is open source and can also be built from source.

Windows

npm install
npm run tauri:build

For development:

npm run tauri:dev

Android

rustup target add aarch64-linux-android
npm run android:dev

For an APK:

npm run android:apk

The repository also includes automated Rust tests for media probing, subtitle extraction and audio remuxing using real FFmpeg-generated media fixtures.

Architecture

The project separates the user interface from the platform-specific media implementation.

This became especially important when adding Android support because Windows and Android cannot execute FFmpeg in exactly the same way.

Windows uses FFmpeg sidecar processes, while Android uses FFmpegKit in-process through JNI.

The higher-level player logic can still remain shared.

From a "Skin" to a Real Player

The project started from a simple idea:

"What if VLC had a cleaner, more YouTube-like interface?"

But that idea gradually grew into something bigger.

Version 1 was an Electron + HTML implementation for Windows.

Version 2 became a Rust + Tauri 2 application for Windows and Android, with a growing set of playback and mobile features.

So although the repository is still called:

vlc-youtubeskin

the project has evolved into something closer to a standalone media player.

What I Want to Build Next

There is still plenty I'd like to improve.

Possible future directions include:

• More playback controls
• Better media library management
• Additional mobile polish
• More visual themes
• Playlist support
• Further performance improvements

The project is still evolving.

Try It

If you've ever wanted something between VLC's compatibility and YouTube's simplicity, give it a try.

⭐ GitHub — Simple YT Style Player

The project is released under the MIT License.

And that's really how this started:

I wanted a media player I'd actually enjoy using, so I built one.