This repository implements a local AI assistant for Windows with a focus on privacy and offline operation. The application features a modern Qt-based GUI with multiple tabs for chat, planning, briefing, home automation, and web search. It includes a voice pipeline with wake word detection ('jarvis'), speech-to-text, intent classification via a fine-tuned FunctionGemma model, local LLM inference through Ollama, and text-to-speech using Piper TTS. Core functionalities encompass smart home control (TP-Link Kasa), calendar/task management, weather/news aggregation, and system monitoring. The architecture is modular, separating concerns into core services (LLM, router, function execution, voice assistant) and GUI components, with communication via Qt signals and slots. Data is stored locally in SQLite databases. The project demonstrates thoughtful engineering in areas like reactive settings management, model persistence for VRAM optimization, and reusable UI components, though it maintains some Windows-specific dependencies and tight coupling in certain areas.
Primary risks are external coupling: only Linear is supported as an issue tracker, the Codex app-server protocol is version-specific and can drift, and the upstream spec (SPEC.upstream.md) is still marked 'Draft v1'. The project is pre-1.0 (v0.1.8) so APIs and configuration are not stable. The WORKFLOW.md format is project-specific and must be created manually by adopters. Error codes are extensive but not centrally validated, so new error paths could introduce duplicates. No data/research components exist; this is purely an operational automation tool.
This is a large collection of IoT device driver libraries for .NET nanoFramework, a .NET runtime for microcontrollers. It provides over 100 hardware bindings for sensors (temperature, humidity, pressure, gas, distance, light, motion), actuators (motors, LEDs, buzzers, relays), displays (OLED, e-paper, character LCD), communication modules (NFC/RFID, cellular modems, GNSS, CAN, Modbus, WiFi), and network services (DHCP, DNS, mDNS, MQTT, Home Assistant integration). Each device binding is a self-contained NuGet package with source code, samples, and optional unit tests. The repository also includes shared infrastructure such as GPIO abstractions, I2C/SPI helpers, logging, and a code generator for migrating bindings from the .NET IoT repository. The codebase is actively maintained but exhibits some technical drift: duplicated helper classes, inconsistent naming, generated code that may lag behind manual updates, and platform-specific assumptions (ESP32). Overall, it is a solid, functional library for embedded IoT development with nanoFramework.
This repository is a collection of sample applications and plugins for Android game development, maintained by Google. It demonstrates integration of the Android Game Development Kit (AGDK), Google Play Games Services, Play Asset Delivery, Adaptive Performance (ADPF), Game Mode, game controllers, and more. The samples span multiple engines: native C++ (NDK), Unity, Unreal Engine, and Godot. Each sample is a self-contained project with its own entry points (e.g., `android_main()` for native apps, `MainActivity` for Java, Unity scenes, Unreal game instances). The architecture varies per sample but commonly follows a scene-based game loop with a `SceneManager` singleton, input handling via cooked events, and rendering through either OpenGL ES or Vulkan via the `simple_renderer` abstraction. External dependencies include the Android SDK/NDK, Google Play Services libraries, and third-party libraries like glm, Bullet Physics, and Dear ImGui. The repo also includes utility tools like a Tuning Fork validation tool and Unity plugins for ANR detection and memory monitoring. While many components are well-crafted and reusable (e.g., `simple_renderer`, `base_game_framework`, `ndk_helper`), there is significant code duplication across samples and some use of deprecated APIs, indicating a moderate level of technical drift.
AIBotPublic is a full-stack ASP.NET Core MVC web application that provides a comprehensive AI chatbot platform. It integrates multiple AI providers (OpenAI, Baidu, custom endpoints) and offers features such as real-time chat, role-playing, AI assistants, knowledge base with vector search (Milvus), plugin marketplace, workflow automation, AI book generation, deep research, and a community forum. The system includes user management, payment processing (WeChat/Alipay), VIP tiers, and an admin panel for configuration and monitoring. The frontend is built with jQuery and Bootstrap, with a bundled Monaco Editor for code editing capabilities. The architecture follows a service layer pattern with dependency injection, Entity Framework Core for data access, Redis for caching, and SignalR for real-time communication. The repository also contains a custom OpenAI SDK wrapper (Betalgo.Ranul.OpenAI) that covers completions, embeddings, assistants, fine-tuning, and vector stores. While the codebase is feature-rich and functional, it exhibits signs of technical debt such as duplicated frontend pagination logic, hardcoded API URLs in JavaScript, and a large vendored third-party dependency (Monaco Editor v0.45.0). The project is actively maintained with recent commits and no open issues, but the reliance on .NET 6 and an older version of Monaco Editor indicates moderate technical drift.
Figura is a Minecraft mod (client-side, with an optional server backend) that enables extensive player avatar customization through Lua scripting and Blockbench model importing. The core architecture is a multi-loader (Fabric, Forge, Quilt, Spigot) project built with Architectury. The client mod integrates deeply with Minecraft's rendering pipeline via Mixins to replace or augment player model rendering, GUI, input, sound, and networking. Avatars are loaded from local files or fetched from a custom backend service (FSB) via HTTP/WebSocket. A Lua runtime (based on LuaJ) provides a rich API for scripting avatar behavior, rendering custom models, manipulating textures, handling events, and interacting with the game world. The server-common module provides a permission system, avatar storage, and packet-based communication for dedicated servers. The system's key entry points are the `FiguraMod` class (client initialization and tick), `AvatarManager` (avatar lifecycle), `FiguraAPIManager` (Lua API registration), and the various Mixin targets that hook into entity rendering, GUI screens, and input handling. Data flows include scanning local avatar directories, parsing Blockbench JSON and Lua scripts into NBT, caching textures and sounds, and synchronizing avatar data with the backend. External dependencies include Minecraft (1.20.1), LuaJ, Gson, Architectury, MixinExtras, and platform-specific mod loaders. The codebase exhibits a mix of high-quality, reusable abstractions (math library, event system, packet abstraction, permission framework) alongside areas of technical debt (incomplete backend handlers, duplicated platform code, fragile Mixins, and some hardcoded values). The mod is actively maintained with a large community, but the sheer volume of Mixins and multi-version support introduces maintenance risk. Overall, it is a solid, professional-grade mod with a well-designed Lua API and rendering pipeline, though some subsystems are still in development.
This repository is the COSMIC desktop environment's suite of panel applets, implemented as a Rust Cargo workspace with approximately 30 crate members. Each applet (audio, battery, bluetooth, network, notifications, power, tiling, time, accessibility, input sources, minimize, workspaces, app list, status area) is an independent cosmic::Application component that can be compiled as a separate binary or dispatched from a unified 'cosmic-applets' binary via symlink naming. The architecture follows the Elm/iced pattern with Message enums, update/view functions, and subscriptions to system events (Wayland protocols, D-Bus signals, config changes, timer ticks). All applets share a common localization infrastructure using i18n-embed and Fluent, and many reuse a 'wayland_subscription' pattern for compositor events. The codebase is actively developed by System76 for the Pop!_OS COSMIC desktop, with significant internationalization (60+ language directories) and integration with Linux system services (NetworkManager, PulseAudio, UPower, BlueZ, systemd-logind). It is not a data/research repository.
This repository is a Tailwind CSS plugin that generates utility classes for fixed aspect ratios using the 'padding-bottom trick' for browser compatibility (particularly Safari 14). The plugin provides composable classes like `aspect-w-{n}` and `aspect-h-{n}` that set CSS custom properties to define the width and height ratio, along with `aspect-none` to remove the ratio. It supports both Tailwind CSS v2 (via `addComponents`) and v3 (via the newer `matchComponents` API, which also enables arbitrary values). The codebase is minimal: a single source file (`src/index.js`) that exports a plugin configuration, a TypeScript type declaration, and a Jest test suite that validates CSS output for both versions. As noted in the README, Tailwind CSS v3.0 ships with native `aspect-ratio` utilities, making this plugin obsolete for most projects; it remains useful only for projects requiring Safari 14 support. The implementation is clean, well-structured, and follows Tailwind's official plugin authoring patterns, but offers no surprising craftsmanship or reusable components beyond its designated purpose.
This repository is a specialized tool for previewing icon fonts, primarily targeting frontend developers. It consists of three main components: a Node.js HTTP server (font-searcher.js) that scans local directories for font files and provides a REST API, a single-page Vue.js application (index.html) that loads and displays icons from local or online sources, and a browser userscript (iconfont-preview.user.js) that enhances web pages by detecting iconfont links and offering quick previews. The tool supports multiple font formats (TTF, WOFF, WOFF2, OTF, EOT) and uses opentype.js for TTF/OTF parsing and a WebAssembly module (woff2-decode.js) for WOFF2 decoding. For online CSS/JS resources, it extracts icon names via regex. The architecture combines a local server for development scanning with a client-side Vue app for rendering, while the userscript enables on-the-fly previewing during web browsing.
kubectl-df-pv is a kubectl plugin that displays disk usage (like the Unix `df` command) for Kubernetes Persistent Volumes. It retrieves storage metrics from each node's kubelet stats/summary endpoint and presents them in a color-coded, human-readable table. The tool handles concurrent node queries using goroutines and channels, supports filtering by namespace, and allows users to select which columns to display (including inode information). It auto-converts byte sizes to IEC binary prefixes (Ki, Mi, Gi, Ti) and colorizes usage percentages (red > 75%, yellow < 25%, green otherwise). The codebase is a single Go binary using Cobra for CLI parsing, client-go for Kubernetes API interaction, and go-pretty for table rendering. It is a well-structured, focused utility that solves a specific operational need for Kubernetes administrators. While the core logic is solid, the project is relatively simple and does not exhibit exceptional architectural depth or highly reusable components beyond basic byte formatting.
This repository contains the **HLA-NoVR** mod for *Half-Life: Alyx*, a comprehensive modification that enables the game to be played without a VR headset using standard mouse and keyboard controls. The mod replaces VR-specific interactions (e.g., gravity gloves, wrist pockets, flashlight, weapon upgrades) with flat-screen equivalents, while preserving as much of the original gameplay as possible. The core logic is implemented as Lua scripts loaded through the Source 2 VScript system, with compiled map packages (VPK files) per chapter that contain modified entities, world geometry, and custom trigger models. The mod is structured as a game addon and includes a launcher integration, configuration via command-line flags, and a save/load system for player inventory across maps. Although the mod is functional and widely used, the codebase exhibits monolithic design (especially novr.lua), heavy reliance on hardcoded map-specific coordinates and entity names, and several incomplete TODO comments, indicating moderate technical drift.
Mi-Create is a desktop GUI application for creating and editing watchfaces for Xiaomi smartwatches. Built with PyQt6, it provides a tabbed interface for managing multiple watchface projects, with dockable panels for project exploration, property editing, and resource management. Users can design watchfaces using widgets (images, text, analog displays, etc.), preview designs, and compile them to binary .face files for device deployment. The application features a plugin system for extensibility, theme management with light/dark modes, internationalization support, and an auto-update mechanism. It handles multiple project formats (Fprj, GMF) and includes tools for format conversion and binary manipulation. The architecture follows a modular design with clear separation of concerns: the main window (WatchfaceEditor) coordinates UI components, while utilities handle plugins, themes, history (undo/redo), and project management. The canvas uses custom QGraphicsView items for rendering watchface elements, and the properties editor dynamically generates input fields based on schema definitions. Platform-specific window effects are implemented for Windows, macOS, and Linux to provide frameless window behavior. The application relies on external dependencies including PyQt6, platform-specific packages (pywin32, pyobjc), and build tools like Wine and a custom compiler for generating watchface binaries. While the codebase demonstrates solid engineering practices with reusable components like the plugin system and theme engine, it shows signs of technical debt including platform-specific conditionals, tight coupling in the main window class (exceeding 2000 lines), and reliance on external tools that may introduce compatibility issues. The presence of TODO comments, commented-out code, and hardcoded values suggests areas for refinement. However, the active maintenance status and structured approach to extensibility indicate a viable project with opportunities for improvement in modularity and dependency management.
This repository is a C# port of the Three.js 3D library, providing a comprehensive 3D graphics framework for .NET applications. It implements a scene graph architecture with Object3D hierarchy, supporting geometries, materials, cameras, lights, and various loading mechanisms for 3D models and textures. The library offers multiple rendering backends (OpenTK/OpenGL and Silk.NET) and includes extensive example applications demonstrating features like physically-based rendering, post-processing effects, animation systems, and camera controls. The codebase shows good separation of concerns in core mathematical utilities and event systems, though suffers from some duplication between rendering backends and inconsistent patterns in examples.
This is the umbrella monorepo for Evo CRM Community, an open-source AI-powered customer support platform. The repository itself does not contain application source code; it orchestrates seven independent microservices (auth, CRM, frontend, AI processor, core service, bot runtime, and event flow) via Git submodules and Docker Compose/Swarm configurations. The primary function of this repo is to provide a single entry point for cloning, building, seeding, and deploying the full stack. It includes a nginx API gateway for path-based routing to backend services, CI/CD workflows for building and publishing Docker images, migration version collision guards, and extensive release documentation. The actual business logic, AI agent execution, conversation management, and user interface reside in the submodules.
This is a production-grade web application for automated batch registration and management of OpenAI accounts. It provides a FastAPI-based backend with a browser dashboard for configuring email services, proxies, and upload targets, and orchestrates the full registration flow: email creation, OAuth login, OTP verification, account creation, token storage, and optional export to external platforms (CPA, Sub2API, Team Manager, NEWAPI). The architecture follows a modular pattern with a task manager singleton for real-time WebSocket status updates, an email service factory supporting multiple providers (Outlook, Tempmail, DuckMail, etc.), and a proxy management system with dynamic failover. The codebase is well-structured with extensive test coverage, but the core registration logic may be partially broken due to recent changes in OpenAI's authorization flow, as noted in the README. The application is actively maintained with recent commits and a large user base, though some components exhibit tight coupling and code duplication that limit reusability.
This repository is a fully functional, offline single-player space strategy game (OGame clone) built with Vue 3, TypeScript, Pinia, and shadcn-vue. It implements the complete OGame feature set: resource management, building, research, fleet combat, defense, diplomacy, NPC AI, achievements, campaigns, and a battle simulator. The architecture is a modern SPA with client-side persistence (localStorage encrypted via AES), optional WebDAV cloud sync, and multi-platform builds (web, desktop via Electron, Android via Capacitor, Docker). The game logic is organized into modular TypeScript files under `src/logic/`, with a centralized game loop in `App.vue` that processes resource production, construction queues, fleet missions, NPC behavior, and achievement checks every second. The UI uses a custom component library built on shadcn-vue and Reka UI, with full internationalization (8 languages). The repository also includes a Go-based static server for production deployment and a battle simulation Web Worker for offloading heavy computation. While the codebase is well-structured and demonstrates good use of modern frontend patterns, it is heavily coupled to game state and lacks automated tests, which limits reusability of most modules outside this project.
Lavandula is a lightweight C web framework designed for building small web applications quickly. It provides HTTP server functionality with routing, middleware pipeline support, SQLite3 integration, and a built-in JSON library. The framework includes a CLI tool (lavu) for project scaffolding and features a 'hot restart' mechanism for development. The codebase is well-organized with clear separation of concerns between HTTP parsing, routing, middleware, and database operations. However, the README explicitly states it's in early development and not production-ready, with several features still in progress including multithreading, TLS, rate limiting, and the Lavender ORM layer. The framework demonstrates solid C engineering practices with proper memory management, error handling, and a comprehensive test suite covering core components like JSON parsing, authentication, CORS, and HTTP parsing.
Pokemon-Terminal is a CLI tool that sets Pokemon images as terminal backgrounds or desktop wallpapers. It supports multiple terminal emulators (iTerm2, ConEmu, Terminology, Tilix, Windows Terminal, Kitty) and desktop environments (macOS, GNOME, sway, feh, swww, Windows) via a clean adapter pattern with runtime discovery. The system parses user-supplied filters (name, region, type, brightness) from a database of 719 Pokemon plus custom extras, then applies the selected image to the terminal or wallpaper. It also features a slideshow mode using multiprocessing and platform-specific named events for IPC. While the codebase has some rough edges (global mutable state in filters, a hacky unittest.mock.patch in production for POSIX named event detection), the overall architecture is well-modularized and demonstrates solid use of abstraction and reflection. The repo is actively maintained with recent commits and a large community (4.8k stars).
WarriorJS is a terminal-based educational game that teaches JavaScript and TypeScript through interactive coding challenges. Players write a `Player` class with a `playTurn(warrior)` method to control a warrior navigating grid-based towers filled with enemies, captives, and stairs. The game runs as a CLI application using Ink (React for terminal UI) and relies on a sandboxed code execution environment via Node's `vm` module and esbuild. The monorepo structure includes a CLI app, game engine (`@warriorjs/core`), abilities library (`@warriorjs/abilities`), units library (`@warriorjs/units`), scoring module, spatial math helpers, effects, and two sample towers. The codebase demonstrates clean architecture with well-separated concerns, extensive test coverage, and reusable patterns such as the ability/effect binding factory and sensed space wrappers. However, the project has been inactive since 2018 (last release v0.14.0), the documentation website uses the deprecated Docusaurus v1, and there are some mixed module system usages. Despite being stale, the game engine and ability system remain functional and could be extracted for similar turn-based coding games or sandboxed code execution.
This repository provides a preconfigured Nginx reverse proxy distribution designed to bypass regional internet censorship (primarily for Pixiv, but also covering GitHub, Steam, Discord, and other services). It includes a portable Nginx binary, self-signed SSL certificate generation scripts, and a set of modular site-specific configuration files that rewrite SNI and proxy requests to real upstream IP addresses. The system requires no VPN; instead, it modifies the user's `hosts` file to redirect target domains to localhost, where Nginx intercepts the traffic. The primary entry points are Windows batch scripts (e.g., `5.θ°θ―ε·₯ε ·οΌθΏδΈͺεθ½ε ¨οΌ.bat`) for starting, stopping, and reloading Nginx, while the core configuration is in `conf/nginx.conf` which includes reusable shared proxy parameters and site-specific configs. Certificate generation is handled by a standalone batch script folder (`θͺηΎθ―δΉ¦ε»ηεΌζΉε€ηε /`) that creates a root CA and signs server certificates for all proxied domains. The repository is not a development framework or data pipeline; it is an end-user tool for circumventing censorship, with a strong emphasis on easy setup and maintenance through regular IP list updates.