Entralinked is a Java-based application that emulates Nintendo's Pokémon Global Link services for Pokémon Black/White and sequels. It functions as a standalone local server suite, providing DNS, GameSpy, and HTTP services to enable Nintendo DS/3DS consoles to access online features without save file modification. The architecture combines network servers (DNS on port 53, GameSpy on 29900, HTTP on 80/443), a Swing-based GUI for configuration, and a web dashboard for managing in-game Pokémon Dream World data. Key features include user/account management, DLC distribution, and save data synchronization via the PGL protocol. The project demonstrates solid engineering with reusable utility modules, clear separation of concerns, and active maintenance, though it relies on legacy protocols and contains some technical debt.
P-HAR is a video analysis application that performs human action recognition specifically tailored for adult content. It processes input videos through three complementary modalities: visual frames (using TimeSformer), human pose sequences (using PoseC3D), and audio features (using a ResNet-based model). The system extracts features from each modality, runs inference through specialized deep learning models, and fuses the results using a weighted late fusion approach that handles heterogeneous output spaces. The architecture follows a modular pipeline: video input undergoes frame extraction and preprocessing, then each modality is processed independently through its respective model pipeline. The RGB stream processes spatiotemporal visual features, the skeleton stream first performs human detection and pose estimation before action recognition, and the audio stream extracts loudness-normalized spectral features. Results from all three streams are aligned to a common label space and combined using weighted averaging to produce final action predictions. Output can be generated as an annotated video with overlayed action labels and confidence scores, or as a JSON file containing temporal predictions for further processing. Key entry points include the multimodal demo script for end-to-end video processing, utility scripts for dataset preparation and model evaluation, and specialized tools for audio filtering and data pipeline management. The application relies on the MMAction2 framework ecosystem (including MMDetection and MMPose) for core computer vision capabilities, supplemented by standard Python libraries for media processing and data handling.
This repository implements the Elden Ring Practice Tool, a Windows application that provides an in-game overlay with cheats, debugging utilities, and speedrun practice features for Elden Ring. The system works by injecting a DLL into the game process, hooking DirectX 12 to render an ImGui overlay, and reading/writing game memory via pointer chains. The architecture is a Cargo workspace with multiple crates: `practice-tool` (main DLL with overlay UI), `lib/libeldenring` (core memory editing and parameter access library), `lib/param-tinkerer` (standalone parameter editor), `lib/no-logo` (intro screen removal DLL), `lib/scripts` (injector), and `xtask` (build and code generation orchestration). Key entry points include `practice-tool/src/lib.rs` (DLL main), `practice-tool/src/practice_tool.rs` (ImGui render loop), and `xtask/src/main.rs` (build tasks). Data flows involve reading game memory via pointer chains, parsing game parameters from community-maintained Paramdex XML, and generating Rust structs and base addresses via AOB scanning. External dependencies include `hudhook` for injection, `imgui` for UI, `windows` crate for Win32 APIs, and `Paramdex` for game data definitions. The tool is heavily version-dependent, supporting 28 game versions with hardcoded base addresses.
This repository is a static website ranking Chinese GitHub developers by follower count, built with Astro and Tailwind CSS. It features two ranking tabs: 'Developers' and 'Markdown Engineers', based on a curated list of users known for documentation/content creation. The site fetches data daily via GitHub Actions using a Node.js script that queries the GitHub API. While primarily a web application, it has a significant data-engineering component in the form of the data collection script, which includes rate limiting, pagination, caching, and deduplication. The frontend implements client-side search functionality and lazy-loaded avatars for performance. The UI is designed with a VSCode-inspired dark theme. The codebase is well-structured, with clear separation of data fetching, utilities, and presentation components. However, the ranking logic and the classification of 'Markdown Engineers' are based on a hardcoded list, which is opinionated and not algorithmic. Overall, the project is a functional and visually polished static ranking site with a robust data pipeline.
The repository implements the Ascon family of lightweight cryptographic algorithms, including authenticated encryption (Ascon-AEAD128), hashing (Ascon-Hash256), extendable output functions (Ascon-XOF128), message authentication codes (Ascon-Mac), and pseudorandom functions (Ascon-Prf). It provides both reference and highly optimized implementations for diverse architectures (ARM, AVR, RISC-V, x86 with AVX512/NEON) and optimization levels (speed, size, side-channel resistance). The library follows the CAESAR API style with functions like crypto_aead_encrypt, crypto_aead_decrypt, and crypto_hash. Core operations use a 5-word state structure and apply permutation rounds (6, 8, or 12) based on the mode. The architecture is modular, separating algorithms into directories with subdirectories for implementation variants (reference, architecture-specific, low-size). While the code demonstrates strong cryptographic engineering and portability, it exhibits significant duplication across variants, increasing maintenance burden. However, reusable components exist, such as endianness handling, word abstraction, and bit-interleaving algorithms from 'Hacker's Delight'. The repository is actively maintained with recent commits and shows low technical drift.
This repository is a comprehensive cybersecurity knowledge base focused on offensive security techniques, particularly binary exploitation, cryptography, reverse engineering, and CTF challenge writeups. It serves as an educational resource containing detailed tutorials, exploit development guides, and solution writeups for various platforms (HackTheBox, picoCTF, etc.). The content is organized by topic with markdown files explaining concepts ranging from basic stack overflows to advanced heap exploitation techniques like tcache poisoning and kernel attacks. While not containing runnable applications, it provides reusable exploit methodologies and code snippets that security practitioners can adapt for learning and CTF preparation.
VASPy is a pure Python library for manipulating and analyzing VASP (Vienna Ab initio Simulation Package) input and output files. It provides object-oriented parsers for common VASP formats including POSCAR, CONTCAR, XDATCAR, OUTCAR, OSZICAR, INCAR, DOS, ELFCAR, CHGCAR, and also supports Materials Studio formats (XSD, ARC, XTD). The library exposes high-level classes like PosCar, OutCar, DosX, and InCar that encapsulate file parsing, coordinate transformations, and data extraction, enabling users to programmatically read, modify, and visualize simulation results. It also includes a set of command-line scripts for common tasks such as creating VASP inputs, extracting forces, computing zero-point energies, and converting between file formats. The architecture is modular, with separate modules for atomic coordinates, electronic structure, iterative outputs, and Material Studio interoperability, all built on a shared base class and utility functions. Visualization is a key feature, with matplotlib and PyVista backends for plotting DOS, charge densities, and trajectories. The library is designed for computational materials science researchers and DFT practitioners who need to automate post-processing and workflow tasks around VASP calculations.
The yandex2spotify repository provides a command-line tool for migrating personal music data from Yandex.Music to Spotify. The tool facilitates the transfer of liked tracks, playlists, albums, and artists by leveraging the respective APIs of both services. Users authenticate with Spotify via OAuth and provide a Yandex.Music token to access their data. The application is structured around a single Python script, `importer.py`, which defines an `Importer` class responsible for orchestrating the import process. This class contains methods for each import category (likes, playlists, albums, artists) and a generic method for importing from a JSON file. The implementation includes robust error handling for API rate limits and timeouts via a custom decorator, and utilizes batching to efficiently process large numbers of items via the Spotify API. While the codebase is relatively small and focused, it exhibits several sound software engineering practices, such as modularization of import logic, reusable utility functions (e.g., for chunking lists), and thoughtful handling of edge cases (e.g., truncating overly long track names). The tool depends on the `spotipy`, `yandex-music`, and `Pillow` libraries, and is designed to be run in a standard Python 3.8+ environment.
This is a Go-based CLI tool that synchronizes Claude Code session state across devices using encrypted cloud storage. It is distributed via npm (with platform-specific binaries), GitHub Releases, and 'go install'. The tool provides commands for push, pull, status, diff, conflict resolution, and self-update. It integrates with Claude Code through shell hooks installed into `settings.json` and an optional plugin, enabling automatic synchronization on session start/stop. The architecture follows a provider-agnostic storage pattern with adapters for Cloudflare R2, AWS S3, Google Cloud Storage, S3-compatible endpoints, and WebDAV (e.g., Nextcloud/ownCloud). Files are gzip-compressed, then age-encrypted using a deterministic passphrase-derived X25519 key (Argon2id with 64MB memory). A PathMapper rewrites absolute paths to portable tokens in both remote keys and file content, enabling cross-OS round-trip consistency. The system also includes a three-way merge for MCP server configurations and history reconstruction from session files. External dependencies include the `age` encryption library, `golang.org/x/crypto` for Argon2id, survey for interactive wizards, and cloud storage SDKs (AWS SDK v2, Google Cloud Storage client). The repository is actively maintained with regular releases and a comprehensive test suite, though some version drift (npm package.json shows 0.4.0 while CHANGELOG reaches 1.17.2) and minor CI configuration mismatches (Go 1.21 vs go.mod 1.24) are present. A security audit has been performed with findings documented.
goploader is a self-hosted file sharing system consisting of a Go-based command-line client and web server. The server provides both a web interface and REST API for file uploads/downloads, featuring optional client-side encryption (where encryption keys are never stored server-side), automatic expiration-based cleanup, and metadata storage via BoltDB. The client supports terminal-based uploads with features like progress bars, screenshot capture, and clipboard integration. Architecture follows a layered design with separation between HTTP handlers (views), data models, and utility components. While the core functionality is well-implemented, the codebase shows signs of technical debt including outdated frontend dependencies (Font Awesome 4.7.0), inconsistent Go version references, and a cryptographic concern (static IV in AES encryption mode). The maintainer explicitly notes the technology is outdated but maintains the repository in a working state.
SequenceServer is a Ruby/Sinatra web application that provides a graphical interface for running NCBI BLAST+ and DIAMOND sequence similarity searches against custom databases. It manages BLAST database formatting, job submission with background execution, result parsing, and interactive visualization of alignments using D3.js and Circos-style plots. The backend uses a thread pool for concurrent job processing, YAML-based job persistence, and a plugin system for extensibility. The frontend is built with React and includes components for database selection, query input, and result exploration with export to SVG/PNG. The application is designed for bioinformatics researchers who need a self-hosted BLAST server with a modern web UI, supporting multiple BLAST programs (blastn, blastp, blastx, tblastn, tblastx) and DIAMOND. It includes comprehensive test suites for multiple BLAST versions and CI/CD pipelines for Docker and AppImage deployment.
This is a minimal npm package that fixes the $PATH environment variable on macOS and Linux when an application is launched from a GUI (e.g., Electron). It uses the shell-path package to retrieve the shell's PATH, strips ANSI escape codes, and sets process.env.PATH accordingly. On Windows, it is a no-op. The codebase is a single ES module with TypeScript definitions, unit tests, and CI. It is well-maintained by Sindre Sorhus and has no open issues. The implementation is straightforward and does not contain any complex architecture or reusable components beyond the package itself.
RDocumentation 2.0 is the production Next.js frontend for rdocumentation.org, a searchable documentation browser covering every version of every R package published on CRAN and Bioconductor. It is a pages-router Next.js application (Next 14, React 18) deployed as a Docker container on ECS/Kubernetes with CircleCI. The application renders package pages with READMEs, function/topic documentation with syntax-highlighted examples and MathJax-rendered math, download statistics, GitHub repository metrics, collaborator profiles, and search results with pagination. It also implements numerous legacy redirect routes (e.g. campus/help, link/[topic], bare package/topic URLs) that resolve to canonical versioned URLs server-side, plus a local health-check endpoint used by container orchestration. The architecture is a server-rendered UI that delegates all data access to an external backend API at api.rdocumentation.org, supplemented by the GitHub GraphQL API (requiring a GITHUB_TOKEN) for repo star/fork/issue counts and cranlogs.r-pkg.org for monthly download data. Search and autocomplete are client-side, hitting the backend's Elasticsearch-backed search_functions and search_packages endpoints directly. The most interesting engineering resides in the lib/ layer: a custom R-version comparator (R versions are not semver; segments like "1.0.10" vs "1.2-3" need numeric segment comparison), a search query parser that recognizes both stats::lm and lm(stats) scoped-search formats, and client-side deduplication logic that collapses duplicate package/function versions while preserving relevance order — compensating for known quirks in the backend API (identical relevance scores tie-broken by insertion order, latest=1 flag dropping packages with null latest_version_id, function searches lacking topic documents for newest versions). Operational reality is documented honestly in docs/runbook.md: the UI is the most modern component in a larger legacy system. The backend API, worker, and Elasticsearch components date from 2015-2016 and run Node 8; the Depsy collaborator data source has been dead since 2018; and the frontend has minimal error handling when the API is unavailable. The UI code itself is well-structured and cleanly separated between components, lib helpers, and pages, but it ships without unit tests (only Playwright health checks), TypeScript is configured non-strict, and several dependencies lag their ecosystems (ESLint 7, TypeScript 4.9, react-markdown 5's deprecated plugin API, an old recharts beta).
AtoM (Access to Memory) is a mature, open-source web application for archival description and access, developed by Artefactual Systems. In production, it manages hierarchical archival descriptions (fonds, series, files, items), authority records, repositories, digital objects, and accessions. It supports multiple archival standards (EAD, EAC, MODS, METS, Dublin Core) and provides multilingual, multi-repository archival description. The application is built on PHP 7/8 with a Symfony 1.x core, Propel ORM for persistence, and Elasticsearch for search indexing, with MySQL/MariaDB as the primary datastore and Gearman for background job processing.
GeeksBlabla is a Moroccan tech community podcast website built with Astro. It serves as a content hub for podcast episodes (200+ episodes in Darija), blog articles, community projects (BlablaConf, State of Dev, Awesome Morocco), and a team page. The site features a chatbot (BlaBlator) powered by RAG over podcast transcripts using ChromaDB and OpenAI, an episode creation workflow integrated with Notion as a CMS, and YouTube API for metadata. The frontend uses Astro with React interactive islands, Tailwind CSS, and Rive animations for engaging visuals. The architecture is a hybrid of static site generation (Astro static output) with dynamic server actions and API routes deployed to Cloudflare Workers. It includes CI/CD workflows for episode validation, Spotify upload, and YouTube description syncing. While well-structured and feature-rich, it relies on many external services (Notion, OpenAI, ChromaDB, YouTube, Cloudinary, Supadata) and has some code duplication (two identical server action files).
PyLTSpice is a Python library and CLI toolkit for automating LTspice circuit simulations. It exposes programmatic editing of .asc netlists (AscEditor/SpiceEditor), reading of LTspice .raw binary output files (RawRead), histogram generation for Monte Carlo analysis, and command-line utilities (ltsteps, histogram, raw_convert, rawplot, run_server, asc_to_qsch). The codebase is primarily a compatibility layer over the spicelib package: many modules are thin re-exports that emit deprecation notices and delegate to spicelib, while preserving legacy class names such as SimCommander and LTSpiceRawRead. The repository includes unit tests with sample .raw/.log/.asc files, Sphinx documentation, and examples. Although it processes simulation data, this is an application/library rather than a data-research repository. Maintenance is active, but the tight dependency on spicelib and the presence of legacy shims create moderate drift risk.
RSSDP is a .NET library implementing the Simple Service Discovery Protocol (SSDP) for UPnP device discovery and advertisement. The library enables applications to discover network services and advertise their own services on local networks using UDP multicast communication. It provides a clean separation of concerns with distinct components for device discovery (SsdpDeviceLocator), device publication (SsdpDevicePublisher), and network communication handling (SsdpCommunicationsServer). The library follows .NET best practices with interface-based dependency injection, proper IDisposable implementation, and event-driven architecture for device lifecycle events. It supports multiple .NET platforms including .NET Framework 4.8+, .NET 6/8+, .NET Standard 2.0, and Xamarin platforms via MAUI. The repository includes comprehensive unit tests, sample applications (console, MAUI, UWP), and generated documentation via DocFX.
DeepV-Ki is an AI-powered wiki generator for code repositories that combines a Next.js frontend with a FastAPI backend. The system allows users to input a repository URL and automatically generates documentation, architecture diagrams (Mermaid), and provides a RAG-based Q&A interface. It features multi-LLM provider support (OpenAI, Google Gemini, Azure, AWS Bedrock, Ollama), GitLab/GitHub/Bitbucket integration, asynchronous task processing with Celery, and multi-layer caching. The architecture follows a monorepo structure with clear separation between frontend (React/Next.js) and backend (Python/FastAPI) components, communicating via REST APIs. The system includes sophisticated authentication (SSO, session management), progress tracking, and real-time WebSocket communication for streaming AI responses.
SYSTEM is an AI-powered macOS automation assistant enabling natural language control of Mac functions through a distributed architecture. It consists of a Tauri-based desktop app for local management, a CLI for setup/diagnostics, a local bridge server executing commands on the Mac, and a Cloudflare Worker serving as the AI agent using Anthropic's Claude. The system emphasizes privacy by keeping processing on user infrastructure, with secure Bearer token authentication between components. The architecture features a modular tool system where each capability (music, reminders, calendar, etc.) follows a consistent interface for easy extension. Communication occurs via HTTP/WebSocket: the UI sends requests to the Cloudflare Agent, which processes natural language with Claude and commands the local bridge. The bridge validates inputs, executes tools (using AppleScript/shell commands), and returns results. Real-time updates use WebSockets for scheduled tasks and notifications. Security is prioritized through command allowlisting, dangerous pattern blocking, and explicit macOS permission requirements. Key reusable components include secure command execution utilities and input validation patterns. The bridge server's validation and command modules isolate security concerns, while the tool interface pattern enables extensibility. The system is actively maintained with a pre-commit hook and low issue count, though distributed components risk drift. Dependencies show no known vulnerabilities (Dependabot Alerts: 0), but reliance on external services (Anthropic, Cloudflare) requires monitoring for API changes.
Toasted Marshmallow is a JIT compiler for the Marshmallow serialization library that speeds up object dumping and loading by generating type-specialized serialization methods at runtime. It works by creating optimized serializers for instance objects, dictionaries, and hybrid objects (those with __getitem__), then using a proxy to adaptively select the best serializer based on input type patterns. The project includes a forked Marshmallow submodule to provide necessary hooks for JIT integration. Architecture-wise, it's a Python library with core logic in toastedmarshmallow/jit.py, utility modules for code generation and compatibility, and performance benchmarks. Entry points involve setting schema.jit = toastedmarshmallow.Jit on a Marshmallow Schema instance.