Open Source · AGPL-3.0 Self-hosted · Runs fully offline in your LAN

Short drama,
on your own NAS

A short-drama streaming service you host on your own NAS, with the feel of the popular "Hongguo"-style apps: swipe up and down through the feed, episodes auto-play in sequence, and progress stays in sync across web, Android, and desktop. It runs entirely inside your LAN and never calls an external scraper API.

Deploy Now GitHub Repo ↗
$ docker compose up -d --build
  • Go 1.23 backend
  • Vue 3 H5
  • Native Kotlin Android
  • x86_64 + ARM64
3media sources
3platforms in sync
0external scraper calls
2CPU architectures
1container to run
Core Features

Built for binge-swiping, light enough for a NAS

Swipe your own NAS library like a short-video app — fast, private, and maintenance-free.

Video Feed × Poster Wall

One tap toggles the home screen between a fullscreen vertical feed and a classic poster wall. Swipe your NAS library like a short-video app.

Cross-Device Progress Sync

Progress is stored server-side keyed by "account + show + episode": start an episode in the browser, continue in the app. Re-scans and source changes never lose your place.

Zero Scraper Dependency

Show titles and episode numbers come from file-naming conventions; covers come from posters in the folder, with a built-in fallback. No external API calls, ever.

Three Media Sources

Local directories / WebDAV (Alist, Synology, etc.) / Jellyfin (Emby compatible). Existing Jellyfin libraries plug right in — posters and summaries included.

Multi-Arch Single Image

Pure-Go SQLite (no CGO) is cross-architecture by nature; buildx cross-compiles x86_64 + ARM64 images, so low-power ARM NAS boxes need no QEMU.

Built-in Admin Panel

Add/edit/scan all media sources, check scan status, register users, and keep per-user watch progress isolated — all from the web UI, no terminal required.

Media Sources

Plug in wherever your shows live

Three sources, one pipeline for scanning, playback, and progress. No need to move existing libraries.

Local Directories

Mount your show folders into the container and watch right after scanning. Titles and episode numbers are parsed from file names.

/media/your-show/EP01.mp4

WebDAV

Just fill in the URL and credentials: Alist / Synology / QNAP / OMV all work. Streams are proxied server-side with full Range / 206 passthrough.

dav://alist:5244/dav/dramas

Jellyfin / Emby

Attach an existing library and reuse its posters, summaries, and durations. Containers browsers can't play are 302-redirected to HLS transcoding automatically.

http://jellyfin:8096 + API Key
Every Platform

One progress library, three ways in

The server keeps a single progress store; switch between web, Android, and desktop freely.

http://192.168.31.31:8654
InhoDrama web H5 UI — video feed home

Web H5 Embedded in backend

  • Built assets are embedded straight into the Go binary — delivered as a single container
  • Video feed and poster wall home modes; web player with prev / next controls
  • mp4 plays directly; unfriendly Jellyfin containers fall back to automatic HLS transcoding
InhoDrama Android app — details and episodes InhoDrama Android app — profile page

Android App Native Kotlin

  • Jetpack Compose + Media3/ExoPlayer — no WebView anywhere
  • Swipe to switch episodes, auto-continue, external SRT subtitles, vendor decoder fallback
  • Fullscreen playback rotates to landscape; notch and gesture-area insets fully handled
Get the APK / build it yourself ↗
InhoDrama

InhoDrama
Windows · macOS

Desktop Wails shell

  • Wails v2 embeds the same H5; log in by pointing it at your NAS address
  • Single-file portable builds: double-click Windows exe, universal macOS DMG
  • Reuses the Go stack — no Electron or Node runtime
Product Demo

38 seconds to get InhoDrama

A full walkthrough from deployment to binge-watching (with music).

Quick Start

Three steps to your first binge

Any NAS (or always-on machine) with Docker; two minutes to launch.

  1. 1

    Clone the repo

    On any machine that can SSH into the NAS:

    git clone https://github.com/no1very/inho-drama.git
  2. 2

    Launch

    The multi-stage build packs the frontend and compiles the backend automatically:

    cd inho-drama && docker compose up -d --build
  3. 3

    Add a media source

    Open http://<NAS_IP>:8654 and sign in with the default admin / admin (change it right away), then head to "Mine → Media Sources" to add one. Once scanning finishes, start swiping.

For deployment details (environment variables, reverse proxy, backup & upgrade) see the deployment guide ↗; ARM NAS builds need no QEMU — buildx cross-compiles directly.

Tech Stack

A small, hard tech foundation

No unnecessary layers: one binary, one container, fully native clients.

Backend

Go 1.23modernc.org/sqlite · no CGO stdlib net/httpgowebdavbcrypt + Token

H5 Frontend

Vue 3VitePinia vue-routerhls.js fallback

Android

Kotlin 2.0Jetpack Compose Media3 / ExoPlayerRetrofitDataStore

Streaming & Delivery

Range / 206 passthrough proxyJellyfin HLS 302 Multi-arch DockerWails desktop shell
Documentation

Going deeper? The docs live in the repo

From naming conventions to the API contract — everything self-hosting and secondary development needs.

Deployment Guide

Compose, environment variables, multi-arch builds & publishing, reverse proxy, backup & upgrade, FAQ

File Naming Conventions

Directory layout, episode naming, covers / summaries / subtitles, web-friendly encoding parameters

WebDAV Integration

URLs and credentials for Alist / Synology / QNAP / OMV, plus troubleshooting

Jellyfin Integration

Getting an API Key, user isolation, HLS transcoding notes, troubleshooting

Android Builds

Android Studio / command-line builds, signing, common issues

API Contract

Every endpoint and field — the reference for writing your own client

Now open your own
"short-drama platform" on a NAS

Go to GitHub ↗ Back to Quick Start