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.
ReNative (rnv) is a cross-platform development CLI tool and framework that enables building applications for mobile (iOS, Android), web, TV (Tizen, webOS, Fire TV, Android TV, tvOS), desktop (macOS, Windows, Linux, Electron), wearables, and consoles from a single codebase. The system uses a monorepo architecture with modular packages: a core library (`@rnv/core`) providing configuration merging, plugin management, template injection, and task orchestration; platform-specific engines (`@rnv/engine-rn`, `@rnv/engine-rn-electron`, `@rnv/engine-rn-next`, etc.) that define build logic and native project templates; SDK packages (`@rnv/sdk-android`, `@rnv/sdk-apple`, `@rnv/sdk-tizen`, etc.) for platform-specific tooling like device management and code generation; and a CLI entry point (`rnv`) that dispatches commands to registered tasks. The primary data flow involves reading hierarchical configuration files (`renative.json`, `appConfigs/`), merging them with plugin definitions and engine defaults, injecting placeholders into platform templates (e.g., AndroidManifest.xml, Xcode project files, Webpack configs), and then invoking native build tools (Gradle, Xcode, Webpack, etc.) to produce deployable artifacts. External dependencies include React Native, Electron, Next.js, Webpack, and platform SDKs (Android SDK, Xcode, Tizen SDK, webOS SDK). The framework also includes a telemetry module, Docker integration, and a build hooks system for custom pre/post-publish scripts.
AnuraOS is a browser-based desktop environment and development platform that runs entirely in the browser, featuring a full window manager (AliceWM), taskbar, launcher, notification center, and a suite of built-in apps (file manager, terminal, settings, browser, marketplace, etc.). It includes a complete x86 emulation subsystem via v86, allowing users to boot a custom Alpine Linux virtual machine with persistent disk storage, PTY multiplexing, and network relay through the Wisp protocol. The system is designed as a Progressive Web App (PWA) with offline support via service workers and uses IndexedDB for filesystem and settings persistence. The architecture is modular: core APIs (filesystem, networking, window management, settings, processes, notifications) are exposed through a global `anura` object. Apps are defined by manifests and can be either iframe-based or manual scripts, with support for versioned libraries imported via `anura.import()`. The filesystem uses an abstract provider pattern (`AFSProvider`) with multiple backends (Filer, LocalFS/OPFS). The x86 subsystem manages a v86 emulator with persistent disk images stored in IndexedDB, and integrates with the host OS through a custom mouse driver and network relay. While the codebase demonstrates strong engineering with clean abstractions (e.g., filesystem providers, window manager, notification service), it also exhibits some technical debt: large monolithic files (v86.tsx, Boot.tsx), use of `eval` in legacy handlers, memory leaks in the x86 disk cache, and race conditions in boot sequencing. The x86 image build process requires Linux, Docker, and specific toolchains, limiting portability. Overall, AnuraOS is a sophisticated and functional webOS with reusable components, but its complexity and some outdated patterns suggest moderate maintenance overhead.