Bernini is a latent semantic planning framework for video and image generation and editing, developed by ByteDance. It unifies tasks such as text-to-image (t2i), image-to-image (i2i), text-to-video (t2v), video-to-video (v2v), reference-driven video generation (r2v/rv2v), and ad insertion (ads2v) under a two-tier architecture. The full Bernini pipeline uses a Qwen2.5-VL multi-modal large language model as a 'semantic planner' to produce latent feature plans, which are then decoded by a connector and a MaskGIT-style iterative VIT decoder into conditions for a dual-expert Wan2.2 diffusion renderer. A lighter variant, Bernini-R, omits the planner and fine-tunes the renderer directly with a T5 encoder. Inference is supported via single-GPU and multi-GPU scripts (with Ulysses sequence parallelism), a Gradio demo, and JSON-driven case files that define task configuration, prompts, and source media. Training of the renderer uses the VeOmni distributed framework with FSDP2 and Ulysses SP, and leverages pre-extracted VAE latents and VIT embeddings stored in Parquet format. The codebase is published under Apache 2.0 with pretrained models on Hugging Face, accompanied by a paper and benchmark results on EditVerse, OpenVE, OpenS2V, VBench, and a custom arena.
mpc-qt is a cross-platform desktop media player that reimplements the classic Media Player Classic β Home Cinema (MPC-HC) interface on top of the mpv playback engine and Qt6 widget toolkit. The application provides a full-featured playback experience with support for virtually all video/audio formats, DVD/Blu-ray discs, network streams, and playlists. It exposes extensive configuration options covering video scaling algorithms, hardware acceleration backends, HDR tone mapping, audio filters, subtitle styling, and user interface themes. The architecture follows a modular Qt widget design: a central MainWindow coordinates playback via a PlaybackManager, which communicates with an mpv wrapper (MpvObject/MpvController) running in a separate thread to keep the UI responsive. Playlist management is handled by dedicated widget classes with drag-drop, tabs, and queue support. The application also includes multiple IPC mechanisms (JSON socket, HTTP server, MPRIS D-Bus) for remote control, a web interface, and a thumbnail generation tool. Platform-specific concerns such as screensaver inhibition and removable device detection are abstracted behind clean interfaces with separate Unix and Windows implementations. The codebase is substantial and well-structured but shows signs of organic growth, including some large classes (MainWindow, SettingsWindow) and occasional use of macros for convenience.
This repository is a KOReader plugin called 'Project: Title' that replaces the default file browser and history with alternative display modes: cover grid, cover list, details list, and filename list. It extracts book metadata and cover images, caches them in a SQLite database (with zstd compression), and displays progress bars, series information, tags, and custom book status screens. The plugin monkey-patches core KOReader widgets (FileChooser, FileManager, Menu, BookStatusWidget) to inject its own UI components. It also provides background metadata extraction, folder cover generation, and a user-patch extension mechanism. The code is written in Lua and is tightly integrated with KOReader's internal APIs, making it non-portable outside that ecosystem. However, several internal modules (gettext proxy, performance debugger, user-patch template) demonstrate reusable patterns for other KOReader plugins.
This is an Android TV screensaver application that plays a curated collection of aerial videos and photos from multiple sources: Apple TV-style community feeds, Amazon Fire TV, Comm1/Comm2, local storage, Samba shares, WebDAV, Immich, Nextcloud Memories, and custom JSON/CSV feeds. The app uses ExoPlayer for video playback with 4K/HDR support, Coil for images, and a rich overlay system (clock, date, weather, metadata, now-playing music, messages, countdown). It integrates with Projectivy launcher as a wallpaper provider and exposes an embedded Ktor HTTP API (port 8081) for external message injection (e.g., Home Assistant). The codebase is well-structured with clear separation of concerns: media providers follow an abstract `MediaProvider` pattern, overlays are managed via a reactive `OverlayStateStore`, and playlist caching uses Room with a sliding-window algorithm. The app targets Android TV (API 23+) with multiple build flavors (Google Play, Amazon, F-Droid, GitHub).
PayKit is an embedded Stripe billing framework for TypeScript applications. It runs inside your app, uses your database, and provides a typed API for managing products, subscriptions, entitlements, metered usage, invoices, and webhooks. The core library (`packages/paykit`) is a framework that integrates with Stripe as the sole payment provider, handling the full subscription lifecycle including upgrades, downgrades, cancellations, resumptions, and scheduled changes. It also includes a CLI for project initialization, database migration management, product synchronization, and a webhook tunnel for local development. The repository is a monorepo managed with pnpm workspaces and Turborepo. It contains the core library (`paykitjs`), an optional dashboard plugin (`@paykitjs/dash`), a demo application (`apps/demo`) showcasing PayKit alongside an alternative billing provider (Autumn), a documentation website (`apps/web`) built with Fumadocs and Next.js, a webhook tunnel service (`apps/wh`) running on Cloudflare Workers, and a comprehensive end-to-end test suite (`e2e/`). The architecture follows a service-oriented pattern within the core library, with separate modules for customers, subscriptions, entitlements, products, invoices, payment methods, and webhooks, all coordinated through a central context object. The codebase demonstrates strong engineering practices: thorough unit and integration testing, CI/CD pipelines with GitHub Actions, strict TypeScript configuration, automated code formatting and linting, and a changeset-based release workflow. The core library exposes a plugin system for extending its router and a pattern for defining typed API endpoints with Zod validation. While the library is in early alpha (0.2.0), it already supports production-grade billing flows and includes detailed documentation covering installation, configuration, and common integration patterns.
Geto is an Android application that allows users to apply specific device settings (like disabling Developer Options or USB debugging) when launching particular apps, and automatically revert those settings when exiting the app. The app follows a clean architecture with separate modules for presentation, domain, and data layers. It uses Jetpack Compose for UI, Hilt for dependency injection, and Kotlin Coroutines for asynchronous operations. Key features include creating app shortcuts that trigger settings changes, a foreground service to monitor system setting changes, and secure storage of app-specific configurations using Room database and DataStore. The application requires the WRITE_SECURE_SETTINGS permission to modify system settings, which must be granted via ADB or Shizuku.
This repository contains a Zotero plugin for formatting item metadata, specifically designed to ensure the existence, correctness, and accuracy of all items and fields in a Zotero library. The plugin includes a rule system with core abstractions expressed as rules, and uses large reference datasets bundled as assets. It is built on the zotero-plugin-template and zotero-plugin-scaffold toolchain and is designed to work with Zotero 8 & 9.
This repository is a comprehensive database of binary file format patterns, YARA rules, encoding tables, themes, and utility scripts for the ImHex hex editor. It contains over 300 ImHex pattern definitions (`.hexpat`) covering a vast range of file formats including executables, archives, multimedia, game assets, filesystems, and firmware. The patterns are written in ImHex's custom pattern language and are organized with a reusable standard library (`includes/std/`, `includes/type/`) and ImHex-specific helpers (`includes/hex/`). The repository also includes a large collection of YARA rules from the official YARA-Rules community, covering malware families, APT groups, exploit kits, and CVEs. Additional assets include encoding tables (`.tbl`), magic files for libmagic, disassembler definitions, themes, and data processor nodes. The project is primarily a data/research resource for reverse engineers, malware analysts, and digital forensics practitioners, but it also includes application-like elements such as Python scripts for format conversion and encoding generation, as well as a CMake-based test suite for validating patterns and includes. The repository is actively maintained with community contributions and CI testing.
TDesign Vue Next Starter is a production-oriented Vue 3 admin dashboard starter from Tencent's TDesign team, built with Vite 8, Pinia 3, TypeScript, and the tdesign-vue-next component library. It is a single-page frontend application demonstrating a complete mid-office (δΈεε°) admin system: login/register flows, ECharts-powered overview and detail dashboards, CRUD list pages (base/card/filter/tree), multi-step forms, detail pages, result/error pages, and a user profile page. Its purpose is to be scaffolded via tdesign-starter-cli and adapted to real business logic; all backend interactions are mocked via vite-plugin-mock and mockjs. The architecture is conventional but well-layered. src/main.ts bootstraps Vue with TDesign, Pinia (with persisted-state), Vue Router, and vue-i18n. src/permission.ts installs a global route guard that validates a token, fetches user info, and calls permissionStore.buildAsyncRoutes(), which loads a backend menu list (mocked at /get-menu-list-i18n) and transforms it into route records with lazy-loaded page components. Layouts support side/top/mix navigation with a rich settings drawer: light/dark/auto modes, arbitrary brand-color theming (tvision-color generates a 10-step scale injected as CSS custom properties), breadcrumbs, multi-tab keep-alive navigation, and notifications. i18n is comprehensive (zh_CN/en_US, JSON-driven, persisted to localStorage, including TDesign component locales). The most genuinely reusable artifacts are in the infrastructure layer. src/utils/request/Axios.ts is a non-trivial axios wrapper implementing duplicate-request cancellation, automatic retry with backoff, interface-level throttle/debounce via a pending-resolvers queue, and a transform-hooks pipeline. src/utils/color.ts cleanly encapsulates dynamic theme generation. src/store/modules/tabs-router.ts implements multi-tab navigation with subtle keep-alive eligibility logic. The main weaknesses: the test script is a no-op stub (zero unit tests), all data is mock-only, and demo pages contain console.log leftovers and occasional `as any` casts. As a starter kit it delivers exactly what it claims; as a reference for Vue 3 + TDesign architecture it is solid, though the CRUD page demos are boilerplate.
This repository implements `cuda_tile`, an MLIR-based compiler dialect and toolchain for GPU tile programming, primarily targeting NVIDIA CUDA architectures. It defines a rich set of operations for tile-level computation (arithmetic, matrix multiply, memory views, atomics, control flow) with explicit memory ordering and synchronization. The project includes a custom bytecode serialization format (.tileirbc) with versioned backward compatibility, allowing efficient IR transport and JIT compilation. Key tools are `cuda-tile-opt` (dialect testing), `cuda-tile-translate` (MLIR-to-bytecode conversion), `cuda-tile-optimize` (bytecode-to-bytecode optimization passes), and `cuda-tile-tblgen` (TableGen-based code generation for bytecode readers/writers). Python bindings enable programmatic IR construction. The architecture is a set of modular libraries (dialect, bytecode, optimizer, C API) that can be integrated into larger compiler pipelines. External dependencies are LLVM/MLIR at a pinned commit and CUDA. The codebase demonstrates high engineering rigor with extensive test coverage (bytecode stability, version compatibility, round-trip, transformation passes) and careful version management for evolving the IR format. While primarily a compiler infrastructure application, the project's focus on low-precision matrix operations (FP8, FP4) and tensor core optimizations touches on ML research areas.
GTKWave is a GTK-based waveform viewer for digital simulation trace files (VCD, FST, GHW). It loads trace data, displays hierarchical signal lists, renders time-value waveforms using Cairo, supports zoom/pan/markers, and provides conversion tools between formats. It also includes a remote control protocol (WCP) and scripting via Tcl. The architecture is a monolithic GTK application with a core library (libgtkwave) providing a GObject-based data model and loaders. The GUI is built with GTK3/4 widgets and custom Cairo drawing. Separate helper executables handle format conversion and mining. The build system is Meson. Key entry points include src/main.c (main), src/dump_file_main.c (file loading), src/signalwindow.c (signal list display), src/wavewindow.c (waveform display), and the loader implementations in lib/libgtkwave/src/. Primary data flows: user opens a dump file, the loader parses it, builds a hierarchy tree (GwTree), creates signal facs (GwFacs), reads time-value changes into compressed vlists (GwVlist), then the GUI displays the tree and renders traces on demand. External dependencies include GTK3/4, GLib, Cairo, Pango, libpeas (optional), json-glib (for WCP), gzip/bzip2/lzma (for compression), and gperf (for keyword generation).
Cog is a free, open-source audio player for macOS and iOS with a focus on playing video game music and obscure audio formats. The application is built around a plugin-based decoder architecture that supports hundreds of formats through embedded libraries (vgmstream, GME, OpenMPT, Dumb, lazyusf, etc.) and standard codecs (FLAC, MP3, AAC, Opus, Vorbis). The core audio engine provides a DSP pipeline with equalizer, surround sound, time-stretching, ReplayGain, and visualization. The macOS frontend uses SwiftUI and Cocoa for playlist management, file browsing, lyrics display, and remote control via an MCP server. The iOS version shares the same audio engine with a touch-optimized interface. The repository is a hybrid of a polished consumer application and a deep research archive of reverse-engineered game audio formats and emulator cores.
This repository is a comprehensive operational playbook for 'Ralph', Geoff Huntley's methodology for running Claude Code in an autonomous loop to build software. The core deliverable is a detailed guide (README.md plus a styled index.html mirror) explaining the three-phase workflow: define requirements as JTBD-aligned specs, generate an implementation plan via a planning loop, then run a building loop where Claude picks tasks from the plan, implements them, validates against tests, and commits β with a fresh context window per iteration. The guide is unusually well-structured, covering context management, backpressure via tests, sandbox security, and tuning strategies. Beyond documentation, the repo ships functional artifacts: two bash loop scripts (files/loop.sh, files/loop_streamed.sh) that orchestrate the Claude CLI, a dependency-free Node.js stream parser (files/parse_stream.js) for readable terminal output, and five prompt templates (PROMPT_build.md, PROMPT_plan.md, PROMPT_specs.md, PROMPT_reverse_engineer_specs.md) encoding the methodology's guardrails. It also documents sandbox environment options (E2B, Fly Sprites, Modal, Cloudflare, Docker) for safely running autonomous agents with --dangerously-skip-permissions. The prompt templates are the real product β they encode hard-won operational knowledge about context efficiency, subagent fan-out, and steering LLM behavior. Notable patterns include escalating 9s-numbered guardrails, explicit subagent limits (500 for search, 1 for build/tests), the 'one sentence without and' topic scoping test, and a two-phase reverse-engineering prompt that produces implementation-free behavioral specs. This is a documentation-first repo with a small but functional code footprint.
nix-topology is a NixOS module and toolchain that automatically generates infrastructure and network topology diagrams (SVG) from NixOS configurations. It defines a global module system to declare nodes, networks, interfaces, and services. A NixOS module automatically extracts information from systemd-networkd, known services, microvms, nixos-containers, and DHCP servers (kea). The architecture decouples information gathering from rendering: two renderers (ELK for layout, SVG for per-node cards) produce both a physical-connection diagram and a network-centric view. The project demonstrates advanced Nix module system usage (merge, lazy evaluation, option types) and provides standalone Node.js tools (elk-to-svg, html-to-svg) for converting ELK JSON and Satori HTML to SVG. It supports user-defined nodes, connections, networks, and icons, with automatic network propagation through connections.
gh-poi is a GitHub CLI extension (written in Go) that safely removes local git branches whose associated pull requests have been merged or closed. It solves a real pain point: squash-merged PRs leave no merge commit in the default branch, so tools like `git branch --delete-merged` cannot identify them as safe to delete. The tool reconstructs the branch-to-PR association by querying GitHub's GraphQL API with commit hashes, then applies a layered safety model (locks, worktrees, uncommitted changes, untracked files, detached HEAD, default-branch protection) before deleting anything. It supports `--dry-run`, `--state merged|closed`, `--scan quick|deep`, and `lock`/`unlock` subcommands that persist locks in git config as `branch.<name>.gh-poi-locked`.
Hercules is a GPL-licensed, open-source MMORPG server emulator specifically for Ragnarok Online. It provides a multi-process server architecture consisting of login, character, map, and HTTP API servers, all written in C (migrating to C++20). The codebase is large (4,000+ files) and implements the full game logic including combat, skills, item systems, quests, instances, guild wars, parties, mail (RoDEX), auction houses, vending, and a plugin system (HPM) for extensibility. The project maintains compatibility with multiple official client versions through conditional packet definitions, and uses MySQL/MariaDB for persistent storage with a robust SQL migration system. The architecture follows an interface pattern, where each major subsystem exposes a struct of function pointers, enabling loose coupling and plugin hooks. The repository includes extensive configuration files (libconfig), game databases (monsters, items, skills, etc.), and utility libraries for networking, memory management, and string processing.
Chamilo LMS is a PHP-based Learning Management System built with Symfony framework and Vue.js frontend. It provides course management, assessments, gradebook, attendance tracking, and collaboration tools through a modular plugin architecture. The system features RESTful API endpoints consumed by Vue services, Doctrine ORM for data persistence, and supports over 60 languages. While actively modernizing with Vue.js 3 and Symfony 6, it maintains legacy PHP components alongside new implementations, creating some technical debt from gradual migration. The plugin system follows a standardized structure enabling extensibility, and the codebase demonstrates solid engineering practices with clear separation of concerns between CoreBundle, CourseBundle, and PluginBundle.
This repository is the Intel XeSS SDK, a comprehensive set of libraries and APIs for integrating AI-powered super resolution (XeSS-SR), frame generation (XeSS-FG), and low-latency optimization (XeLL) into games and applications. It provides C-callable functions for DirectX 11, DirectX 12, and Vulkan, along with sample applications demonstrating each technology. The SDK is distributed as precompiled DLLs, header files, and documentation. The samples render a simple animated triangle and show the complete integration flow: context creation, initialization, per-frame execution, and resource management. The codebase is well-structured with consistent error handling, versioning, and logging patterns across all three technology areas.
This repository is a comprehensive, community-authored tutorial for video encoding and VapourSynth preprocessing, maintained by VCB-Studio. It is primarily documentation with executable example scripts (.vpy), covering everything from video format fundamentals to advanced mask generation and expression-based pixel manipulation. The 'Basics' section builds foundational knowledge (e.g., video properties, common artifacts, encoding tools), while the 'Advanced' section dives into VapourSynth internals like the Expr filter and mask creation. Although not a standalone application, the scripts are production-oriented and carefully crafted to illustrate best practices in Blu-ray ripping and quality enhancement. The repository is actively maintained with a responsive issue tracker, and its content reflects current industry techniques.
Yamagi Quake II is a maintained source port of id Software's Quake II, focusing on offline and cooperative gameplay. It is a full game application with a client-server architecture, featuring dedicated server (q2ded), multiple rendering backends (OpenGL 1.x, OpenGL 3.x/GLES, and software renderer), sound backends (SDL, OpenAL), and HTTP download support. The game logic is compiled as a separate shared library (game.so/.dll) with a plugin-like interface. The codebase is written in C and retains many original Quake II patterns (global state, custom memory allocators, fixed-size arrays), but has been modernized with SDL3, gyro input support, and improved network code. It supports cross-platform builds on FreeBSD, Linux, Windows, and macOS.