This repository is the official documentation website for the BNB Chain ecosystem, built with MkDocs and deployed to GitHub Pages. It serves as a comprehensive knowledge base covering multiple blockchains (BNB Smart Chain, opBNB, BNB Greenfield, New L1), developer toolkits (BNB Agent SDK, BNB Agent Studio, MPP SDK), and migration programs (BC Fusion). The site includes custom JavaScript for an AI chatbot (SuperIntern) and dynamic footer menus, as well as custom CSS for branding. While primarily a static documentation site, it incorporates interactive elements and external API integrations. The content is well-organized with extensive cross-references, but the codebase is not a software application in the traditional sense; it is a content-driven site with some client-side scripting.
This repository is a curated list (awesome list) of ESLint-related resources, including shareable configs, plugins, parsers, formatters, tools, and tutorials. It serves as a community-maintained index for developers seeking to extend or configure ESLint for various use cases, such as code quality, compatibility, frameworks, security, and style. The primary content is a single README.md file organized into categories, with links to external projects and brief descriptions. The project is not a software application or data pipeline; it is a documentation-focused repository that follows the awesome list convention. It includes a minimal package.json with a test script using awesome-lint to validate the list's formatting and a GitHub Actions CI workflow that runs on pull requests and pushes. The contributing.md outlines guidelines for adding new entries. Despite its simplicity, the repo is actively maintained, with a large number of stars (4766) and forks (270), indicating its value as a reference. It does not contain reusable code components beyond the list itself, but the curation and organization demonstrate good practices for maintaining a community resource.
This repository is the official project website for the Rime input method engine (δΈε·ι»θΌΈε ₯ζ³εΌζ). It is a static site built with the Zola static site generator, deployed to GitHub Pages via a GitHub Actions workflow. The site provides download links for Rime clients (Weasel for Windows, Squirrel for macOS, ibus-rime for Linux), documentation, a blog, donation information, and an online input method demo using fcitx5-rime.js. It also includes a Python script that automatically fetches the latest release assets from GitHub and updates Sparkle appcast XML files for the Weasel and Squirrel clients, enabling automatic updates. The site features dynamic notices (e.g., commemorative messages, typewriter animations) and Chinese text conversion between simplified and traditional characters. While primarily a content site, it contains well-structured CI/CD pipelines and a reusable release management script.
FluidCalendar is a full-stack Next.js 15 calendar and task-management application intended as an open-source alternative to Motion. In production, it lets users manage tasks and calendar events in a local PostgreSQL-backed store, connect external calendars via Google, Outlook, and CalDAV, and synchronize tasks bidirectionally with Google Tasks, Outlook Tasks, and CalDAV VTODO providers. The application also includes an auto-scheduling engine that finds open time slots and scores them by deadline proximity, energy level, project grouping, and buffer constraints, plus dedicated focus mode, board/list task views, recurring event handling, and rich settings/admin screens. It is not a data-research repository, though its multi-provider synchronization layer has meaningful data-engineering depth.
DeepSeek-OCR is an inference repository for a multimodal OCR model that combines vision encoders (SAM and CLIP) with a large language model (DeepSeek-V2/V3) to perform optical character recognition with layout awareness, supporting native and dynamic resolution processing. The system provides two inference paths: a Hugging Face Transformers integration for simple usage and a custom vLLM integration for high-throughput batched inference, including PDF processing and evaluation benchmarks. The architecture is a monolithic model definition with separate modules for vision encoding (deepencoder), image preprocessing (process), and vLLM glue code, all tightly coupled to the specific model architecture. The codebase is functional and demonstrates competent engineering for research-grade inference, but lacks production hardening, documentation, and consistent coding standards.
Yaxim is an Android-based XMPP/Jabber instant messaging client. It maintains a persistent XMPP connection via a background service (XMPPService) using the Smack library, with UI components binding to the service for message exchange and roster management. The app features multiple product flavors (main, branded, F-Droid, Google Play variants) and supports core XMPP extensions including MAM, Carbons, and Message Archiving. Data persistence is handled through SQLite ContentProviders for chat history and roster management. The application demonstrates a clean separation of concerns between networking, data storage, and UI layers, though it shows signs of technical drift due to reliance on deprecated Android Support Libraries and outdated APIs like Android Beam.
This repository contains a cross-platform mobile application (iOS and Android) that functions as an AI assistant for Ray-Ban Meta smart glasses. The app connects to the glasses via the Meta Wearables DAT SDK to access camera and microphone streams, then provides various AI-powered features including real-time conversations (Live AI), image recognition (Quick Vision), food nutrition analysis (LeanEat), real-time translation, and experimental RTMP streaming. The architecture follows MVVM patterns on both platforms, with SwiftUI/Jetpack Compose for UI, ViewModels for state management, and service layers handling API communications with multiple AI providers (Alibaba Cloud, Google Gemini, OpenRouter). Key features include secure API key storage, Bluetooth audio routing for glasses microphones, and integration with external systems like OpenClaw. The application is actively maintained with recent commits and demonstrates solid engineering practices, though the multi-platform nature and reliance on external AI services introduce some complexity.
Bloopair is a Wii U homebrew project that patches the IOS operating system to enable unsupported Bluetooth controllers (DualShock 3/4, DualSense, Switch Pro, Xbox One). It consists of four major components: a kernel/IOS exploit loader (uses ROP chains to inject payloads), kernel and IOS module patches (modify the Bluetooth stack to recognize and handle foreign controllers), a userland C library (libbloopair) providing an IPC API to communicate with the patched IOS, and a companion GUI application (Koopair) for testing inputs, creating button/stick mappings, managing configurations, and pairing controllers. The system translates HID reports from non-official controllers into the Wii U Pro Controller format expected by the padscore driver. The codebase demonstrates deep reverse engineering of Bluetooth protocols and the Wii U's inner workings, but relies heavily on hardcoded memory addresses and exploits that are highly version-specific, leading to significant technical drift risk.
Agregarr is a full-stack Plex collection management application built with Next.js and Express, written in TypeScript. It automates the creation, synchronization, and visual customization of Plex collections by integrating with numerous external media sources and APIs including Trakt, TMDB, IMDb, Letterboxd, MDBList, AniList, MyAnimeList, Tautulli, Overseerr, Radarr, and Sonarr. The core architecture follows a monolithic pattern: a single server process running both the React frontend and Express backend, with SQLite persistence via TypeORM and a robust migration system. In production, Agregarr performs scheduled full syncs and incremental quick syncs of collection definitions to Plex, applies poster overlays based on configurable conditions (ratings, resolution, audio codecs, HDR formats), manages placeholder items for upcoming content, and can auto-request missing media through Radarr/Sonarr or Overseerr. The UI provides per-library collection views with drag-and-drop reordering, a visual poster editor with snap-to-guides and layering, an overlay editor with condition evaluation, and dashboard statistics from Tautulli. The codebase demonstrates solid engineering with clear separation of concerns, a template method pattern for collection sources (`BaseCollectionSync`), consistent API client wrappers, and modular UI form sections. However, it carries significant maintenance overhead from fragile web scraping (IMDb WAF, Cloudflare bypass), a large dependency surface including Chromium and Playwright, commented-out legacy code from its Overseerr fork, and reliance on external APIs that may change unexpectedly. The project is actively maintained with frequent migrations and feature additions.
ChatWiki is an open-source, multi-service AI chatbot and workflow automation platform primarily targeting the WeChat ecosystem. In production, it operates as a suite of Go microservices (chatwiki, message_service, code_run, websocket, plugin, llm_runner) behind a Gin web server, with a Vue 3 admin panel, separate mobile/PC/Electron frontends, and an embeddable SDK. The core functionality includes knowledge base management (document ingestion, chunking, vector storage with pgvector), a LogicFlow-based visual workflow builder, multi-channel messaging (WeChat Official Account, Mini Program, Feishu, DingTalk, Telegram, WhatsApp, LINE), and an AI agent framework called Clawbot with skill reuse. External dependencies include PostgreSQL (with pgvector and AGE graph extension), Redis, NSQ message queue, and optional Neo4j and E2B sandbox. While the system is primarily an application, it incorporates data-intensive components such as RAG pipelines, LLM request logging, and daily statistics, giving it a hybrid character.
OsEngine is a full-featured algorithmic trading terminal for the Windows desktop, written in C# with a WPF/WinForms hybrid UI. It provides a plugin-based exchange connectivity layer supporting over 40 crypto, stock, and derivatives exchanges (Binance, MOEX, Interactive Brokers, etc.) through a unified `IServerRealization` interface. The platform includes a live trading robot framework with over 300 built-in strategies, a backtesting engine (`TesterServer`), a walk-forward optimizer (`OptimizerMaster`), historical data management (`OsData`), and a technical indicator library with 100+ indicators. A Model Context Protocol (MCP) JSON-RPC API exposes terminal control to external AI agents, allowing them to create and manage robots, run tests, and configure exchanges via chat-based interfaces. The architecture is monolithic but modular, with separate executables for data, tester, optimizer, and live trading, all sharing the same codebase via project references.
Packetdrill is a command-line testing tool for network stack validation, primarily used to test TCP/IP implementation in the Linux kernel. It allows engineers to write deterministic scripts that describe system calls and packet events with microsecond precision, then executes these scripts against a live kernel or a simulated network device (TUN) to verify behavior matches expectations. The tool supports local testing via TUN devices and remote testing over physical NICs using a custom wire protocol. It is developed by Google and licensed under GPLv2. Architecturally, packetdrill is a single C executable built from about 50 source files. It uses flex and bison for script parsing, a state-machine runtime engine (run.c, run_packet.c, run_system_call.c) for event execution, and platform-specific network I/O modules (packet_socket_linux.c, netdev.c, wire_client/server.c). The test suite includes hundreds of script files covering TCP congestion control, fast open, ECN, zerocopy, timestamping, and many other protocol behaviors. The tool also supports optional PSP (Packet Security Protocol) encryption for testing secure tunnels. The codebase demonstrates solid engineering craftsmanship: clearly separated concerns, portable network header definitions that avoid kernel header dependencies, and a well-documented protocol DSL. It is primarily valuable as a reference for kernel networking development and as a reusable testing framework for anyone working on TCP/IP stack implementations. While some parts are tightly coupled (e.g., packet parser to internal packet types), several utility modules (checksum, IP address parsing, hash map, logging) are self-contained and easily reusable in other C projects. The main risk is technical drift due to evolving kernel APIs and custom header definitions that may become outdated.
This is a React admin dashboard template built with CoreUI, React 19, Vite, Redux, and Chart.js. It provides a comprehensive set of example pages demonstrating CoreUI components, form controls, charts, widgets, authentication flows, and icons. The codebase is well-structured with lazy-loaded routes, a simple Redux store for theme and sidebar state, and reusable layout components (AppSidebar, AppHeader, AppContent). It serves as a starting point for building admin panels rather than a production application. The template includes extensive documentation (ARCHITECTURE.md, DEVELOPMENT.md) and uses JSDoc comments. It is tightly coupled to the CoreUI ecosystem and contains no real backend integration or data fetching logic. The repository is primarily a showcase and scaffold for developers.
This repository provides a comprehensive, opinionated Docker Compose configuration for building a self-hosted NAS (Network Attached Storage) system on a vanilla Linux box. It orchestrates a suite of containerized services for media management (Sonarr, Radarr, Lidarr, Bazarr, Prowlarr, Jellyfin, Jellyseer), download automation (qBittorrent, SABnzbd, Unpackerr, Cross-Seed, Autobrr), and home utilities (Homepage, Traefik, AdGuard Home, Home Assistant, Immich, Vaultwarden, Paperless-ngx, Tandoor, Joplin). The architecture relies on Docker Compose profiles to enable optional services, Traefik as a reverse proxy with Let's Encrypt SSL, and a WireGuard VPN (via PIA) to isolate torrent traffic with port forwarding. The configuration is designed for hardlink support between the download client and media managers to avoid storage duplication.
PearPass Desktop is an Electron/React password manager with a local-first architecture: encrypted vaults are stored on-device and synchronized peer-to-peer through Pear Runtime, with no central cloud account. The renderer is a large React application handling vault/record CRUD (logins, credit cards, identities, notes, Wi-Fi, passphrases, custom fields), folders, favorites, TOTP authenticator codes, import/export from other password managers, and extensive settings. The Electron main process spawns a Bare-sidecar vault worklet, exposes a preload bridge, and coordinates secure native messaging with a browser extension. The repo also includes Flatpak/Snap/AppImage/MSIX packaging, an Appling installer, and a Playwright E2E suite. Security is taken seriously: there is an encrypted session handshake (X25519 ECDH, Ed25519 transcript signatures, secretbox, sequence numbers), a method registry separating public vs secure IPC methods, master-password verification, auto-lock, and platform-specific clipboard cleanup. The codebase has extensive Jest unit coverage and Playwright E2E coverage for every record type. However, much of the actual vault crypto and UI kit logic lives in internal @tetherto packages, making this repository primarily application glue around private dependencies. Maintainability is mixed. The README explicitly states development is paused, and there are signs of drift: mixed JS/TS, duplicated attachment/schema logic across many modal forms, a frozen legacy UI component tree, commented-out E2E tests, a likely bug in pairing-token hash construction, and feature stubs marked UNSUPPORTED. It remains a well-organized and functional password manager, but a significant refactor would be needed to fully modernize it.
SmallCode is an open-source AI coding assistant CLI designed to run locally on consumer hardware with small language models (8Bβ35B parameters). It provides a full-screen terminal UI with streaming output, tool execution, and multi-turn agent loops. The system compensates for small-model limitations through a context budget engine, forgiving JSON parser, patch-first editing, early-stop detection, and TODO-driven planning. It supports multiple LLM providers (Ollama, LM Studio, llama.cpp, OpenAI, Anthropic, DeepSeek) with automatic escalation to stronger models on hard failure. The architecture is a monolith agent loop with modular subsystems: a plugin system for tools, commands, and hooks; a skill system for reusable prompt templates; a knowledge injection system for contextual notes; a memory store with SQLite/FTS5; a RAG index for code snippet retrieval; and an MCP client/server for tool interoperability. The codebase includes a compiled MarrowScript cognition layer with typed prompts, output validation, and budget tracking, though the dual implementation (hand-ported JS alongside MarrowScript sources) introduces drift risk. Key entry points include bin/smallcode.js (main CLI), src/tui/fullscreen.js (zero-dependency TUI), and src/compiled/cognition/ (prompts, routers, validation). The agent loop orchestrates user input, model calls, tool dispatch, and improvement loops. The repository also includes benchmark harnesses, trace recording, evaluation runners, and a provider wizard for configuration. Despite being marked as 'dead' in the README, the codebase exhibits high craftsmanship in several reusable components, though the large feature surface and experimental nature suggest maintenance challenges.
fridaUiTools is a PyQt5 desktop application that serves as a comprehensive workbench for Android reverse engineering using Frida. It integrates dozens of Frida scripts for common tasks such as SSL unpinning, DEX dumping, JNI tracing, memory scanning, native hooking, and anti-debug bypass. The tool provides a unified GUI with attach/spawn modes, USB/WiFi connectivity, Frida server management, and AI-assisted script generation and log analysis. The architecture is a monolithic PyQt5 application with a main window (kmainForm.py) that orchestrates multiple dialog forms (e.g., SearchMemory, Wallbreaker, ZenTracer) and a background thread (TraceThread) for Frida script execution. While the codebase is functional and feature-rich, it suffers from tight coupling, duplicate scripts, hardcoded paths, and some dead code, making it more of a practical tool than a reference-quality codebase.
This repository implements the Elden Ring Practice Tool, a Windows application that provides an in-game overlay with cheats, debugging utilities, and speedrun practice features for Elden Ring. The system works by injecting a DLL into the game process, hooking DirectX 12 to render an ImGui overlay, and reading/writing game memory via pointer chains. The architecture is a Cargo workspace with multiple crates: `practice-tool` (main DLL with overlay UI), `lib/libeldenring` (core memory editing and parameter access library), `lib/param-tinkerer` (standalone parameter editor), `lib/no-logo` (intro screen removal DLL), `lib/scripts` (injector), and `xtask` (build and code generation orchestration). Key entry points include `practice-tool/src/lib.rs` (DLL main), `practice-tool/src/practice_tool.rs` (ImGui render loop), and `xtask/src/main.rs` (build tasks). Data flows involve reading game memory via pointer chains, parsing game parameters from community-maintained Paramdex XML, and generating Rust structs and base addresses via AOB scanning. External dependencies include `hudhook` for injection, `imgui` for UI, `windows` crate for Win32 APIs, and `Paramdex` for game data definitions. The tool is heavily version-dependent, supporting 28 game versions with hardcoded base addresses.
Open-AutoGLM (Phone Agent) is an AI-powered mobile automation framework that uses vision-language models to understand phone screens and execute user tasks through automated touch, swipe, and text input operations. The system works by repeatedly capturing device screenshots, sending them to a vision model (AutoGLM-Phone-9B or compatible API), parsing the model's decision into actionable commands, and executing those commands via platform-specific debugging tools (ADB for Android, HDC for HarmonyOS, WebDriverAgent for iOS). The architecture employs a device factory pattern to abstract platform differences behind a unified interface, an OpenAI-compatible model client with streaming and performance metrics, and a command-based action handler that supports tap, type, swipe, launch, back, home, long press, and takeover operations. The repository is structured as both a CLI application and a Python library, with comprehensive configuration for 50+ Android apps, 60+ HarmonyOS apps, and 100+ iOS apps, along with bilingual system prompts (Chinese/English), configurable timing parameters, and callback hooks for sensitive operation confirmation and manual intervention. Notable features include remote debugging support, verbose step-by-step execution with model thinking output, and integration with third-party model hosting services.
FreeStuffDev is a static website built with Astro that curates a categorized list of free tools and services for developers. It consists of a collection of Markdown files (over 900 entries) with frontmatter metadata (title, link, thumbnail, tags, etc.), which are rendered at build time into pages like the home page, tag filters, and alternative suggestions. The site is fully client-side for search, sorting, and favorites (via localStorage). It has no backend or API, and relies on GitHub for contribution. The codebase is straightforward and well-organized, demonstrating a clean content-driven static site pattern. It is not a software application in the traditional sense but a content directory, though its architecture is a standard Astro application.