yutto is a production-grade CLI application for downloading videos, subtitles, danmaku (bullet comments), and metadata from Bilibili. In production it resolves user-supplied URLs (UGC videos, bangumi anime, paid cheese courses, favourites, collections, watch-later lists) against Bilibili's private JSON APIs, normalizes responses into typed Pydantic download requests, and runs a planner/executor pipeline: immutable DownloadPlan construction (output paths, codec/quality selection), concurrent range-based downloading, FFmpeg muxing, and writing of NFO/SRT/ASS artifacts. It also ships an experimental WebSocket JSON-RPC server mode (`yutto serve`) for remote task submission, querying, cancellation, and live event streaming with token authentication.
Bilibili-Evolved is a powerful userscript (Tampermonkey/Greasemonkey) that enhances the Bilibili video platform with a modular component and plugin system. It injects into Bilibili pages and provides a wide range of features including video player enhancements (speed control, screenshot, remember progress), danmaku management (merging, downloading, conversion), UI customization (dark mode, custom navbar, home page redesign), feed filtering, live streaming tools, and video downloading with multiple output formats. The architecture is based on a core framework in `src/` that handles settings, DOM observation, style injection, toast notifications, and lifecycle management, while individual features are defined as components in `registry/lib/components/` using a metadata-driven pattern (`defineComponentMetadata`). Features can be installed, updated, and configured through a built-in settings panel. The project relies heavily on Bilibili's internal APIs and DOM structure, making it tightly coupled to the platform but also highly functional for power users. It uses Vue 2 for UI, TypeScript for type safety, and SCSS for styling, with a custom build pipeline using Webpack and pnpm.
AngelLive is a cross-platform (iOS, macOS, tvOS) live streaming viewer that aggregates content from multiple Chinese streaming platforms (Bilibili, etc.) via a dynamic plugin system. The application is built entirely in Swift, using SwiftUI for the UI layer with UIKit bridging where needed. Its core architecture revolves around a shared library, AngelLiveCore, which provides a plugin runtime for loading JavaScript-based platform adapters, a custom danmaku (bullet-chat) rendering engine, unified playback recovery with a state machine, and iCloud-based favorite and credential synchronization. The macOS and tvOS targets share the same core but have platform-specific UI components and input handling (e.g., tvOS focus-driven navigation, macOS menu bar and window management). The system is characterized by a high degree of modularity and concurrency: plugins are isolated sandboxed JavaScript runtimes, the danmaku engine uses asynchronous layer rendering and a dedicated shoot scheduler to handle burst traffic, and the playback recovery coordinator implements a tunable ladder of fallback actions (reload, switch CDN, refresh play args) to handle stream stalls. The favorite syncing engine uses `CKSyncEngine` with actor-based concurrency and circuit breakers to avoid retry storms. The codebase also includes a comprehensive test suite covering plugin operation, playback recovery, danmaku connection reconnection, and favorite refresh policies. Key entry points for the iOS app are `AngelLiveApp.swift` and `ContentView.swift`, which manage navigation and deep link handling. The macOS app uses `TabView` with sidebar navigation, and the tvOS app uses a SwiftUI-based sidebar and focusable grid. The developer console (`PluginConsoleView`) provides real-time logging and filtering of plugin calls, which is useful for debugging and extending the platform support. The app supports DLNA casting via SSDP discovery and a local HTTP proxy, and it integrates with AirPlay and Picture-in-Picture. Overall, AngelLive is a well-engineered, production-quality application with a clear separation of concerns, strong test coverage, and a plugin architecture that allows it to adapt to new platforms without modifying the core app. Its design patterns—such as the actor-based credential manager, the state machine for playback recovery, and the modular danmaku engine—are candidates for extraction into other projects.
Kazumi is a cross-platform Flutter application for browsing, collecting, and streaming anime (番剧). At its core, it provides a curated media experience: users can discover anime via popularity rankings, weekly schedules, text and image (trace.moe) search; manage a local watchlist synced with Bangumi (bgm.tv) and WebDAV; and play videos using a hardware-accelerated media_kit (libmpv) player with danmaku overlay, Anime4K super-resolution shaders, Picture-in-Picture, and external player support. It also downloads episodes (HLS segments) for offline playback and supports synchronized group viewing via the Syncplay protocol. The application is built as a Flutter monolith with modular routing (flutter_modular), reactive state management (MobX), local storage (Hive), and a custom plugin system that defines scraping rules (XPath/API) to extract video sources from third-party websites. External dependencies include Bangumi, DanDanPlay, trace.moe, WebDAV servers, and a GitHub-hosted plugin catalog. The codebase demonstrates mature engineering practices including well-isolated async utilities, event-sourced history sync with conflict resolution, and platform-specific WebView integrations for video source extraction and captcha handling.
This repository is an Android TV application (影視TV) that provides a comprehensive media center experience for streaming Video-on-Demand (VOD) and live television. It features a plugin-based content aggregation system using spiders written in Java, Python (via Chaquopy), and JavaScript (via QuickJS), allowing users to browse and play content from multiple external sources. The application supports multiple player engines (ExoPlayer and mpv), hardware/software decoding, subtitle and danmaku (bullet comment) overlays, DLNA casting (both sender and renderer), and a local HTTP server for remote control and file sharing. Architecturally, the project is a multi-module Gradle build with a shared core library (catvod) providing network utilities, cryptography, and data models. The main app module contains two UI tracks: 'leanback' for TV remote control navigation and 'mobile' for touch-based phone interaction, both sharing common logic under app/src/main. The system uses an event-driven architecture with EventBus, a Room-based SQLite database for persistence, and a ViewModel pattern for reactive UI updates. External content sources are integrated through a standardized Spider interface, with loaders for JAR, Python, and JavaScript plugins. Key features include a sophisticated playback controller with fallback policies, preloading, and history management; extensive audio/video effect pipelines (equalizer, loudness normalization, color adjustment); danmaku search and display; EPG (Electronic Program Guide) with timezone-aware parsing; and a comprehensive settings system covering player, decoding, subtitles, and network configuration. The project also includes a documentation website built with Next.js, providing developer guides for the spider API and local HTTP API.
This is a TypeScript-based danmaku (bullet screen/comment overlay) library for the web. It provides a manager-based architecture to push, render, and animate danmaku over video or any DOM container. The library offers two types of danmaku: facile (scrolling) and flexible (custom-positioned), with collision detection modes (none, strict, adaptive) and a track system for lane management. Rendering is done via CSS transitions, enabling rich customization and integration with any UI framework (the demo uses React). The library has a comprehensive plugin system via hooks-plugin, allowing developers to hook into lifecycle events at both manager and danmaku level. It is well-structured, with clean separation of concerns (Manager, Engine, Container, Track, Danmaku classes), and includes utility functions for expression-based size calculations. The demo application is a full-featured control panel for testing all configurable options. The repository also includes extensive documentation (VitePress) with both English and Chinese locales.
This repository is a collection of demos and examples for integrating the Aliyun ApsaraVideo Player (Aliplayer) into web applications. It showcases various features including VOD playback, live streaming, ads, interactive components (danmaku, comments, likes, playlists), and platform-specific implementations (WeChat mini-program, responsive design). The demos are built using different technologies: plain JavaScript/jQuery, Vue.js, React, and WeChat mini-program. The repository includes a custom component system that allows extending the player with reusable UI elements. While the demos are functional and demonstrate practical integration patterns, the codebase exhibits some technical drift due to outdated dependencies (e.g., zepto, webpack 4.0) and code duplication across demos. The custom components, however, are well-crafted and follow a consistent pattern for encapsulation and registration, making them reusable in other projects.
JKVideo is a cross-platform (Android/iOS/Web) Expo React Native application that acts as an unofficial Bilibili client. It browses Bilibili recommendation feeds, searches videos, plays DASH video via a locally generated MPD consumed by react-native-video/ExoPlayer, streams live rooms over HLS, displays video and live danmaku, loads comments, supports QR-code login, downloads videos, and shares them over a LAN HTTP server. The code is organized into expo-router screens, React hooks, Zustand stores, a single API service module, and utility modules; it uses signed WBI requests and maintains Bilibili cookies/CSRF state. The implementation quality is above average for a community project: the service layer includes request deduplication and network-only retries; the video player uses Animated-driven seek bars with video-shot preview thumbnails and quality fallback chains; DASH MPD generation handles Dolby Vision and segment ranges; the download hook pauses on background and resumes on foreground. However, there are no automated tests, some dead/default code remains (App.tsx is not the real entry), a hardcoded Sentry DSN and an exposed EAS Sentry auth token are present, and the LAN-share QR code relies on an external QR API. Live 'real-time' danmaku is actually 1.5-second REST polling of Bilibili's history endpoint, despite README claims of WebSocket. The repository is explicitly deprecated: the Chinese README states Bilibili sent a legal letter and maintenance/Issues/PRs have ceased, even though the last commit is recent. This code is useful as a reference for Bilibili API integration, DASH MPD construction, danmaku rendering, and React Native video-player architecture, but it should not be selected for new production use.