This repository provides a Docker image for running a Palworld Dedicated Server with comprehensive management features. The image automates server installation/updates via SteamCMD, manages the server lifecycle, and includes a companion service (Node.js) that provides a web operation panel and Discord live status card. Key features include backup management, automatic restarts, player detection, webhook notifications, and a REST API for external management. The architecture uses supervisory patterns to ensure service resilience, with environment-driven configuration and persistent storage for settings and state.
gimli is a Rust library for reading and writing the DWARF debugging format, used by debuggers, profilers, and binary analysis tools. It provides zero-copy, lazy parsing of all standard DWARF sections (e.g., .debug_info, .debug_line, .debug_frame, .debug_names) across versions 2–5, including split DWARF (DWO/DWP) and supplementary object files. The library is split into `read` and `write` modules, with a conversion pipeline to transform parsed debug data back into DWARF. It is designed to be `no_std` compatible (with alloc) and uses trait-based abstractions for readers/writers, allowing custom backing stores. Example CLI tools (dwarfdump, simple, convert) demonstrate real-world usage. The codebase is highly modular, with extensive unit tests, fuzzing, and benchmarks, and emphasizes correctness, performance, and cross-platform support (32/64-bit, little/big endian).
TinyLLaVA Factory is a modular Python framework for building, training, evaluating, and serving small-scale Large Multimodal Models (LMMs). It provides a pluggable architecture with separate components for vision towers (CLIP, SigLIP, DINOv2), language models (Phi, TinyLlama, Gemma, Qwen2, etc.), and connectors (MLP, QFormer, Resampler), all accessible via factory registries. The training pipeline supports two-stage pretraining (alignment) and finetuning with full, LoRA, or QLoRA recipes using DeepSpeed. It includes a comprehensive evaluation suite for standard benchmarks (VQA, GQA, SQA, POPE, MMMU, etc.) and a Gradio-based web demo. The codebase is well-organized and follows clean architectural patterns, though many modules are tightly coupled to the internal framework. It is actively maintained, with recent additions like a visualization tool and support for new models.
Jco is a JavaScript toolchain for WebAssembly components. It transpiles WASM components to JavaScript, generates TypeScript types from WIT, bundles components, and provides a standard library (`jco-std`) that ports Node.js built-in modules (fs, http, tls, net, crypto, zlib, etc.) to run inside WebAssembly components via WASI Preview 2/3. The monorepo contains a Rust workspace (bindgen crates, test components) and TypeScript packages (jco CLI, jco-transpile, preview2-shim, preview3-shim, jco-std). The codebase is notable for its differential testing approach: shims are tested against native Node.js behavior, with tests for HTTP/2, TLS, SQLite, streams, and worker threads. A dual-adapter pattern (deny-by-default vs. Node-native) ensures security by default. The project supports multiple WASI versions (0.2.x, 0.3.x) and Node.js versions (24.x, 26.x), with dedicated shims for browser and Node.js runtimes. Maintenance is active (recent commits, CI workflows), but there are drift risks: pinned Node.js versions, many TODO comments, incomplete browser shims (throwing Todo), and experimental features like JSPI and async support.
HAITI (HAsh IdenTIfIer) is a Ruby library and CLI tool for identifying hash types from input strings. It matches against a comprehensive database of over 675 hash types (including modern algorithms like SHA3, Blake2, and VeraCrypt) using regex patterns. The library provides concise output with hashcat mode numbers, John the Ripper format names, and example hashes. Multiple CLI entry points exist: the main `haiti` command, `haiti-parsable` for script-friendly output, `haiti-fzf` for interactive selection, and `hashcat-haiti`/`john-haiti` for converting hashes into hashcat/JtR formats. The codebase is well-structured, with clean separation between the identification engine, data definitions, and CLI wrappers. It includes comprehensive documentation (man pages, YARD API docs, a docsify site) and is packaged for numerous Linux distributions and Homebrew. The identification logic is straightforward but effective: iterate over a JSON array of prototypes, apply each regex to the input, and return matching types. The data file (`prototypes.json`) is manually maintained and extended with each release.
The iproute2 repository is the canonical source for the standard Linux networking command-line suite. It provides the `ip`, `tc`, `bridge`, `ss`, `rdma`, `tipc`, `devlink`, `genl`, `dcb`, `vdpa`, `dpll`, and `netshaper` tools. These tools are the primary interface for system administrators to configure and monitor the Linux kernel's networking stack, including interfaces, addresses, routes, tunnels, traffic control (QoS), IPsec, multicast, and more. All tools communicate with the kernel exclusively via netlink sockets. Architecturally, it is a collection of tightly integrated C programs built on a shared library (`libnetlink`, `libutil`). It features a well-designed plugin system for traffic control objects (qdiscs, filters, actions) and link types, allowing extensibility without modifying core tools. The codebase demonstrates high craftsmanship in areas like structured output (JSON/plain dual-mode via `json_writer`), robust netlink message construction (`libnetlink`), and complex state introspection (`ss`). The project is actively maintained with recent commits and a large community. However, its long history means it carries significant technical debt. This includes vendored kernel UAPI headers that must be manually synced, multiple code paths for legacy features (e.g., BPF loading via libbpf vs. legacy ELF), and a vast surface area of specialized modules that can suffer from bit rot. The core infrastructure is solid, but some peripheral modules show signs of drift. For engineers, the `lib/` directory is a goldmine of reusable C patterns. `libnetlink.c` is the definitive reference for netlink communication. `json_writer.c` provides a battle-tested dual-output system. `lib/fs.c` offers robust cgroup2 filesystem helpers. These components are self-contained and can be extracted for use in other Linux system tools.
Rivalcfg is a Python 3 library and command-line tool for configuring SteelSeries gaming mice (Rival, Sensei, Prime, Aerox, Kana, Kinzu, etc.) on Linux, macOS, and Windows. It communicates with devices via HID (using hidapi) using reverse-engineered HID report protocols. The system provides a clean device profile dictionary schema for each mouse, a plugin-like handler system for different value types (choice, range, RGB color, button mapping, gradients, etc.), and a CLI that dynamically generates argparse options from the device profiles. It also includes persistent settings storage in JSON, udev rule management for Linux, and test doubles (FakeDevice, FakeMouseSettings) for testing without physical hardware. The project is community-driven, with new devices added frequently through reverse engineering.
Certifi is a minimal Python library that provides Mozilla's curated collection of root CA certificates for SSL/TLS verification. It exposes two functions: `where()` returns the filesystem path to the bundled `cacert.pem` file, and `contents()` returns its contents as a string. The library handles both modern Python 3.11+ importlib.resources API and older versions, with careful management of context managers and atexit cleanup to support zipimport scenarios. It is a dependency of many popular Python packages (e.g., requests) and is automatically updated daily via a GitHub Actions workflow that fetches the latest Mozilla CA bundle. The codebase is small, well-tested, and demonstrates high craftsmanship in resource management and backward compatibility.
redis-replicator is a Java library for Redis replication and data parsing. It provides event-driven APIs to consume Redis RDB snapshots, AOF logs, and live replication streams (PSYNC/SCAN). The architecture is based on a `Replicator` interface with multiple implementations (`RedisRdbReplicator`, `RedisAofReplicator`, `RedisSocketReplicator`, `RedisMixReplicator`, `RedisScanReplicator`). Key entry points are `RedisReplicator` (facade) and `Configuration` (URI-based settings). Data flows: raw bytes from Redis or files are parsed by `RdbParser` or `CommandParser` into typed `Event` objects (e.g., `KeyValuePair`, `Command`), which are dispatched to registered `EventListener` instances. The library supports all major Redis data types, commands, and versions 2.6–8.4.x, with extensions for Valkey and custom modules. External dependencies include SLF4J for logging and Jedis for online tests. It is used for data migration, backup, real-time synchronization, and building custom Redis-compatible tools.
Tailwind CSS Animated is an npm library that extends Tailwind CSS with a comprehensive set of animation utilities and 19 predefined keyframe animations. It provides utility classes for animation duration, delay, direction, iteration count, timing function, fill mode, play state, and composition, plus ready-to-use animations such as wiggle, shake, fade, flip, jump, and rotate. The package is dual-version: it ships a CSS-first implementation using Tailwind v4's @utility and @theme directives (src/utilities/*.css, src/index.css), alongside a legacy JavaScript plugin (src/compat/*.js, src/index.js) that works with Tailwind v3's plugin API. The architecture cleanly separates the v4 CSS utilities from the v3 compatibility layer, sharing a single theme definition in src/compat/theme.js.
Sailfish is a compile-time template engine for Rust, delivered as a multi-crate workspace. The core crates are `sailfish` (public runtime API), `sailfish-macros` (thin derive-macro shim), and `sailfish-compiler` (the actual template compilation pipeline: parser -> translator -> resolver -> optimizer -> code generator). Applications derive one of four traits (`TemplateSimple`, `TemplateOnce`, `TemplateMut`, `Template`) on a struct, point at a `.stpl` file with `#[template(path = ...)]`, and call `render_*()` to produce an HTML/text string. The compiler runs at build time, which makes rendering type-safe: template expression errors surface as Rust compile errors mapped back to template source positions. The runtime side is performance-focused: a custom raw-allocated `Buffer` with zero-copy `String` conversion, adaptive pre-allocation via size hints, filter composition via wrapper types, and SIMD HTML escaping (AVX2/SSE2/fallback) selected at runtime with an atomic function pointer. Templates support EJS-style syntax (`<% %>` code, `<%= %>` escaped output, `<%- %>` raw output, `<%+ %>` nested component rendering, `include!` for composition), custom delimiters, whitespace control, and a `sailfish.toml` config system with env-var expansion. The repo also ships editor tooling: a tree-sitter grammar with bindings for Rust, Node, Python, Swift, Go, and C, a VSCode extension, and Vim syntax/indent files, plus an mkdocs documentation site whose generated output is committed. External dependencies are minimal (syn/quote/proc-macro2, filetime, optional serde/toml for config); web-framework integration is demonstrated with an actix-web example. Tests are strong: template fixtures paired with golden `.out` reference files plus trybuild compile-fail tests. Notable warts: CHANGELOG is stale (stops at v0.4.0 while the crate is at v0.11.x), the docs `output_site/` and VSCode `node_modules/` are committed to the repo, a legacy Travis script lingers, and the VSCode grammar does not recognize the newer `<%+` component tag. None of these affect the core library, which is well-structured and actively maintained.
This repository is a robust Android library designed for debugging applications by providing a user-friendly interface to view system logs (logcat). It functions as a standalone framework that integrates into an Android app via Gradle dependency. The core functionality involves capturing logs from the system logcat process, parsing them using regex patterns, filtering them based on user-defined rules (TAG, level, search keywords), and displaying them in a RecyclerView with features like auto-merging, highlighting, and saving to file. The architecture relies on a ContentProvider for automatic initialization, a Foreground Service to maintain the log capture process (handling Android 8+ and 14+ restrictions), and a Floating Window/Notification for user interaction. The code demonstrates strong engineering practices, particularly in handling Android version fragmentation (e.g., specific handling for Android 12's Foreground Service restrictions and Android 14's targetSdk 34 requirements). It includes OOM protection mechanisms by limiting the number of displayed logs and uses MD5 hashing to prevent duplicate log entries when restarting the capture stream.
Kineto is a production-grade C++ library for GPU and CPU performance profiling, primarily embedded in PyTorch's profiler. It provides low-overhead timeline tracing of GPU kernels, memory operations, synchronization events, and CPU-side activities, with support for CUDA (CUPTI), ROCm (rocprofiler-sdk), and Intel XPU (PTI) backends. The library supports both synchronous (manual start/stop) and asynchronous (on-demand, daemon-triggered) profiling modes, and emits Chrome Trace JSON and in-memory trace buffers for downstream analysis. It is not a standalone application; it is a linkable library with a public C API and plugin interfaces for custom profilers and loggers. Architecturally, Kineto is organized around a central ActivityProfilerController that drives a warmup/collect/process state machine, delegating platform-specific capture to backend profilers derived from GenericActivityProfiler. Configuration flows through a ConfigLoader that polls files or an IPC fabric daemon, and activity data flows from vendor callback/activity APIs through correlation-ID-based flow tracking into typed metadata and trace spans. The codebase demonstrates strong software engineering practices: extensive unit tests, CI matrices for CPU/CUDA/ROCm/XPU, clean interface abstractions, and reusable patterns such as observer-based logging, factory-based output registration, and type-safe metadata visitors. However, heavy conditional compilation, vendor SDK version guards, and platform-specific ifdefs introduce maintenance complexity and moderate technical drift risk.
This is an automated trading bot for Polymarket prediction markets that buys NO outcomes in standalone yes/no markets below a price threshold. The application features a modular architecture with separate components for strategy execution, exchange interaction, risk management, state persistence, and web-based monitoring. It continuously scans for eligible markets, places orders when conditions are met, manages positions, and implements recovery mechanisms for handling failed orders. The system can operate in paper trading mode or live trading mode with appropriate configuration.
YaFSDP is a high-performance Sharded Data Parallelism library for PyTorch, developed by Yandex. It provides two APIs: a high-level `YaFSDP` wrapper class and a lower-level `fully_shard` composable function, both designed to shard model parameters across data-parallel processes for training large transformer models. The library implements advanced techniques such as ragged sharding (via `RaggedShardDTensor`), efficient all-gather/reduce-scatter with optional YCCL acceleration, mixed precision, gradient accumulation, and hybrid parallel zones (HPZ). It is tightly integrated with PyTorch's distributed infrastructure and includes patches for Hugging Face libraries (transformers, accelerate, trl) to enable seamless usage in LLM training workflows. The codebase is well-structured, with clear separation of concerns across modules for parameter management, collectives, state, and tensor operations. It demonstrates high craftsmanship in its custom tensor subclass and communication optimizations, making it a valuable tool for large-scale distributed training.
pret/pokeruby is a reverse-engineering project that reconstructs the complete source code of Pokémon Ruby and Sapphire (Game Boy Advance) in C and ARM assembly. The build system compiles the entire game into byte-identical .gba ROMs, verified by pinned SHA1 checksums across a matrix of variants: Ruby/Sapphire, revisions 0/1/2, German localization, debug builds, and a modern-toolchain mode. The repository is the actual working source of the game engine, not documentation: it contains the battle system (turn logic, AI, animations via sprite templates and affine transforms), overworld/field state machines (weather, poison, cut, evolving, day care), Pokémon storage and save/load serialization, contest/link multiplayer subsystems, and the m4a sound driver, all written directly against GBA hardware registers and ARM7TDMI constraints. The architecture is a monolithic single-binary ROM rather than a service or library. Entry points are AgbMain() and the CB2_* main-loop callback system; game systems are orchestrated by a 16-slot task scheduler and a sprite/OAM manager. The build is driven by a sophisticated Makefile that feeds custom C++ asset pipelines — gbagfx (PNG↔GBA tile conversion, Huffman compression), preproc (charmap string embedding, INCBIN expansion), scaninc (include/incbin dependency resolution), mid2agb and wav2agb (MIDI/WAV to m4a data), mapjson/jsonproc (map JSON to assembly) — which generate C arrays and assembly that the hand-written sources consume. Data flows are: raw asset → tool → generated C/asm table → compile/link → .gba ROM → SHA1 comparison against the retail cartridge dump. Because this is a decompilation, the code carries inherent artifacts: sub_* function names, NONMATCHING stubs with NAKED asm fallbacks, unused/unreferenced data, and known UB comments. However, the project is professionally maintained with CI, organized headers, careful localization branching, and a clean separation between game code and build tooling. The tools/ directory is the most reusable asset — each utility is standalone and portable to any GBA homebrew or decomp effort — followed by small hardware-abstraction layers like include/gba/macro.h and src/trig.c.
libfsm is a C library and toolchain for constructing, manipulating, and compiling finite state machines (FSMs) from regular expressions. It supports multiple regex dialects (PCRE, glob, SQL LIKE, literal, native) and compiles them into deterministic finite automata (DFAs) that guarantee linear-time matching. The library provides a rich set of FSM operations: determinisation, minimisation, union, intersection, complement, reversal, trimming, and more. It also includes a lexer generator (lx) that produces C lexers from specification files, and a pattern matcher builder (rx) that merges many patterns into a single DFA with conflict detection. The architecture is modular: an abstract data type (ADT) layer provides reusable data structures (sets, hash tables, priority queues, edge sets, interned state sets); the libfsm core implements FSM algorithms; libre handles regex parsing and AST analysis; and multiple code generation backends emit C, Rust, Go, LLVM IR, x86 assembly, awk, shell, JSON, and a custom VM bytecode. The build system uses BSD make (bmake) and the project is extensively tested with unit tests, property-based fuzzing (theft), and a cross-implementation test runner (retest) that compiles and runs generated code via dlopen. Key entry points include the fsm CLI tool for interactive FSM operations, the re CLI for regex compilation and code generation, the lx CLI for lexer generation, and the rx CLI for building pattern matchers. The library is designed for embedding in other applications, with allocator hooks and a clean public API. It is particularly suited for high-performance pattern matching, protocol parsing, and any domain requiring deterministic automata with guaranteed worst-case performance.
Offen Fair Web Analytics is a privacy-focused, self-hosted web analytics platform that emphasizes user consent and data ownership. The system employs a multi-service architecture consisting of a Go-based backend server for API and data persistence, a Node.js vault service for client-side encryption and key management, a Node.js tracking script for event collection, and a Node.js auditorium interface for users to view their analytics data. All services are orchestrated via Docker Compose, with Nginx acting as a reverse proxy. The platform ensures privacy through end-to-end encryption of analytics data in the browser before transmission to the server, preventing even the server operator from accessing raw data without the user's key. It implements granular consent management, data retention policies (default 6 months), and allows users to review, export, or delete their data via the auditorium. The system supports multiple databases (SQLite, MySQL, PostgreSQL) and provides internationalization for over six languages.
This repository is a Node.js wrapper for the TA-Lib (Technical Analysis Library) C library, providing access to technical analysis functions for financial market data. It enables Node.js applications to calculate indicators like SMA, EMA, RSI, MACD, Bollinger Bands, and dozens of candlestick patterns. The architecture uses node-gyp to compile the TA-Lib C library into a native Node.js module, with a JavaScript/TypeScript interface that supports both callback-based async and synchronous execution. Key entry points include index.js (main interface), index.d.ts (TypeScript definitions), and various usage examples. The repository demonstrates strong engineering in its cross-platform build system, clean wrapper pattern for the native addon, and high-quality TypeScript definitions that accurately represent the complex TA-Lib API.
angular-cli-ghpages is an Angular CLI builder and schematic that deploys Angular applications to GitHub Pages, Cloudflare Pages, or any Git repository. It wraps the gh-pages npm package and integrates with Angular CLI's deployment infrastructure via `ng deploy`. The tool features a modular architecture with separate entry points for standalone CLI usage, Angular builder integration, and schematic-based setup. It handles complex deployment concerns including build process integration, authentication token injection, CI environment metadata appending, and creation of necessary deployment files (.nojekyll, 404.html for SPA routing, CNAME for custom domains).