tsumiki is a Claude Code plugin and skill library that operationalizes AI Test-Driven Development (AITDD). It exposes slash commands (`/dev-impl`, `/dev-debug`, `/ipa-security-check`, `/orchestrate`) and Markdown-based skills that guide an AI coding agent through a Red-Green-Refactor-Validation cycle. The repository is not a standalone runtime; it is a development methodology toolkit whose primary artifacts are command definitions, skill instructions, and workflow orchestration logic consumed by Claude Code.
This is a Flutter-based cross-platform peer-to-peer file sharing application designed for local network transfers without server reliance. The app enables sharing of files, text, clipboard content, and folders between Android, iOS, Windows, macOS, Linux, and Web devices. Architecture follows a modular pattern with GetX for state management, featuring separate controllers (chat, device, settings, download), services (HTTP-based messaging via shelf, file serving, UDP discovery, clipboard), and platform-specific adapters. Key workflows include device discovery via multicast, HTTP-based message/file transfer, and adaptive UI rendering. The application demonstrates solid engineering practices with platform abstraction, reusable UI components, and thoughtful handling of cross-platform file operations, though exhibits some coupling between controllers and platform-specific code paths.
Deep Forest (DF21) is a Python library implementing the Deep Forest ensemble learning algorithm, which serves as an alternative to deep neural networks for tabular data. The system provides both classification (CascadeForestClassifier) and regression (CascadeForestRegressor) capabilities through a cascade of decision tree ensembles. Each cascade layer consists of multiple estimators (Random Forest and Extra Trees) whose out-of-bag predictions serve as augmented features for subsequent layers. The architecture includes feature binning for efficiency, early stopping mechanisms, support for custom estimators/predictors, and a partial mode for memory-efficient training on large datasets. The codebase is organized into modular components with clear separation of concerns, including dedicated modules for binning, estimation, layer management, tree implementation, and I/O operations.
EasyXT is a comprehensive quantitative trading toolkit for Chinese A-share markets, built on top of the Xuntou QMT broker platform. It provides a modular ecosystem that includes data management (multi-source with automatic fallback via DuckDB, Tushare, BaoStock, QMT DAT files, etc.), factor research (Alpha101/Alpha191 engines, IC/IR analysis, layered backtesting, Fama-French factors), backtesting engines (vectorized and event-driven with T+1 enforcement), live trading capabilities (auto-login, signal bridges, real-time quote providers, WebSocket push, monitoring), and multiple strategy implementations (grid trading, small-cap, convertible bonds, Xueqiu portfolio following). The system also features a PyQt5 desktop GUI and a Streamlit web app for factor analysis and strategy configuration. While primarily an application framework for executing trading strategies, it contains significant data research components for alpha factor development and performance analysis, making it a hybrid tool with a focus on production deployment. The codebase is large and actively maintained, with well-designed abstractions like data source adapters, cache backends, and a config manager, but also exhibits some duplication, hardcoded paths, and mixed Chinese/English naming that may hinder portability.
This repository provides a ComfyUI custom node extension that wraps NVIDIA's nvidia-vfx SDK for GPU-accelerated video processing. It implements three nodes: RTX Video Super Resolution (upscaling, denoising, deblurring), RTX Video HDR (SDR-to-HDR conversion with PQ and HLG support), and RTX Video Frame Generation (interpolation for frame rate conversion or slow motion). The code is a single Python module that integrates with ComfyUI's plugin system via an async entrypoint, converting between ComfyUI's channels-last image tensors and the SDK's channels-first or packed representations using PyTorch DLPack. Notable technical decisions include intelligent batch chunking to limit peak VRAM usage, a custom PQ-to-HLG color space conversion with system gamma correction, and bit-packing routines for 10-bit precision. The implementation is clean and well-typed, though tightly coupled to both ComfyUI and the NVIDIA SDK, limiting standalone reusability.
This repository contains custom open-source firmware for Quansheng UV-K1/K5 V3 handheld ham radios, built around the PY32F071 MCU. It is a fork in the lineage DualTachyon → Egzumer → F4HWN → this project, adding features gated by compile-time flags (ENABLE_FEAT_F4HWN_*, ENABLE_NOAA, ENABLE_DTMF_CALLING, etc.). The firmware is bare-metal C (no RTOS in the application code despite CMSIS-RTOS2 RTX5 being vendored), with a main-loop architecture and an overlay app system using an app_api_t struct of function pointers. The build system uses CMake presets, per-app build.sh scripts, and a Docker wrapper (compile-firmware.sh) producing .elf/.bin/.hex artifacts. A pack_app.py script packs raw binaries into .app blobs. The repository vendors a large CMSIS_5 tree (~20k+ files), most of which is unused DSP/RTOS/validation code, bloating the repo. The README explicitly warns that flashing can brick radios, and overlay apps run with full privileges (no MPU). Notable engineering patterns include the overlay app API (function-pointer-based, placed in .text.entry section), an LL I2C driver mirroring STM32 LL conventions, and extensive conditional compilation. However, the codebase shows drift: deprecated compile-with-docker.sh retained as a forwarding shim, repetitive per-app build scripts, vendored CMSIS that may be outdated, and a license placeholder in the CMSIS bundle. Maintenance is active with recent commits, but the fork lineage and vendored dependencies create ongoing merge/upstream complexity. This is purely an embedded application repository - no datasets, ML models, or research artifacts are present.
This repository hosts a Jekyll-based GitHub Pages website that curates and distributes AI skills (SKILL.md files) for economists. The site presents a browsable catalog of 17 skills organized by research workflow stage (ideation, literature, theory, data, analysis, writing, communication, engineering). It offers user path personalization (beginner/intermediate/advanced) persisted via localStorage, a download-all-skills feature that bundles skills into a zip using JSZip, individual skill downloads, a submission form that opens a GitHub Issue, and an educational 'Learn' page explaining AI agent concepts. The repository is primarily a content distribution platform; the actual software consists of the Jekyll site structure, CSS design system, and JavaScript interactivity. The skills themselves are high-quality markdown documents with YAML frontmatter, containing detailed instructions for AI coding assistants like Claude Code, Cursor, and Gemini CLI.
This is a large Go and TypeScript project for managing and monitoring network devices, specifically MikroTik routers. It has a web interface, role-based access control, and supports features like backups, settings management, and notifications.
SkyReels-V3 is a multimodal video generation inference framework that supports three core tasks: reference-to-video (generating video from 1-4 reference images), video extension (single-shot and shot-switching), and talking avatar generation (from a portrait and audio). The codebase implements a diffusion transformer architecture (Wan-based) with custom components including a causal 3D VAE, T5 text encoder, CLIP image encoder, wav2vec2 audio encoder, and a flow-matching scheduler. It provides multi-GPU support via xDiT USP and low VRAM options with FP8 quantization and block offloading. The system is designed as a CLI tool with a single entry point (`generate_video.py`) that dispatches to task-specific pipelines. While primarily an application for running inference, it contains several reusable modules such as a custom scheduler, attention wrappers, and color transfer utilities.
grzyClothTool is a GTA V modding tool suite consisting of two main applications: CodeWalker (a WinForms-based game file viewer/editor with DirectX 11 rendering) and grzyClothTool (a WPF-based clothing addon manager using MVVM pattern). The tool enables users to import, preview, organize, optimize, and build GTA V clothing assets for FiveM/singleplayer/AltV platforms. Key features include 3D asset preview via CodeWalker integration, duplicate detection, texture optimization, auto-save functionality, and project management. The architecture separates concerns with shared libraries (CodeWalker.Core), plugin support via MEF, and navigation systems for view switching. Data flows involve scanning game files, importing assets (.ydd/.ytd), organizing via tags/groups, resolving conflicts, optimizing resources, and building final addon packages.
Handwrite is a CLI application that converts a scanned handwriting sample into a TrueType font. The pipeline consists of three stages: SHEETtoPNG uses OpenCV to detect and extract individual character images from a grid-based form; PNGtoSVG uses Potrace to convert the PNG images to SVG vector outlines; and SVGtoTTF uses FontForge to compile the SVGs into a font file with configurable metrics, kerning, and bearings. The architecture is a simple sequential pipeline orchestrated by the CLI entry point. External dependencies include OpenCV, Pillow, Potrace, and FontForge. The codebase is well-structured with unit tests, CI, and modern Python packaging (uv, Python 3.14). The character detection module in `sheettopng.py` demonstrates reusable grid-based contour extraction logic.
Scal3R is a research codebase for CVPR 2026 Highlight paper on large-scale 3D reconstruction from unordered images using test-time training. The core contribution is a novel bidirectional attention mechanism with fast weight updates (TTT layers) that adapts during inference to improve reconstruction quality for large scenes. The repository provides an end-to-end inference pipeline: given a folder of images, it estimates camera poses, depth maps, and produces a colored point cloud. The architecture builds on a DINOv2 backbone and VGGT-based aggregator with custom attention heads, loop detection via SALAD, and pose graph optimization with submap management. The codebase is well-structured with separate modules for data loading, model definition, inference orchestration, and visualization tools. It includes fallback implementations for key components (e.g., Python-only loop solver, simple correlation-based loop detector) to improve portability, though GPU and CUDA are assumed. The repository is primarily a research artifact with clean utilities that could be extracted for other 3D vision projects. Evaluation code and dataset scripts are explicitly marked as not yet released, limiting reproducibility until those are provided.
This repository is an Android plugin for the Android Team Awareness Kit (ATAK) that integrates with Meshtastic mesh networking technology. It enables tactical communication capabilities including position sharing, messaging, voice memos, file transfer, and external GPS functionality over Meshtastic's low-power, long-range mesh network. The application follows a modular architecture with separate components for mesh service management, CoT (Cursor on Target) event processing, voice encoding/decoding using Codec2, and reliable file transfer using fountain codes. The codebase combines Java/Kotlin for Android components with C/C++ for the Codec2 audio codec and STM32 microcontroller implementations, reflecting its dual purpose as both an Android application and embedded communications system.
StereoCrafter is an application that converts monocular videos to stereoscopic 3D videos using a two-stage diffusion-based pipeline. The first stage estimates depth via DepthCrafter and generates a right-eye view through forward warping. The second stage refines the stereo video using a fine-tuned Stable Video Diffusion model with spatial tiling for high-resolution processing. The system relies on external dependencies including DepthCrafter and Forward-Warp submodules, and requires manual download of model weights. The codebase demonstrates modular design with clear separation between depth estimation, warping, and inpainting stages.
CanOpenSTM32 is an STM32 integration layer and example suite for the CANopenNode CANopen protocol stack. The core code provides a compact C API in CANopenNode_STM32/ that wraps CANopenNode initialization and periodic processing into canopen_app_init(), canopen_app_process(), canopen_app_interrupt(), and canopen_app_resetCommunication(). The CANopenNodeSTM32 configuration struct carries bus handles, node ID, baudrate, and timer callbacks, allowing the same application pattern to run across multiple STM32 families. A low-level driver abstracts STM32 HAL classic CAN and FDCAN peripherals behind a unified interface, with optional locking hooks for bare-metal or FreeRTOS use. The repository is primarily a collection of board bring-up examples rather than a standalone product. It contains full CubeMX-style firmware projects for STM32F0, F3, F4, G0, and H7, both bare-metal and FreeRTOS variants, with vendored CMSIS/STM32 HAL drivers and generated CANopen object dictionaries. The dominant data flow is interrupt-driven: a 1 ms timer interrupt feeds canopen_app_interrupt(), CAN/FDCAN IRQ handlers push received frames into CANopenNode, and the main loop calls canopen_app_process() to run protocol state machines. Build automation is provided by per-example CMake presets and scripts/build.py, which builds every example project. A legacy/ tree contains older H7-specific FreeRTOS implementations and duplicated vendor drivers that are not actively maintained. There are no automated unit tests; verification is build-based and board-level.
SoundFlow is a comprehensive .NET audio framework providing cross-platform audio processing, synthesis, MIDI handling, and security features. It features a modular architecture with components, modifiers, and analyzers that can be chained together to build audio applications. The framework supports audio playback/recording, real-time effects, MIDI sequencing, audio analysis, encryption, watermarking, and fingerprinting. It includes extensive platform-specific native libraries (MiniAudio, FFmpeg, PortMidi, WebRTC APM) built for Windows, Linux, macOS, iOS, Android, and FreeBSD. The repository includes numerous sample applications demonstrating various capabilities, from simple playback to complex security-enabled audio processing.
This repository provides a GitHub Action that wraps the lychee link checker to validate links in Markdown, HTML, and text files. The action downloads and installs a specified version of lychee, runs it with configurable arguments, and processes the output to set exit codes and generate reports. The core action is well-designed with robust version handling and error processing, but the associated workflow files show signs of technical drift due to outdated action versions (e.g., actions/checkout@v7 which doesn't exist). The action is actively maintained with recent commits and automated version update workflows.
ImNodeFlow is a C++ library that provides node-based editor functionality for Dear ImGui applications. It enables developers to create visual programming interfaces with customizable nodes, input/output pins, and bezier curve connections. The library handles all aspects of the node editor including grid management, node rendering, link rendering, user interactions (dragging, clicking, popup menus), and connection logic. The architecture centers around the ImNodeFlow class which manages the infinite grid, nodes, and links. Custom nodes are created by deriving from BaseNode and implementing the draw() method for node content. The system uses a retained-mode approach for nodes and links while leveraging ImGui's immediate-mode rendering for the UI. Key features include zoom/pan support, connection filtering, customizable styling, and popup events for right-click and dropped links. While primarily a UI component library, the repository includes specialized mathematical utilities that could be reused independently. The bezier math implementation for connection rendering and the context wrapper for zoom/pan functionality demonstrate particularly strong encapsulation and could be extracted for use in other projects.
Wuji (无极) is a cross-platform media aggregation application built with Tauri v2 (Rust backend) and Vue 3 (frontend). It allows users to browse, search, and consume content across multiple media types—books, comics, videos, music, and photos—from user-defined 'subscribe sources' that are implemented as JavaScript extensions. The application includes a built-in Monaco code editor for creating and editing these extensions, a cloud synchronization engine with CRDT-like conflict resolution (LWW clocks, tombstones, pending queues), a download manager with M3U8 support and AES decryption, DLNA casting, text-to-speech via Edge TTS, and a membership system with VIP/PRO tiers. It targets both desktop (Windows) and mobile (Android) platforms through Tauri's plugin architecture, with platform-specific implementations in Rust and Kotlin. The architecture is monolithic but modular, with clear separation into packages (sync, source-extension, fetch, components, hot-api) and custom Tauri plugins (commands, mediasession, cast, mywebview). The sync library is particularly well-crafted, offering a reusable offline-first synchronization pattern. The codebase is actively maintained with recent commits, though testing coverage is limited to the sync package and a few utility modules.
This repository is a curated collection of low-level design (LLD) and machine coding round solutions, primarily targeting interview preparation. It contains over 15 self-contained subprojects, each modeling a classic system design problem such as chess, elevator control, Uber ride booking, Splitwise expense splitting, parking lot, stock broker, task scheduler, Kafka message queue, in-memory key-value store, and more. Each subproject follows a consistent architecture with domain models, repository interfaces with in-memory implementations, service classes, and often a Main or Demo class for standalone execution. The code heavily employs design patterns like Strategy, Factory, Repository, and Observer, and demonstrates concurrency handling with locks, atomic variables, and thread-safe collections. The collection is not intended for production deployment; all state is volatile and stored in-memory. While the quality is uneven across subprojects, many exhibit clean separation of concerns and extensible design. The repository serves as a practical study resource for object-oriented design, with problem statements and video tutorials linked in the README. Some subprojects have multiple iterations (e.g., Kafka from simple to production-grade) showing evolution, but this also introduces duplication and occasional inconsistencies in naming and package structure. Despite the lack of automated tests and incomplete implementations in a few areas, the overall codebase demonstrates solid craftsmanship for educational purposes. A handful of modules—such as the distributed cache with consistent hashing, the circuit breaker for resilience, the order matching engine, and the heap-based feed fetch strategy—are particularly well-isolated and could be extracted for reuse in other projects with minimal adaptation.