PyRanges (version 0, legacy) is a Python library for genomic interval operations, analogous to Bioconductor's GenomicRanges. It provides a comprehensive set of tools for manipulating, comparing, and analyzing genomic intervals and annotations. The library supports reading and writing common bioinformatics file formats (BED, GTF, GFF3, BAM, BigWig), and implements a wide range of operations including merging, intersection, subtraction, join, nearest neighbor, clustering, coverage, and statistical methods like Jaccard and Fisher exact. Internally, PyRanges represents intervals as a dictionary of pandas DataFrames keyed by chromosome and optionally strand. This design enables efficient per-chromosome parallelism and easy integration with the Python data science stack. Operations are implemented as modular functions in separate files under the `methods/` directory, each accepting a DataFrame and keyword arguments from a central dispatcher. The library also provides a parallel execution framework using Ray via `pyrange_apply` and related functions, allowing users to apply custom functions to each chromosome/strand group in parallel. Although primarily a software library, this repository has a strong research character: it includes built-in example datasets (e.g., ChIP-seq peaks, CpG islands, Ensembl annotations), a bookdown tutorial with executable R Markdown, property-based tests that compare results against the bedtools suite, and statistical methods designed for colocalization and annotation enrichment. This makes it equally valuable as a research tool for bioinformatics analysis. Maintenance note: This is the legacy version 0 of PyRanges, superseded by a redesigned version 1 (pyranges1). Despite the deprecation, the codebase is mature, well-tested, and still functional. The design patterns (modular operations, per-chromosome dispatch, property-based testing against a reference tool) are noteworthy and could be reused in other bioinformatics and data engineering projects.
This repository is a sample Spring Boot application that demonstrates custom JWT token-based authentication for protecting RESTful APIs. It provides a vehicle CRUD API (via both a custom controller and Spring Data REST), a user authentication endpoint (/auth/signin), and a user info endpoint (/me). The architecture follows a standard Spring Boot monolith with Spring Security, Spring Data JPA, and Spring HATEOAS. The custom JWT implementation is encapsulated in a JwtTokenProvider and a JwtTokenAuthenticationFilter, which extract, validate, and set authentication from JWTs. The codebase is modern, using Spring Boot 3.x, Jakarta EE, Java 21, and the latest JJWT library. It includes unit tests, integration tests, and a docker-compose file for PostgreSQL. While the core functionality is straightforward and typical for such samples, the separation of JWT logic into reusable components and the use of Spring Boot 3.x best practices make it a solid reference implementation. It is primarily an application with no data research elements.
This repository is the canonical archive of Markdown transcripts for the Changelog podcast network, which includes shows like Changelog News, JS Party, Go Time, Practical AI, and The Changelog. Its primary function is to store, standardize, and publish the textual record of these conversations, serving as a searchable knowledge base and the source of truth for show notes and content distribution. The data flows from raw audio recordings into human-curated Markdown files, which are then automatically normalized by a formatting pipeline. The architecture is a static data repository augmented with a lightweight ETL pipeline. The core transformation logic lives in `scripts/format.js`, which applies a series of regex replacements to enforce consistent formatting (e.g., standardizing product names, timestamps, and punctuation). A GitHub Actions workflow runs this formatter on every push to the master branch, ensuring the entire dataset remains uniform without manual effort. The repository is organized by show directory (e.g., `news/`, `gotime/`, `practicalai/`), with each file representing a single episode. The standout reusable asset is the `applyReplaces()` function in `scripts/format.js`, which implements a clean, extensible text normalization pipeline that can be extracted for any project requiring consistent text cleaning. The repository is highly reproducible: all data is bundled within the repo, dependencies are pinned via `package-lock.json`, and the environment is explicitly defined. The primary technical drift risk is the CI pipeline's reliance on Node.js 14.x, which is long past its end-of-life, though the simplicity of the scripts makes a migration straightforward.
react-dropdown-tree-select is a React component library that provides a dropdown interface for selecting items from hierarchical tree data. The component supports multiple selection modes (multi-select, simple select, radio select, and hierarchical), displays selected items as tags/pills, includes search functionality with progressive filtering and debouncing, offers keyboard navigation, and implements accessibility features through ARIA attributes. The architecture centers around a DropdownTreeSelect component that uses a TreeManager to handle tree state and operations, with supporting components for rendering trees, nodes, tags, and controls. Performance optimizations include virtualized rendering via react-infinite-scroll-component, search debouncing, and progressive filtering that reduces search scope with each keystroke.
callx is a Node.js CLI tool that serves as a unified runtime switcher and configuration manager for AI coding assistants like Claude Code and OpenCode. It allows users to define multiple AI 'sprites' (agent configurations) with different providers, models, skills, and MCP servers, all managed through a single `~/.config/callx` directory. The system provides two entry points: the `call` command for quick invocation of sprites, and `callcli`, a full-featured TUI built with Ink and React for managing providers, sprites, skills, MCP servers, and git worktrees. The architecture is a monolith CLI application with a clear separation between runtime utilities (`lib/runtime.js`), git worktree helpers (`lib/worktree.js`), and the TUI frontend (`lib/callcli/app.mjs`). The runtime module handles all configuration file I/O, provider normalization, skill syncing via symlinks, and MCP server configuration generation for both Claude Code and OpenCode formats. The TUI provides a Monokai-themed interface with list-based navigation, field-level editing, and multi-select for skills and MCP servers. Key data flows include: reading `providers.json` for API keys and endpoints, reading sprite `config.json` for CLI type and model selection, syncing skill packs from `skillpacks/` to sprite-specific `skills/` directories via symlinks, and generating MCP configuration files from `mcpservers/` definitions. The tool also integrates with git worktrees, providing an interactive flow to create new branches and worktrees with suggested naming conventions. External dependencies are minimal: Node.js 18+, Ink and React for the TUI, and the target AI CLI tools (opencode-ai, @anthropic-ai/claude-code).
AgentSkillsHub is a production full-stack web application: a security-graded, quality-scored directory of 117,000+ open-source AI agent skills, MCP servers, and agent tools, served from a React/TypeScript SPA with a Python FastAPI service layer and Supabase/PostgreSQL backend. Every 8 hours a GitHub Actions sync pipeline searches GitHub, enriches repo metadata, fetches READMEs, cleans and deduplicates, applies an 8-9 dimension quality score, and grades security into safe/caution/unsafe/reject/unknown tiers via a heavily-tuned rule-based scanner with an optional LLM pass. The frontend exposes search, filtering, compare, favorites, i18n (zh/en), static pre-rendered SEO pages, an admin panel, monetized Pro search, enterprise audit lead capture, and a verified newsletter flow. The public API (FastAPI plus Supabase RPCs) backs the SPA, using request deduplication, aggressive column minimization, and materialized cache tables to survive the load. The repo is application-dominant but genuinely hybrid with data research. An ops/ engine room runs controlled benchmark harnesses (PPT, video, guard-hooks, code review, anti-slop, Obsidian, skill managers) that execute third-party skills in Docker sandboxes, capture transcripts, judge outputs with LLM models under majority voting against ground-truth fixtures, and publish public evidence pages. A radar subsystem monitors X, Hugging Face, the App Store, and social memes to discover emerging tool terms with cost-budgeted API calls. The security scanner rule history and adjudication datasets (reported Jev-judge AUC 0.916 against labeled flag instances) read like an ML calibration project, and the SEO research folder contains extensive keyword, SERP, and competitor studies. Reusable high points: the log-normalized scoring engine, the README security scanner with citation-vs-issue disambiguation, the keyset-paginated batch-commit ETL pattern, the paced idempotent backfill queue, the request-collapsing SPA data layer, and an OpenAI-compatible sandbox image proxy for benchmarking agent skills without leaking API keys. The core pipeline is professionally tested (20+ unit test files, mostly pure-logic tests that run without a database). Caveats: it is effectively a single-maintainer operation with hardcoded personal paths, an admin token seeded in a committed migration, duplicate backend/migrations and supabase/migrations that can drift, many one-off ops scripts with duplicated env-reading code, and future-dated 2026 content plus hardcoded fallback data that can confuse. Despite the sprawl, the engineering discipline around the scanner, batch processing, rate-limit resilience, and RLS-based database security is well above typical directory-site quality.
This repository is a monorepo of 'skills' for the Minis AI assistant platform, designed to extend the assistant's capabilities with domain-specific workflows, API integrations, and automation scripts. Each skill is a self-contained directory with a SKILL.md (instruction set for the AI), executable scripts (Python/shell), reference documentation, and evaluation test cases. The skills cover a wide range of tasks: social media management (Weibo, Twitter/X, Xiaohongshu, Telegram, Bilibili), media processing (YouTube downloader, PDF conversion, TTS, image generation), financial data retrieval (US/Korea/China stocks, fund flows), productivity (Notion API, todoocard e-paper, whenpeak energy prediction), video composition (HyperFrames framework), and system utilities (Android dev environment, Cloudflare DNS, qBittorrent). The architecture is modular and agent-driven: the AI selects a skill based on user intent, reads its SKILL.md, and invokes the provided scripts via shell_execute. Output is typically JSON for machine consumption. The codebase demonstrates strong engineering practices with structured skill definitions, evaluation frameworks, and reusable patterns like cookie-based auth, SQLite message stores, and deterministic animation analysis. However, many skills depend on reverse-engineered or unofficial APIs, hardcoded paths tied to the Minis iOS environment, and external tools (ffmpeg, pandoc, typst), introducing maintenance and portability risks.
BatteryRecorder is an Android application for precise battery power recording and battery life prediction. It consists of a main app module with Jetpack Compose UI and a native server daemon that reads battery data directly from sysfs and dumpsys via JNI. The architecture follows a multi-module structure (app, server, shared) with AIDL-based IPC between the app and the privileged background server. The app provides real-time monitoring, historical charts, per-app and per-scenario battery endurance predictions, calibration settings, and export/import capabilities. It is a sophisticated tool aimed at power users and developers, but it relies on device-specific sysfs paths and hidden Android APIs, making it fragile across different devices and Android versions. The codebase demonstrates solid use of modern Android patterns (ViewModel, StateFlow, UseCase, Repository) and custom Compose components, though it lacks automated tests and has mixed-language documentation.
ghtkn is a Go CLI and local agent daemon that obtains short-lived GitHub App User Access Tokens via the OAuth device flow, replacing long-lived PATs and CLI OAuth tokens. The Cobra-based CLI exposes commands such as init, auth, get, exec, git-credential, revoke, agent start/stop/lock/unlock/status/reset, info, docs, json-schema, and completion. The agent runs as a background daemon and speaks a JSON-lines protocol over a local socket with GET, SET, UNLOCK, STATUS, and STOP commands. Tokens are stored encrypted at rest using AES-256-GCM with an Argon2id-derived key-encryption key, one file per client ID with 0600 permissions and atomic writes.
This repository is an interactive 3D biology teaching application built with React, TypeScript, Vite, and three.js. It allows users to explore detailed models of biological structures (plant cell, animal cell, white blood cell, neuron, DNA) with rotation, zoom, and informational overlays. The application features a custom model loading system that prioritizes the initially displayed model and preloads others in the background to optimize bandwidth usage. The UI consists of a sidebar for model selection, a central 3D viewing area, and an information panel detailing each model's characteristics. The code demonstrates thoughtful engineering in resource loading, state management, and responsive design, making it suitable for educational contexts.
Twilight is a highly customizable, production-ready static blog template built with Astro, Svelte, and Tailwind CSS. It generates a full-featured personal website with posts, diaries, albums, projects, skills, timelines, and friend links, all managed via content collections or headless CMS (Decap). The template includes a rich set of interactive features: client-side search (Pagefind), a built-in music player with LRC lyrics and Meting API integration, a Live2D mascot (Pio), page transitions (Swup), multiple comment systems (Waline, Twikoo), analytics (Umami), and i18n with 4 UI languages. It also offers advanced markdown processing with custom remark/rehype plugins for admonitions, mermaid diagrams, music cards, GitHub cards, and reading time. The architecture is configuration-driven (twilight.config.yaml), with a modular component system (Astro for static, Svelte for interactivity) and a sidebar widget manager. Production deployment is via Docker or adapters for Vercel, Cloudflare, Netlify, and EdgeOne. While the template is robust and feature-rich, it carries some technical debt from legacy Live2D assets and a mix of CSS paradigms (Tailwind + Stylus) that may complicate long-term maintenance.
AppFlowy-Web is a feature-rich collaborative workspace application built with React, TypeScript, and Yjs (CRDT). It provides real-time collaborative document editing via a Slate-based editor, multiple database views (grid, board, calendar, gallery, list, timeline, feed, chart), AI-powered writing assistance and chat, publishing/sharing capabilities, and workspace management. The application is designed as an open-source alternative to Notion, supporting both cloud-hosted and self-hosted deployments. The architecture is a single-page application with Yjs as the core data model for offline-first collaboration, backed by IndexedDB caching and REST/WebSocket APIs. The codebase is extensive (4000+ files) with comprehensive unit and E2E tests, but exhibits moderate technical drift due to mixed UI paradigms (MUI + Radix), complex Yjs observer lifecycle management, and some deprecated environment variable mappings.
DeepOnto is a Python package for ontology engineering with deep learning, centered on ontology alignment (BERTMap) and subsumption inference (BERTSubs, OntoLAMA). It wraps the OWLAPI Java library through JPype to load, query, reason over, and prune OWL ontologies, and uses PyTorch/Hugging Face Transformers to train or apply BERT-based classifiers for mapping prediction and refinement. The package exposes config-driven pipelines (BERTMapPipeline, BERTSubs pipelines, OntoLAMA inference) plus evaluation utilities for OAEI-style benchmarks.
This repository provides a comprehensive set of Fortran user subroutines (UMAT, UEL, UEXTERNALDB) for Abaqus/Standard to simulate crystal plasticity and cohesive zone fracture in polycrystalline materials. Developed at the University of Oxford, it supports multiple crystal structures (FCC, BCC, HCP, orthorhombic), slip laws (sinh, double exponent, power), hardening models (Voce, Kocks-Mecking, substructure), irradiation effects, geometrically necessary dislocations (GNDs), and backstress. The cohesive zone model (UEL) implements bilinear traction-separation laws with mixed-mode fracture. Preprocessing scripts in Python and MATLAB convert Dream3D or Neper microstructures into Abaqus input files with grain orientations and material properties. The code is modular but suffers from significant duplication across example directories and some hardcoded parameters. It is actively maintained with a detailed changelog up to v3.4 (August 2026). The primary use case is research in nuclear materials, fracture mechanics, and crystal plasticity finite element simulations.
libspatialaudio is a C++ library for immersive spatial audio rendering, implementing Higher Order Ambisonics (HOA) up to 3rd order, object-based audio, direct speakers, and binaural output. It follows the ITU-R BS.2127-1 Audio Definition Model (ADM) and AOM IAMF specifications. The library is used in production media players like VLC for 360° video and virtual reality audio. The architecture is modular: a central `Renderer` class orchestrates per-processing blocks for encoding, decoding, rotation, zoom, binauralization, and metadata-driven panning. The codebase is cross-platform (CMake/Meson) and includes unit tests, but some components (e.g., HRTF data, psychoacoustic filters) rely on precomputed data generated by Octave scripts. While not bleeding-edge, the library is solid, well-documented, and suitable for real-time audio applications.
This repository is a full-stack web application that syncs WhatsApp profile pictures into Google Contacts. A user authorizes WhatsApp Web by scanning a QR code (whatsapp-web.js + Puppeteer/Chromium) and authorizes Google via OAuth2 against the People API. The backend then lists Google contacts, loads WhatsApp contacts, matches them by phone number, downloads the WhatsApp profile picture, rate-limits writes to 1 per 1.5 seconds, and updates contact photos through the People API. It also includes an optional Buy Me a Coffee purchase gate: paid emails are checked against Buy Me a Coffee's API and bound to a WhatsApp account ID in Redis for 31 days.
Ham Dashboard is a browser-based web application that displays configurable content in a grid layout. It supports images (with rotation), videos, iframes (web pages), and RSS feeds. The application is built with vanilla JavaScript, HTML, and CSS, requiring no backend or build process. Configuration can be loaded from localStorage, config.js, config.json, or other JS/JSON files via URL parameters or file picker. Key features include a settings UI for configuration, full-screen viewing, right-click to rotate content, double-click to zoom, automatic content refresh, and breadcrumb-aware navigation between different dashboard configurations. The application is designed to be lightweight and easily hostable on static platforms like GitHub Pages or Cloudflare Pages.
The fortitudo.tech repository is a Python library for quantitative finance, providing implementations of Entropy Pooling (including Sequential EP), Conditional Value-at-Risk (CVaR) and Mean-Variance portfolio optimization, Fully Flexible Resampling (FFR) simulation, option pricing, and risk metrics. It is structured as a modular package under the `fortitudo.tech` namespace with well-defined entry points in `__init__.py`. The library is designed for advanced financial analysts and researchers, supporting scenario-based stress testing and portfolio construction. It includes bundled synthetic datasets (time series, risk factors, P&L) and a suite of example Jupyter notebooks that replicate published research and demonstrate practical workflows. While the core library is installable via pip/conda and has 100% test coverage, it deliberately minimizes input validation (targeting expert users) and exposes a global mutable configuration object (`cvar_options`). The repository also serves as a marketing conduit for proprietary Fortitudo products, with links to paid courses and institutional demos. Overall, it is a solid, well-crafted open-source library with reusable optimization and simulation patterns, albeit with some architectural warts (global state, minimal validation) and a strong research/educational flavor.
PECmd (Prefetch Explorer Command Line) is the de facto standard DFIR tool for parsing Windows prefetch (.pf) files. It extracts the executable name, hash, run count and last-run timestamps, volume information, and directory/file references from every prefetch version including XPress/Huffman-compressed Windows 10/11 files, and renders results to the console, CSV (a per-file report plus a per-run timeline), JSON (one object per file, ISO 8601 UTC timestamps), or XHTML. Beyond basic parsing it can process Volume Shadow Copies (--vss via the ERZHelpers library's VSS mounting), scan NTFS alternate data streams for prefetch data hidden by ADS-executed binaries (--ads, including the empty-primary-stream edge case), deduplicate inputs by SHA-1, and save decompressed raw bytes (-o). The parsing core itself lives in the separate Prefetch NuGet package; this repository is the operational shell handling CLI parsing, file enumeration, VSS/ADS orchestration, error resilience, and all export formats. Architecture-wise this is a single C# project multi-targeting net472 and net10.0, built around one monolithic Program.cs (~1500 lines) that owns argument handling (System.CommandLine), recursive file discovery (AlphaFS on net472, a custom FileSystemEnumerator on modern .NET), export serialization (CsvHelper, ServiceStack.Text, XmlTextWriter), and Serilog console/file logging. The code is pragmatic and battle-tested rather than architecturally elegant: static mutable state (shared keyword set, failed-file list, processed-file list) and a god-file style limit modularity and testability (the project explicitly has no tests). What it lacks in structure it makes up for in domain rigor: read errors (access denied, locked files) are carefully distinguished from parse errors (damaged files reported but exit code 0; unreadable input yields exit code 1), unreadable folders are surfaced instead of silently skipped, and the Windows 10+ prefetch hash-validation quirk is handled with real forensic depth. Highlighted reusable logic: ExecutablePathResolver, a cleanly isolated component that resolves an executable's full path from prefetch file references and validates it against the file's hash — including iterating \DEVICE\HARDDISKVOLUME{n} candidates because Windows 10+ stores volume-GUID paths but hashes the native device path. Also notable is the private EntryFinder, a FileSystemEnumerator subclass that captures per-folder read errors during recursive walks without aborting — a genuinely non-obvious pattern worth extracting for any resilient file-walking tool. Maintenance is active (2026.10.3, embedded PDBs for deterministic stack traces, Exceptionless telemetry, SmartAssembly-protected release pipeline) and the README/CLAUDE.md documentation is unusually precise about intentional engineering trade-offs.
WFInfo is a Windows desktop companion application for the game Warframe, built with WPF (.NET Framework 4.8). It uses OCR (Tesseract) to scan in-game reward screens, inventory items (SnapIt), and profile screens, then looks up real-time platinum and ducat prices from warframe.market. The architecture follows a service-oriented pattern with dependency injection (Microsoft.Extensions.DependencyInjection) for screenshot capture (GDI or Windows Graphics Capture), window information, HDR detection, and process finding. Key features include auto-detection of fissure rewards via Warframe's log file, a configurable overlay for price display, warframe.market listing management, language-specific text normalization (11+ locales), and a theme adjuster for OCR filtering. The application is Windows-only and tightly integrated with game UI, making it highly specialized but well-architected within its domain.