Litefin is a high-performance, native Jellyfin media client designed specifically for Samsung Tizen and LG webOS smart TVs. It is built as a single-page web application using vanilla JavaScript with a custom component framework, no external UI libraries. The architecture is event-driven, centered around a global EventBus, StateManager, and Router. The application provides full media browsing, playback with advanced subtitle rendering (ASS/SSA via libass-wasm), live TV with EPG, SyncPlay group synchronization, a plugin system, and integration with Jellyseerr for media requests. It is optimized for TV remote control navigation with a sophisticated FocusManager and spatial navigation engine. The system communicates with a Jellyfin server via REST API and WebSocket for real-time events. It also integrates with TMDB (via Jellyseerr) for metadata and trailers, and uses a background service (Luna on WebOS, HTTP proxy on Tizen) for device discovery, Wake-on-LAN, and Smart Hub preview. The codebase is organized into core modules (App, Router, EventBus, StateManager), UI components (pages, modals, grids), a player subsystem with OSD menus, and platform adapters for Tizen and WebOS. It supports multiple build variants (Modern, Normal, Legacy, Ultra-Legacy) to accommodate different Chromium versions on TV firmware. Key entry points include src/index.js (bootstrap), src/core/App.js (orchestration), and src/core/Router.js (navigation). Data flows primarily through the ApiClient for Jellyfin endpoints and the WebSocketHandler for server push events. The plugin system allows third-party extensions like skip-intro and mdblist-ratings. The application is heavily optimized for TV hardware, using GPU-accelerated CSS transforms, lazy loading, and memory-efficient virtual scrolling.
DUNE is a specialized Android TV client application for the Jellyfin media server ecosystem. It functions as a media consumption interface optimized for remote control navigation, featuring video/audio playback, library browsing, live TV (DVR) management, and extensive user customization. The architecture is a monolithic Android application with modularized internal structure (app, playback, preference modules), utilizing a hybrid UI approach that combines Jetpack Compose for modern screens (preferences, overlays) with Android Leanback widgets for traditional TV browsing. The codebase demonstrates strong separation of concerns, particularly in the playback layer which abstracts media rendering logic from the UI. It relies heavily on the Jellyfin SDK for API communication and ExoPlayer (Media3) for media rendering.
This is an Android TV application that serves as a client for media servers (primarily Jellyfin). It implements a Clean Architecture with clear separation between Data, Domain, and Presentation layers, using Jetpack Compose for the UI, Hilt for dependency injection, and Kotlin Coroutines/Flow for asynchronous operations. The application provides a TV-optimized interface for browsing media libraries, playing content with support for multiple players (ExoPlayer and MPV), handling subtitles/audio tracks/video quality, and managing user preferences. Key features include offline caching, background synchronization, advanced video format support (HDR, Dolby Vision), and a polished user experience with animations and focus handling for TV remotes.
ElegantFin is a comprehensive CSS theme for the Jellyfin media server, providing a modern, dark UI overhaul inspired by Jellyseerr. It is delivered as a single CSS import and relies entirely on CSS custom properties (design tokens) for customization, allowing users to adjust colors, layout, and visibility toggles. The theme is built with PostCSS and includes optional add-on stylesheets for custom media covers and third-party plugin support. The codebase consists of versioned, monolithic CSS files that override Jellyfin's default styling across desktop, mobile, and TV layouts. It is not an application backend or data pipeline; it is a pure client-side presentation layer. The theme demonstrates strong CSS craftsmanship through extensive use of modern selectors (`:has()`, `@container`, `@supports`), responsive card grids, and design token abstraction, though it suffers from duplication across versions and reliance on external CDN resources.