The academic-skills repository is a collection of prompt engineering assets designed to assist with academic research workflows when used with large language models like ChatGPT. It provides eight distinct skills, each encapsulated in a self-contained directory containing a skill description (SKILL.md), platform-specific metadata (agents/openai.yaml), and optional reference templates or scripts. The skills cover tasks such as reading and noting papers, writing literature surveys, monitoring arXiv for new publications, analyzing reviewer comments, summarizing experiment logs, extracting benchmark information, identifying research gaps, and generating weekly lab updates. The repository emphasizes reliability and reproducibility by constraining LLM outputs to avoid hallucination, providing clear input processing rules, and offering structured templates for consistent results. One skill (paper-feishu-digest) includes a deterministic Python script for fetching and filtering arXiv papers, demonstrating a hybrid approach that combines LLM assistance with traditional data processing. Additional tools for validating the repository structure and packaging skills for distribution are included, all written using only the Python standard library to minimize dependencies. The codebase exhibits strong modularity, with each skill following a uniform structure that facilitates maintenance and extension. The arxiv_digest.py script stands out as a reusable component for arXiv data processing, featuring robust error handling, keyword-based ranking, and conservative inference of paper contributions and limitations from abstracts. Overall, the repository represents a well-crafted toolkit for enhancing academic productivity through LLM augmentation, balancing prompt engineering with selective use of deterministic scripts where appropriate.
wsldl is a Go CLI tool for managing Windows Subsystem for Linux (WSL) distributions. It serves as an advanced launcher and installer that can install distributions from rootfs tarballs or ext4 VHDX images, including HTTP download with caching, resumption, and SHA-256 verification. The tool provides subcommands for running commands in the WSL instance (with optional Windows-to-WSL path translation), backing up (tar, ext4 VHDX, registry export), cleaning (unregistering), configuring settings (default user, WSL version, terminal type, mount flags), and querying configuration values. It also integrates with Windows Terminal and Fluent Terminal as default terminals. The architecture follows a clean CLI monolith pattern in Go, with each subcommand implemented as a module using dependency injection for testability. The WSL and registry APIs are abstracted behind interfaces, allowing comprehensive unit tests via mock implementations on non-Windows platforms. Library packages for HTTP download, file operations (including transparent gzip), Windows console API, Windows Terminal configuration parsing, and CLI error handling are well-isolated and potentially reusable in other projects. While the core functionality is tightly coupled to Windows and WSL, the codebase demonstrates strong engineering practices: comprehensive test coverage, clear separation of concerns, proper error handling, and maintainable build infrastructure (Go modules, cross-compilation, CI/CD with GitHub Actions). The project is actively maintained with frequent commits and responsive issue triage.
Episteme is a modern, cross-platform e-book and document reader built with Kotlin Multiplatform and Compose Multiplatform. It supports a wide array of formats including EPUB, PDF, MOBI, audiobooks (M4B), FB2, DOCX, ODT, PPTX, and comic archives (CBZ/CBR). The app offers a rich reading experience with paginated and vertical scroll modes, text-to-speech, ink and text annotations, OPDS catalog browsing, cloud sync via Google Drive and Firestore, AI-powered summarization, and extensive customization (themes, fonts, brightness). The codebase is organized into a shared module containing core business logic, models, and policies, with platform-specific implementations for Android (native Compose, Room, WorkManager), iOS (Swift), and Desktop (Compose Desktop, Swing interop). The architecture follows a clean separation of concerns with expect/actual abstractions for platform services, making it a strong example of production-ready KMP application design.
Mintlify's @mintlify/mdx is a thin TypeScript library that wraps next-mdx-remote-client to provide a simplified MDX rendering experience for Next.js applications. It adds rich syntax highlighting via Shiki, including support for language-specific highlighting, line highlights, diffs, and twoslash-powered TypeScript type hover popups. The library exposes three main APIs: `serialize` (server-side compilation), `MDXClient` (client-side rendering), and `MDXRemote` (RSC component that combines both). It includes pre-configured remark plugins (GFM, Smartypants, Math) and rehype plugins (Katex, syntax highlighting) with the ability to extend with custom plugins. The package also provides UI components for twoslash popups and a Shiki transformer for shell placeholder highlighting. The codebase is well-structured with clear separation of concerns, though test coverage is limited to the shell placeholder transformer.
WhiteSur Icon Theme is a comprehensive SVG icon set for Linux desktop environments (GNOME, KDE, XFCE, Budgie, etc.) that emulates the macOS Big Sur visual style. It provides over 28,000 icons covering applications, devices, places, status indicators, mime types, and more, organized into multiple sizes (16, 22, 24, 32, scalable) and color variants (default, light, dark, and accent colors). The repository includes a well-structured Bash installer script (install.sh) that copies icons to the user's icon directory, creates symlinks for HiDPI scaling, and supports optional bold panel icons, alternative icons, and KDE Plasma logo replacement. The theme is actively maintained with a large community following. While not a software application in the traditional sense, it is a high-quality design asset pack with a robust installation mechanism.
Serie is a Rust terminal user interface (TUI) application that renders git commit history graphs using terminal image protocols (iTerm2, Kitty, Kitty Unicode). It provides a rich, interactive commit graph viewer with features like commit detail view, refs tree, user-defined commands, search, and customizable keybindings. The application is designed as a focused git log/graph viewer, not a full git client. The architecture is event-driven with a main loop managing multiple views (commit list, detail, refs, help, user command). It uses a custom graph layout algorithm to compute commit positions and edges, then renders each graph row as a PNG image via the `image` crate, which is uploaded to the terminal using the appropriate image protocol. The UI is built with `ratatui` and `crossterm`. Key components include a sophisticated graph rendering pipeline with antialiasing support, a flexible keybinding system with conflict detection, a configuration system with schema validation, and an event system with background input handling. The codebase demonstrates strong Rust craftsmanship with clean abstractions, extensive snapshot testing for graph rendering, and careful state management for view refresh. While the application is primarily a practical tool for developers, its graph layout algorithm and antialiased image rendering modules contain non-obvious algorithmic work that could be extracted for other terminal graphics projects. The codebase is actively maintained with CI/CD pipelines, documentation, and release automation.
This repository serves as the central hub for the W3C Positive Work Environment Community Group, which maintains and evolves the W3C Code of Ethics and Professional Conduct (now referred to as the Code of Conduct). The system consists of static HTML documents (some using ReSpec for technical report formatting), Markdown files, presentation templates, and educational resources. Key functions include: maintaining the Code of Conduct document and its update procedures; documenting dispute resolution processes including mediation, investigations, and disciplinary actions; describing the Ombudsperson program; providing meeting facilitation training materials (Running Better Meetings guides); managing inclusion fund proposals and communications; and offering multilingual versions of core documents. The architecture is a static document repository with presentation layers powered by Shower.js and custom CSS frameworks. External dependencies include ReSpec for document formatting and Shower.js for slide presentations, both loaded from W3C domains.
DSInternals is a comprehensive .NET library and PowerShell module for Active Directory security auditing, forensic analysis, and offline/in-place manipulation of AD databases. It provides the ability to extract password hashes (NT, LM, Kerberos), decrypt DPAPI backup keys, recover LAPS and gMSA secrets, parse FIDO2/Windows Hello key credentials, and query DNS zones and signing keys. The library supports multiple access modes: offline via ESENT/ISAM (ntds.dit), online via RPC replication (DRSR), LDAP/ADSI, and SAM/LSA native APIs. The PowerShell module exposes over 50 cmdlets organized into logical groups (ADDB, ADRepl, ADSI, LSA, SAM, Hash, Encryption). The codebase is heavily oriented toward reverse-engineering of Microsoft's internal AD structures and protocols, with extensive unit tests using real-world binary vectors. While the primary use case is security auditing (e.g., penetration testing, incident response), the library also provides utilities for password quality testing, domain controller recovery, and offline account modifications. The architecture is modular, with clear separation between common data models, data store access, replication, and PowerShell cmdlets, making it a robust toolkit for Windows domain administrators and security professionals.
EveBox is a full-stack security event management system for Suricata EVE JSON logs. It provides a Rust backend (Axum, SQLx, Tokio) with a SolidJS/TypeScript web frontend, supporting both Elasticsearch/OpenSearch and embedded SQLite datastores. The system ingests Suricata EVE logs via file spool, Unix socket, or remote agent, and offers real-time dashboards, alert aggregation, PCAP extraction, file analysis, and agent management. It includes a CLI with subcommands for server, agent, oneshot processing, PCAP operations, and backend administration. The architecture is modular: an EventRepo trait abstracts datastore operations, a filter chain processes events during ingestion, and a query parser converts user search syntax into backend-specific filters. The agent subsystem uses a persistent WebSocket control channel for remote event submission, PCAP capture, and file retrieval. The frontend is a single-page application with dashboards for alerts, DNS, TLS, HTTP, SSH, DHCP, and anomalies, using Chart.js for visualizations and Server-Sent Events for live updates. While primarily an application, EveBox also exhibits data-processing characteristics: it transforms raw EVE JSON into structured events, enriches them with GeoIP and rule metadata, and supports aggregation and search across large event sets. However, its core purpose is operational security monitoring rather than data analysis or research.
This repository implements the Adaptive Cards specification, a JSON-based interactive card format developed by Microsoft. The system provides a cross-platform SDK for parsing, rendering, and interacting with adaptive card payloads. The core is a shared C++ object model that defines all card elements (TextBlock, Image, Container, Column, Table, Inputs, Actions, etc.) and handles JSON serialization/deserialization, schema versioning, fallback, and ID collision detection. Platform-specific renderers for Android (Java/SWIG), iOS (Objective-C), .NET (WPF), UWP (C++/WinRT), and Node.js (TypeScript) convert the parsed card model into native UI components. The architecture is a library with multiple language bindings, not a monolithic application. Key entry points include the AdaptiveCard class for parsing, platform-specific renderer classes (AdaptiveCardRenderer), and registration systems for custom elements/actions. The system also includes a designer tool (Node.js) for visually editing cards, a templating engine (ANTLR-based) for dynamic card generation, and a markdown rendering pipeline (MarkedNet). External dependencies include JSON libraries (Newtonsoft.Json, etc.), markdown parsers (MarkedNet, markdown-it), SWIG for Java bindings, and ANTLR for templating. The codebase demonstrates strong engineering practices with clean abstractions (parser registration, renderer registration, host config), extensive unit and integration tests across platforms, and a consistent fallback mechanism. However, it shows signs of technical drift: multiple platform implementations may diverge in behavior, auto-generated SWIG code requires careful synchronization, and some deprecated properties and commented-out tests indicate legacy cruft. The project is actively maintained with CI pipelines and recent commits.
llama-benchy is a CLI tool for benchmarking OpenAI-compatible LLM endpoints, providing detailed performance metrics similar to llama-bench. It measures prompt processing and token generation speeds at various context depths, supports concurrent requests, prefix caching analysis, and multiple output formats. The tool features a modular architecture with separate modules for HTTP client logic, result processing, and progress reporting. It uses asynchronous HTTP requests to efficiently handle concurrent benchmarking and includes sophisticated logic for handling streaming responses, token timing reconstruction, and latency measurement. The tool is actively maintained with recent commits and up-to-date dependencies.
Whale Panel is a comprehensive admin dashboard system for managing X-UI panels with role-based access control (SuperAdmin and Admin roles). The application features a FastAPI backend with SQLite database, a React/TypeScript frontend, and a Telegram bot for VPN reseller functionality. It provides unified management of multiple panel types (3x-ui, Marzban, Guard, Tx-ui) including user management, traffic monitoring, and system statistics. The architecture follows a monolithic design with clear separation between API services, business logic, and presentation layers.
Muviz is a modern Android application built with Jetpack Compose that serves as a movie and TV show discovery client for the TMDB API. It follows a clean MVVM architecture with feature-based packaging, using Hilt for dependency injection, Retrofit for networking, Room for local favorites persistence, and the Paging 3 library for efficient data loading. The app provides a bottom-navigation interface with Home, Search, Favorites, and Account screens, supporting both movies and TV series with categories like trending, popular, upcoming, and top-rated. It includes a custom theme system with light, dark, system, and Material You options, and features animated UI components such as a vote average arc indicator and swipe-to-delete on favorites. The codebase is well-structured and uses modern Android development practices, though some screens (like cast details) are incomplete and there is some code duplication in ViewModels.
Notan is a cross-platform Rust framework for building interactive 2D applications and games. It provides a modular architecture with a core app lifecycle, graphics abstraction (OpenGL/WebGL via glow), input handling, audio (via oddio), asset loading, and an immediate-mode 2D draw API with automatic batching. The framework supports native desktop (winit/glutin) and web (wasm-bindgen) targets, with a plugin system for extensibility and an egui integration for immediate-mode GUI. The codebase is well-structured into ~20 crates, each with clear responsibilities, and includes a macro crate for ergonomic shader compilation and state management. Despite its polish, the project is in slow maintenance mode as stated in the README, with infrequent commits and some unfinished features (e.g., commented-out instanced image code, TODOs in graphics pipelines). The dependency versions are relatively recent (winit 0.30, egui 0.31, glow 0.16), but platform-specific workarounds and scattered `cfg` conditionals indicate potential drift. The extensive example suite demonstrates real-world usage patterns, from simple 2D games to 3D rendering with instancing and post-processing. The framework's strength lies in its clean separation of concerns: a backend trait for platform abstraction, a plugin lifecycle for modular features, and a draw API that abstracts batching and tessellation. The asset system with custom parsers and the compile-time shader macro are standout components. However, the project's maintenance status and some rough edges (e.g., debug assertions, manual keycode mappings) prevent it from being exceptional. It remains a solid choice for developers seeking a lightweight, portable Rust multimedia layer.
Hammer.js is a JavaScript library for detecting touch gestures in web applications. It provides a modular architecture with a Manager class that coordinates input handling (touch, mouse, pointer events) and gesture recognition (tap, double tap, press, pan, swipe, pinch, rotate). The library normalizes different input types into a consistent gesture recognition system, manages gesture lifecycle states, and handles touch-action CSS property polyfilling. It features an event-driven architecture where recognizers emit events when gestures are detected, which are forwarded to registered listeners. The library has no runtime dependencies, relying solely on standard web APIs.
This repository is the official Russian localization pack for the colony-sim game RimWorld, covering the base game (Core) and all major DLCs (Royalty, Ideology, Biotech, Anomaly) plus the third-party Odyssey content mod. It is predominantly a data repository: roughly 1,780 XML files in RimWorld's standard DefInjected/Keyed layout, where each entry overrides an English game string with a Russian translation and preserves the English source as an inline comment. The pack is the canonical Russian translation distributed with game updates, making it a hybrid asset — mostly localization data with a thin application layer of tooling and grammar code. The application layer is thin but purposeful. LanguageWorker_Russian.cs implements RimWorld's language-worker interface with Russian-specific grammar handling — pluralization (three plural forms), gender agreement, and case inflection backed by WordInfo data files. A GitHub Actions pipeline of eight Python scripts validates XML well-formedness, UTF-8/BOM encoding, dash formatting, gender-macro consistency, and reportString punctuation on every push, catching the class of copy-paste errors that plague large translation corpora. The translation data itself uses RimWorld's macro system ({PAWN_gender}, {lookup:...Case;...}) to produce grammatically correct Russian in dynamic game contexts, including procedural name generation via RulePackDef translations. The repository is actively maintained (last commit 2026-09-13) and tracks current game versions including the Anomaly DLC. Its most reusable assets are the CI validation scripts — encoding, XML, and gender-consistency checks applicable to any localization project — and the Russian grammar logic in the language worker. The XML corpus is project-specific but demonstrates a disciplined pattern for large-scale Slavic localization. Known weaknesses include occasional translation inconsistencies (e.g., copy-paste errors in drug-tolerance stage labels where 'large' is translated as 'medium') and the maintenance burden of tracking rapid game updates across six content areas.
Skill-kits is a local-first, single-binary desktop utility for managing AI agent skill directories across multiple coding agents (Codex, Claude Code, Gemini CLI, and custom agents). It operates by observing the filesystem: skills are directories containing a SKILL.md (or SKILL.md.disabled) file that agents read directly. The tool provides both a CLI (via clap) and a native GUI (via egui/eframe) that share a common core library. It does not move skills to the cloud, run a server, or require Node.js/Python runtimes. Architecturally, the system is a Rust monolith with three layers: a core library (src/core/) containing all business logic (agent space scanning, skill installation, project deployment, registry management, health checks, risk scanning), a CLI layer (src/cli/) for argument parsing and output formatting, and a GUI layer (src/gui/) for the desktop workbench. Persistent state is stored in TOML files under ~/.skill-kits/, including registries for managed skills, deployments, and a skill instance index cache. The system uses content hashing (SHA-256) for identity and drift detection, and atomic file writes for all state mutations. Key entry points include the CLI commands (status, scan, list, enable, disable, install, uninstall, doctor, adopt, project, plugin) and the GUI application launched with --gui. The core data flow involves scanning agent skill directories (global and project-level), building a normalized index of skill instances, comparing against managed copies and project deployments, and presenting the user with actionable status (drift, outdated, missing, etc.). The doctor module performs comprehensive health checks and can auto-fix certain issues. External dependencies are minimal: the Rust standard library plus crates for CLI parsing (clap), GUI (egui/eframe), serialization (serde, toml), hashing (sha2), filesystem walking (walkdir), and TOML editing (toml_edit). The system is designed to be offline-first and respects the filesystem as the source of truth for skill enablement.
jest-junit is a Jest reporter that transforms test results into JUnit-compatible XML files, commonly used in CI/CD pipelines for integration with tools like Jenkins, CircleCI, and GitLab CI. The codebase is a small, focused Node.js library with a clear architecture: an entry point that supports both the modern reporter API and the deprecated testResultsProcessor, a configuration resolver that merges settings from environment variables, package.json, and reporter options, and a core transformation module (`buildJsonResults`) that converts Jest's aggregated result objects into a structured JSON representation directly mappable to JUnit XML via the `xml` package. It handles template variables for test suite names, class names, and test titles, supports custom properties via external JS files, and manages edge cases like test compilation errors, empty suites, console output inclusion, and retried tests. The code is well-tested with Jest and includes XML schema validation. While the library is not architecturally groundbreaking, it is cleanly modular, follows Node.js best practices, and its configuration and transformation patterns could be reused in other test report generators.
nec2++ is a C++ implementation of the Numerical Electromagnetics Code (NEC-2) for antenna simulation using the Method of Moments. It provides a library (libnecpp) and a command-line tool that reads NEC-2 card files (geometry, excitation, ground, frequency, output requests) and computes antenna input impedance, radiation patterns, near fields, structure currents, and ground effects. The architecture is modular: a geometry construction module (c_geometry) builds wire/patch models from GW, SP, SC, GM, GX cards; a simulation context (nec_context) manages card dispatch, frequency sweeps, and solver execution; linear algebra (matrix_algebra) wraps Eigen's LU decomposition with a Gauss-Doolittle fallback; and output formatting (nec_output, nec_results) supports NEC text, XML, and CSV formats. The system is callable from C, C++, Python, and Ruby via a public C API (libnecpp.h), and includes a WASM wrapper for browser deployment. External dependencies are Eigen (vendored) for dense/sparse linear algebra and the C++ standard library. The testharness cross-validates against the original FORTRAN NEC-2 and the C port nec2c using over 50 antenna models, with Catch2 unit tests for numerical correctness and regression coverage.
Nuvio TV is a feature-rich, open-source Android TV media streaming client built with Kotlin, Jetpack Compose for TV, and Material 3. It aggregates content from multiple sources via a Stremio-compatible addon system, debrid services (RealDebrid, Torbox, Premiumize), and media servers (Jellyfin, Emby). The application provides a highly customized playback experience built on Media3 ExoPlayer with optional libmpv, featuring Dolby Vision handling, subtitle auto-sync, hardware-aware decoder selection, auto-frame-rate switching, and extensive diagnostic instrumentation. It includes a multi-profile user system, watch tracking integration with Trakt, Simkl, and MDBList, cloud library sync via Supabase, and an in-app update mechanism. The codebase exhibits strong engineering practices with extensive unit tests (over 400 test files), pure policy objects isolated for testability, and a well-layered architecture (MVVM, Hilt DI, DataStore per profile). It is not a data research repository; it is a production Android TV application with a focus on flexibility, performance, and media compatibility.