SkinTokens is a research codebase for a novel 3D character rigging method (TokenRig) that learns a compact discrete representation (SkinTokens) for skinning weights. The system ingests 3D meshes with skeleton and skinning data (from ArticulationXL, VRoid Hub, ModelsResource), transforms them through a pipeline of augmentation, order arrangement, vertex group extraction, and sampling, then trains an FSQ-CVAE to compress skinning weights into discrete tokens. A Qwen3-0.6B-based autoregressive transformer (TokenRig) generates the full rig (skeleton hierarchy + skin tokens) as a single token sequence. The repo includes a Blender-based server for mesh loading and export, a Gradio demo, a CLI, and extensive data processing modules. The code is well-structured with dataclass-based configs, abstract interfaces, and modular design, but remains primarily a research artifact with some incomplete training implementations (e.g., TokenRig training_step raises NotImplementedError). Its hybrid nature leans strongly toward data research, as the core contribution is a learned representation and generative model for animation rigging.
Memo is a Python CLI tool for managing Apple Notes and Apple Reminders. It provides commands to list, add, edit, delete, move, search, and view notes, as well as manage reminders. The tool uses AppleScript to interact with macOS applications and includes a caching mechanism to avoid repeated expensive calls. A notable feature is its handling of inline images in notes when converting between HTML and Markdown, preserving images through the edit cycle via placeholders.
Talkio is a local-first, cross-platform AI chat client (Tauri 2 desktop + Android, React 19 + TypeScript web layer) whose core product is multi-model group chat: multiple AI models, each with a distinct persona/identity, system prompt, temperature, and tool bindings, converse in one conversation with configurable speaking orders (sequential/random/parallel), @-mentions, participant muting, moderator summaries, and auto-discuss rounds. Data is persisted in SQLite (tauri-plugin-sql) for conversations/messages/tasks, a localStorage-backed KV store for provider/model config, and OS credential stores (Keychain/Android Keystore) for API keys. Provider support includes OpenAI, Anthropic, Gemini, Azure, and OpenAI-compatible gateways, with image generation via provider-backed models. A Vercel AI SDK runtime layer (ai-sdk-runtime.ts) maps stream events into the app's generation pipeline, and a streamed-completion-fetch SSE shim tolerates non-compliant streaming gateways.
ResumeLM is an AI-powered resume builder application built with Next.js 15, React 19, and TypeScript. It provides a SaaS platform for creating, editing, and optimizing resumes for tech job applications, featuring AI-assisted content generation, resume tailoring for specific job applications, ATS optimization, and cover letter generation. The application uses Supabase for authentication and data storage, Stripe for subscription management, and integrates with multiple AI providers (OpenAI, Anthropic, Google, etc.) via OpenRouter or direct API keys. The architecture follows a modular structure with separate concerns for authentication, dashboard, resume editor, admin panel, and settings, leveraging server actions for data mutations and a robust AI abstraction layer for model selection and usage tracking.
MegaDetector is a production-grade object detection pipeline specifically designed for camera trap images in wildlife conservation. It detects animals, people, and vehicles in images and videos, outputting bounding boxes with confidence scores in a standardized JSON format (MegaDetector output format). The system provides a comprehensive set of command-line tools for batch inference, post-processing (repeat detection elimination, classification smoothing, format conversion), and integration with platforms like Wildlife Insights and LILA. The architecture is a modular Python package with separate modules for detection (supporting PyTorch and TensorFlow backends), classification, data management, post-processing, visualization, and taxonomy mapping. Key entry points include `run_detector_batch.py` for batch inference, `run_detector.py` for single-image inference, `postprocess_batch_results.py` for generating HTML previews, and `separate_detections_into_folders.py` for organizing results. Data flows from raw images through the detector to JSON results, which are then post-processed (e.g., false positive reduction, confidence thresholding) and optionally converted to other formats (COCO, YOLO, Wildlife Insights). External dependencies include PyTorch, TensorFlow, ultralytics, OpenCV, PIL, and various utility libraries. The repository also includes a C# Windows GUI application for JSON subsetting and integration guides for Timelapse and digiKam.
ONO is an Android Xposed module that modifies and enhances the QQ messaging application (Tencent). It provides a broad set of features including custom sticker panels, message encryption, anti-revoke, developer tools (packet inspection, cookie retrieval), UI tweaks (bubble redirect, profile card menu), and entertainment hooks (fake group owner, sport step spoofing). The module supports both legacy Xposed (API 51–99) and modern LSPosed (libxposed API 100) frameworks, with a dual-entry architecture that unifies startup through a shared `UnifiedEntryPoint` and `StartupRoutine`. Internally, it uses a sophisticated hook item framework based on annotations and a KSP annotation processor to automatically register hook classes. The codebase is heavily reliant on reflection and reverse-engineering of QQ's internal classes, making it tightly coupled to specific QQ versions, but the core utilities (reflection helpers, configuration management, protocol building) are well-crafted and potentially reusable in other Android hooking projects. The project is actively maintained with frequent commits, responsive issue triage, and a comprehensive build system using Gradle convention plugins.
This repository is a modified/forked version of the Hugging Face Diffusers library with specific additions for RealRestorer, a generalizable real-world image restoration model. It provides pipelines for various image restoration tasks (blur removal, compression artifact removal, lens flare removal, moire removal, dehazing, low-light enhancement, denoising, rain removal, reflection removal), tools for synthesizing real-world degradations, benchmark evaluation capabilities, and standard diffusion model functionalities. The architecture follows a modular library structure with lazy loading patterns, standardized pipeline interfaces, and extensive training/inference utilities. Key entry points include CLI commands for export, inference, and degradation synthesis, along with server examples for deployment.
This repository is the canonical ADC Performance Survey dataset maintained by Boris Murmann. It aggregates published ADC (analog-to-digital converter) performance data from ISSCC and VLSI Symposium papers between 1997 and 2026. The primary data artifact is an Excel workbook (xls/ADCsurvey_latest.xlsx) that is consumed by a set of Jupyter notebooks under plots/ to generate publication-quality figures such as FOMs plots, energy plots, aperture trend plots, and FOM trend plots. The repo also contains PDF resources and a short course presentation.
PLINDER is a comprehensive protein-ligand interaction dataset and evaluation resource, providing over 400,000 annotated systems with 750+ annotation columns derived from the PDB. The repository contains a full data generation pipeline (Metaflow-based, configurable via YAML) that downloads, annotates, scores, clusters, and splits structures into train/val/test sets with leakage control. It also includes a Python API (PlinderSystem, PlinderDataset) for accessing the dataset, querying similarity scores, and loading structures, as well as an evaluation harness (ModelScores, StratifiedTestSet) for benchmarking docking algorithms using metrics like lDDT-PLI, DockQ, and posebusters checks. The codebase is hybrid: primarily a data research project with strong software engineering practices (Docker, CI/CD, extensive tests, config-driven pipelines), but the core value is the curated dataset and the tools to generate and evaluate it.
androidqf is a Go-based Android forensic data acquisition tool designed to collect various types of data from an Android device via ADB. The tool automates the gathering of device properties, system logs, running processes, services, settings, diagnostic information, installed applications (with optional APK extraction), and device backups. It stores the collected data in a timestamped directory and optionally encrypts and compresses the archive using age encryption if a public key is provided. The application follows a modular architecture where each data collection task is implemented as a separate module adhering to a common interface. The core components include a cross-platform ADB wrapper that automatically deploys platform-specific binaries, an asset embedding mechanism for distributing native dependencies, and an acquisition manager that handles the lifecycle of data collection and secure storage. The tool interacts with the device through ADB commands, collects data into structured files and directories, and provides user prompts for configurable options such as backup scope and APK selection. Despite the README indicating the project is not maintained, the repository shows recent commit activity and the codebase demonstrates solid engineering practices. Dependencies are up to date, and the tool is built for cross-platform use (Windows, macOS, Linux) with automated build and release workflows. The modular design allows for extensibility, and the reusable components (such as the ADB wrapper and asset deployment) could be adapted for other projects requiring Android device interaction.
GWASLab is a Python library and CLI tool for comprehensive processing, quality control, harmonization, visualization, and downstream analysis of GWAS summary statistics. The core object is the `Sumstats` class, which wraps a pandas DataFrame with metadata, status codes, and methods for common operations such as basic QC (`basic_check()`), genome build inference, rsID assignment, allele harmonization, liftover, and format conversion (TSV, VCF, LDSC, PLINK, etc.). The architecture follows a modular design: a pure-calculation `algorithm` subpackage (numpy/scipy only) for effect-size conversions, fine-mapping (ABF), meta-analysis, and power calculations; a `qc` layer for pipeline orchestration with a decorator (`@with_logging`) that enforces column validation, tool availability, and logging; a `hm` layer for variant lookup and harmonization using VCF/BCF and caching (Parquet); a `viz` layer with dozens of plot types (Manhattan, QQ, regional, Miami, forest, phenogram, Sankey) using matplotlib; and an `extension` layer for integrating external tools like LDSC, PRS-CS, SuSiE, and GWAS Catalog API. The CLI (`gwaslab_cli`) exposes subcommands for all major workflows. External dependencies include `pysam`, `polars`, `pyarrow`, `h5py`, `adjustText`, and system tools (`bcftools`, `plink`, `R`). The library is actively developed with extensive test coverage (200+ test files) and bundled reference data for HapMap3, chain files, and cytoband annotations.
FeedCraft is a self-hosted feed processing service that transforms raw sources (RSS, Atom, HTML, JSON, search results, inbox pushes) into customized RSS feeds through composable processing pipelines called 'crafts'. The system is a monolith Go backend with a Vue 3 admin dashboard, exposing REST APIs for feed ingestion, transformation (AI-powered translation, summarization, full-text extraction, filtering), and aggregation into 'topic feeds'. The architecture follows a clean separation of concerns: source fetching/parsing, craft processing (atomic operations and flows), engine runtime, and administrative controllers. External dependencies include SQLite/PostgreSQL, Redis, an OpenAI-compatible LLM, a browserless service for dynamic content, and optional embedding APIs for semantic filtering. The codebase demonstrates solid engineering with interfaces for sources, parsers, crafts, and caching, though it carries some migration complexity from legacy craft models to newer ones.
Debug-gym is a framework for developing and evaluating AI agents that perform interactive debugging of software. It provides a Gymnasium-inspired environment where agents can use tools like a debugger (pdb), file viewer, editor, and shell to inspect and modify code in order to fix bugs. The framework supports multiple execution backends (local, Docker, Kubernetes) to ensure isolation and reproducibility, and integrates with various LLM providers through a unified interface. The system is designed around a loop of observation, action, and feedback: the agent observes the current state (e.g., code, test output), selects a tool to apply (e.g., set a breakpoint, edit a file), and receives the outcome from the environment. This enables the creation of agents that can learn to debug or be evaluated on debugging benchmarks such as SWE-Bench and Mini-Nightmare. The framework also includes analysis tools for visualizing agent trajectories and logging experiment results, supporting both development and research use cases. Key architectural features include a plugin-based tool system, abstract terminal and LLM interfaces, and a secure workspace for code manipulation. These components are designed to be modular and extensible, allowing researchers and developers to plug in new tools, environments, or language models with minimal changes to the core loop.
This repository is a Spotify client web application that helps users track new releases from artists they follow. It provides a progressive web app (PWA) experience with offline support, allowing users to view, filter, and favorite releases grouped by date. Users can export their release list to CSV or create/update a Spotify playlist with selected tracks. The application handles Spotify authentication via OAuth 2.0 PKCE flow, fetches data from the Spotify Web API, and persists state locally using localForage. Built with React, Redux Toolkit for state management, and Redux Saga for side effects, the app features a modular architecture with reusable UI components, filtering system, and settings management.
This repository is a research fork of Meta's Habitat-Sim, extended with 3D Gaussian Splatting (3DGS) for photo-realistic rendering in embodied AI navigation tasks. It provides a full simulation platform with physics (Bullet), sensors (RGB, depth, semantic, fisheye), navigation meshes, and a CUDA-accelerated Gaussian splatting rasterizer supporting dynamic avatars. The codebase includes training and evaluation pipelines for PointNav, ImageNav, ObjectNav, Vision-Language Navigation (StreamVLN, Uni-NaVid), and dynamic avatar avoidance. It also contains an LLM-driven agent system (HabitatAgent) with a bridge API, MCP server, and TUI for interactive navigation. The repository is hybrid: primarily a research platform for embodied AI experiments, but also includes application-like components such as web tools (navmesh editor, object annotation helper), a real-time Rerun viewer, and a conda packaging system. The core C++ simulator is well-architected with managed object patterns, replay recording, and PBR rendering, while the Python layer provides episode generation, prompt-based agent control, and analytics dashboards. Data assets (GS scenes, avatars, checkpoints) are hosted externally on Hugging Face, and the setup requires multiple conda environments for different tasks.
This is a desktop application built with Go and the Fyne GUI framework that manages updates for portable Chrome installations and Chrome++ (a Chrome enhancement tool). It provides a graphical interface to check for the latest Chrome versions across stable, beta, dev, and canary branches, download them using a multi-threaded downloader with resume support, and extract 7z archives. It also supports updating Chrome++ from GitHub releases, system tray integration with auto-update scheduling, proxy configuration, and localization (English/Chinese). The application communicates with Google's Omaha update protocol (via XML requests to tools.google.com) and a custom web service (chrome.noki.eu.org) to fetch version information. The codebase demonstrates solid engineering practices including data binding, concurrent downloads, and a clean i18n system using embedded TOML files.
Parakeet.cpp is a high-performance speech recognition inference library for NVIDIA's Parakeet model family (TDT-CTC, RNNT, Streaming EOU, Nemotron, Sortformer), written in C++ with C bindings. It provides offline and streaming transcription, speaker diarization, voice activity detection (VAD), beam search with optional n-gram language model fusion, phrase boosting, and timestamp extraction. The library is built on the axiom tensor library with Metal GPU acceleration for Apple Silicon, and supports audio input from WAV, FLAC, MP3, and OGG formats. The codebase includes a CLI tool, a Unix domain socket server example, and a rich set of examples covering all major features. While primarily an application/library for production ASR inference, it also contains research-oriented model conversion scripts (NeMo to safetensors) and a benchmark script comparing with PyTorch inference, giving it a hybrid character. The architecture is cleanly modular, with separate modules for audio I/O, VAD, model encoders/decoders, and decoding algorithms. The C API enables binding to Python, Swift, Rust, and other languages. Documentation and build system are well-maintained, and the repository is actively developed with recent commits.
graph_weather is a research-oriented deep learning library for weather forecasting with graph neural networks. It implements multiple model families—GraphCast-inspired encoder/processor/decoder models, the diffusion-based GenCast and GenDA, the ensemble FGN, WeatherMesh, Aurora, FengWu-GHR, and CaFA—along with a substantial set of data loaders, loss functions, training scripts, and evaluation utilities. The package is structured as a Python library with HuggingFace Hub model integration, PyTorch Lightning training support, and a comprehensive test suite, giving it a hybrid character: it is fundamentally research code, but packaged and tested with application-grade discipline. Entry points include GraphWeatherForecaster, GraphWeatherAssimilator, WeatherStationReader, and various dataset classes, while training scripts live under train/.
Vue Cal is a full-featured Vue 3 calendar component library with zero external dependencies beyond Vue itself. It provides multiple views (day, week, month, year, years), event management (create, edit, delete, drag-and-drop, resize), schedules, special hours, extensive localization (50+ languages), dark/light theme via CSS variables, and comprehensive slot-based customization. The library is built entirely with the Composition API and is structured around core composables: `useVueCal` (main state), `useConfig` (prop parsing, locale loading), `useEvents` (event normalization, indexing, overlap detection), `useView` (navigation, cell generation), and `useDragAndDrop` (native HTML5 DnD with cross-instance support). The primary entry point is `src/vue-cal/index.js`, which exports the `VueCal` component, `useLocale` function, and a set of optional Date prototype extensions. Events are passed as an array of objects and reactively rendered; all interactions emit Vue events enriched with context (cell info, cursor position). The library is in active pre-release (v5.0.1-rc.46) with a stable release pending timezone support.
tremc is a console-based client for the Transmission BitTorrent daemon that provides a curses interface for monitoring and controlling torrents. It connects to Transmission via its RPC protocol, offering features like torrent listing with sorting/filtering, detailed torrent views (files, peers, trackers), bandwidth control, and torrent management operations. The architecture follows a modular design with separate components for configuration handling, Transmission RPC communication, and the curses-based user interface. Key entry points include the main tremc executable and the ability to forward arguments to transmission-remote. The application maintains local caches of torrent state that are periodically updated from the daemon, with user interactions triggering RPC calls to control the daemon.