3D Visuali Logo

Turning a Cheap Android TV Box into a 24/7 Linux Home Server and Media System

How I repurposed an H96 Max Android TV box into a hybrid Linux home server using Armbian and LibreELEC.

H96 Max Android TV Box

Turning a Cheap Android TV Box into a 24/7 Linux Home Server and Media System

For a long time, I was looking for a small, quiet device that could run 24/7 without consuming much power.

Something simple, low-cost, and efficient enough to handle basic home server tasks without feeling like overkill.

Typical options like Raspberry Pi or Orange Pi work well, but once you add storage, power supplies, and accessories, the total cost can get surprisingly high for the performance you get.

So I started looking for alternatives.

The Idea: Android TV Boxes as Linux Devices

While browsing through Armbian forums, I came across people repurposing cheap Android TV boxes into Linux machines.

That immediately caught my attention.

These devices often run ARM-based SoCs and can sometimes be flashed with Linux distributions like Armbian, depending on hardware support.

Eventually I ended up with the H96 Max (RK3328):

  • 4 GB RAM
  • 64 GB internal storage
  • Android-based firmware
  • 4K video support
  • WiFi + Ethernet
  • HDMI + USB ports

Nothing special as a TV box, but potentially very interesting as a low-power always-on system.

Flashing Armbian and First Boot

After some research and trial-and-error, I managed to flash Armbian onto the device.

Like most Android TV box projects, it wasn’t completely straightforward. Different images, boot issues, and a few failed attempts were part of the process.

Eventually, it booted successfully into Linux.

From there, it quickly started to feel like a usable headless system.

Running Services on Armbian

Once Armbian was running, I started experimenting with real workloads.

The first service I set up was Pi-hole, installed directly on the system (not in Docker). It worked well as a lightweight network-wide DNS filter and immediately became useful in my home network.

Next, I installed Jellyfin natively as well, also outside of containers. The goal was to keep the core services simple and stable.

In addition to that, I ran a few Docker containers for smaller experiments and auxiliary services.

At this point the setup looked like this:

  • Pi-hole (native installation)
  • Jellyfin (native installation)
  • A few Docker containers
  • Fully headless Linux environment

For a cheap Android TV box, it already felt like a surprisingly capable home server.

The Problem: Headless YouTube Playback (mpv + yt-dlp)

One thing I wanted to experiment with was YouTube playback in a fully headless setup.

There was no browser or desktop environment involved — everything was strictly terminal-based.

For this, I used mpv combined with yt-dlp to stream YouTube content directly from the command line:

  • yt-dlp resolves the video stream
  • mpv handles playback

This setup works well in general Linux environments.

However, on this device it did not work reliably from the beginning.

The main issue was not the tools themselves, but hardware and driver limitations:

  • inconsistent hardware video acceleration on Armbian
  • CPU fallback decoding on RK3328
  • unstable performance for higher resolutions
  • limited VPU/GPU support on TV box firmware

As a result, playback was often CPU-heavy and not smooth enough for a good experience.

So while the idea of a fully headless media setup was clean, in practice it was not usable in this configuration.

Switching Direction: LibreELEC (Kodi)

At that point, I started looking for a more media-focused solution instead of forcing a headless Linux setup into something it wasn’t really suited for.

Someone in a Discord community suggested LibreELEC, a lightweight Kodi-based operating system designed specifically for embedded devices and hardware video playback.

That turned out to be the right direction.

LibreELEC provided:

  • Kodi-based media center
  • proper hardware-accelerated playback
  • stable and smooth media experience

But the interesting part is that I didn’t use it only as a media system.

I also managed to run additional services alongside it:

  • Pi-hole
  • Jellyfin
  • a few Docker containers

So in practice, LibreELEC became a hybrid setup rather than just a media box. It ended up being a “best of both worlds” configuration — handling media playback through Kodi while still running lightweight server services in the background.

Final Setup and Outcome

In the end, the device evolved into two different modes depending on the operating system:

Armbian (server-focused phase)

  • Pi-hole (native installation)
  • Jellyfin (native installation)
  • Docker for experiments
  • Headless Linux setup

LibreELEC (hybrid media + services)

  • Kodi-based media center
  • Hardware-accelerated playback
  • Pi-hole + Jellyfin + Docker containers alongside Kodi
  • Combined media frontend and lightweight server

Final Thoughts

What started as a cheap Android TV box turned into a surprisingly flexible low-power home lab device.

It’s not perfect, and it requires tinkering, especially around hardware support and software compatibility. But that’s also what makes it interesting.

It’s pretty amazing what a cheap Android TV box can become once you throw Linux on it instead of Android.

The biggest takeaway from this project is that the same hardware can behave completely differently depending on the software stack:

  • Armbian → better as a headless server and experiment platform
  • LibreELEC → better as a media-focused hybrid system

In the end, the H96 Max (RK3328) proved that even cheap TV boxes can be repurposed into useful 24/7 systems if you’re willing to work around their limitations.

And sometimes, the best solution isn’t choosing between “server” or “media box” — but combining both in a way that actually fits the hardware.

This is the beginning of my Home Lab Experiments series, where I’ll document small but practical builds like this.