This is a full-stack todo application built with Next.js 15, React 19, and TypeScript. It features AI-powered natural language todo input, reminders via email, workspace collaboration, and a subscription model. The application uses a PostgreSQL database with Drizzle ORM for data storage, better-auth for authentication, and Resend for sending emails. The frontend is styled with Tailwind CSS and uses shadcn-ui components. Key architectural elements include API routes for todos, reminders, workspaces, and user settings, along with a cron job for processing reminders. The codebase demonstrates good engineering practices with reusable utilities for timezone handling, email sending, toast notifications, and a command palette.
NyaProxy is a lightweight API gateway/proxy service built with FastAPI and Uvicorn that manages authentication, credential rotation, load balancing, rate limiting, and observability for HTTP APIs. It acts as an intermediary between clients and upstream services, injecting credentials, enforcing quotas, and providing features like retry logic, key quarantine, and request/response transformation. The system includes a web dashboard for monitoring traffic, metrics, and queue status, and exposes Prometheus metrics for external monitoring. The architecture follows a modular design with separate concerns: core proxy logic (queue-first request handling), traffic management (load balancing and rate limiting), configuration management (using Nacho for layered config and schema validation), services (metrics, state persistence), and a dashboard interface. Requests are processed via a priority queue with worker pools, enabling prioritization of retries and high-priority requests. State persistence saves rate limit windows and key cooldowns to disk using SHA256-hashed keys to avoid storing secrets, allowing survival across restarts. Key entry points include the CLI (`python -m nya` or `nyaproxy` script) and the main application factory in `nya/server/app.py`. The system relies on dependencies like FastAPI, Uvicorn, Pydantic, Nacho, and the Prometheus client, with explicit version pins in `pyproject.toml` and regular updates shown in the changelog. The codebase demonstrates strong engineering practices including comprehensive test coverage (unit and end-to-end), secure secret handling, and clean separation of concerns.
Onsen UI is a comprehensive mobile UI framework for building hybrid mobile apps and progressive web apps (PWAs) with native-like interfaces. The repository is a monorepo containing a core library built on Web Components, CSS components with iOS and Material Design theming, and official bindings for React, Vue 2, Vue 3, Angular 2+, and legacy AngularJS. The core defines custom HTML elements (e.g., `<ons-navigator>`, `<ons-tabbar>`, `<ons-dialog>`) that encapsulate mobile-specific UI patterns such as navigation stacks, tab bars, side menus, pull-to-refresh, lazy lists, and various form controls. The CSS component library provides a consistent, themable styling layer via CSS custom properties and BEM-like modifier classes. Framework bindings wrap these core elements for seamless integration with modern frontend frameworks. The repository also includes example applications, a CSS component previewer, and extensive documentation schemas. While the framework is mature and feature-rich, it shows signs of technical drift with deprecated APIs, multiple legacy binding packages, and a complex build infrastructure. It is actively maintained but appears to be in a stabilization phase rather than rapid development.
This repository is the official collection of Godot Engine demo projects, maintained by the Godot Foundation. It contains hundreds of self-contained, runnable demo projects that showcase specific engine features across 2D, 3D, audio, GUI, networking, XR, mobile, compute shaders, and editor plugins. Each demo is a standalone Godot project with its own project.godot, scenes, scripts, and assets. The repository serves as both a learning resource for developers and a testbed for engine capabilities. While not a single application, it demonstrates a wide range of game development patterns and engine APIs. Notable highlights include a generic state machine implementation, a 2.5D node system, a virtual joystick for touch input, a custom logger with UI integration, and a JSON-driven dialogue system. The codebase is actively maintained with recent commits, low technical drift, and consistent use of modern Godot 4.x APIs.
This repository provides an agent skill for attaching before/after screenshots and screen recordings to GitHub pull request descriptions. The core product is `skill/SKILL.md`, which instructs AI agents (like Claude Code) on a workflow: capture media using `agent-browser`, format them with the bundled zero-dependency script `skill/scripts/format.mjs`, and publish via `gh --attach`. The formatter generates deterministic markdown tables with image or video comparisons, and performs idempotent replacement of a marked block (`<!-- before-and-after:start/end -->`) in PR bodies, preserving all unrelated prose. The repository also includes a comprehensive verification suite (unit tests, local browser smoke, live GitHub smoke, and an agent smoke test) and a Next.js landing page at `site/`. The architecture is minimal: one dependency-free script, one skill document, and verification infrastructure. It does not wrap browser automation, capture, or media hosting—those are delegated to `agent-browser` and GitHub CLI.
ReactPage (formerly ORY Editor) is a production-grade WYSIWYG page editor built in React. It provides a visual drag-and-drop interface for composing page layouts from a plugin system of content and layout cells. The editor stores its state as a structured JSON tree (not HTML), enabling versioning, migrations, and server-side rendering. It supports multi-language content, undo/redo, inline editing via Slate, and a read-only mode for lightweight rendering. The architecture is a monorepo with a core editor package, a rich set of content plugins (Slate rich text, image, video, spacer, divider, HTML5 video), a layout plugin (background with gradients/images), and a ReactAdmin integration. The editor is highly extensible: custom cell plugins can define their own renderers, controls (auto-generated forms via uniforms), cell styles, and data migrations. The Slate plugin itself is extensible via factory functions for marks, blocks, and data plugins. The project is used in production by several companies for CMS-like page building.
EdgeVPN is a decentralized peer-to-peer VPN built on libp2p. It creates private mesh networks by bootstrapping nodes via DHT, mDNS, and optional relays. A blockchain-like distributed ledger (pkg/blockchain) synchronizes network state—machine lists, services, DNS records, file announcements—across all nodes, with write-integrity enforced by signed entries and ownership modes. The VPN layer (pkg/vpn) creates a TUN interface and routes packets based on the ledger's machine table. Additional features include TCP service tunneling, HTTP proxy/egress, DNS resolution, file transfer, and an embedded React management dashboard (api/react-ui). The primary entry point is the CLI (cmd/app.go), which supports commands for starting the node, managing services, and accessing the API. The architecture is fully decentralized; there is no central server. External dependencies include libp2p for networking, Echo for the HTTP API, and standard Go libraries. The codebase demonstrates solid software engineering with functional options, modular packages, and integration tests, though some features remain experimental and test coverage is uneven.
PassWall is a LuCI application for OpenWrt routers that provides a unified management interface and runtime orchestration for proxy/VPN clients. In production it runs as a daemon-managed transparent proxy: it generates per-core JSON configurations for xray, sing-box, shadowsocks-rust, SSR, hysteria2, naiveproxy, and other engines; builds iptables/nftables transparent-proxy rules; integrates DNS-level routing through dnsmasq, smartdns, chinadns-ng, or dns2socks; and exposes a full web UI for node management, subscriptions, ACLs, shunt rules, health checks, load balancing via HAProxy, and server-side inbound configuration. The service is configured through UCI (`/etc/config/passwall`), with shell scripts as the main runtime dispatchers and Lua modules as the configuration-generation and LuCI-controller layer.
rspirv is a Rust workspace providing comprehensive SPIR-V module processing functionality. It includes a core library (rspirv) with a low-level data representation (DR) for raw instructions and a higher-level structured representation (SR) with type-safe indices. The project also features a binary parser, an assembler, a disassembler CLI (rspirv-dis), and a code generator (rspirv-autogen) that derives Rust types from the official SPIR-V JSON grammar. The parser supports custom consumers via the Consumer trait, enabling streaming or custom processing. The builder (dr/build) allows programmatic construction of SPIR-V modules. The lift module converts from DR to SR, bridging the two representations. The codebase is heavily auto-generated from the SPIR-V specification, ensuring spec compliance, but this also introduces risks of drift if the grammar submodule is not updated. The project is actively maintained with CI/CD pipelines, and the multi-crate workspace is designed for both library reuse and standalone tool usage.
This repository provides the Nerd Fonts project, a CLI tool and collection of scripts that patch popular developer fonts with a large set of icon glyphs (including Font Awesome, Devicons, Octicons, Material Design Icons, and many more). The core entry point is the `font-patcher` Python script, which uses FontForge to merge icon glyphs into existing monospace fonts. Supporting scripts handle font name parsing, CSS generation, fontconfig configuration, release automation, and testing. The repository also contains pre-patched fonts in `patched-fonts/` and the raw icon sources in `src/glyphs/`. It is a mature, widely-used tool with active maintenance and a large community.
Reall3dViewer is a high-performance 3D Gaussian Splatting (3DGS) web viewer built on Three.js. It streams and renders large-scale point cloud scenes (up to 150M points) at interactive frame rates across desktop and mobile devices. The viewer supports multiple input formats including PLY, SPLAT, SPX (proprietary high-compression format), SPZ, SOG, and GLB with the KHR_gaussian_splatting extension. Its architecture is event-driven and modular, with a central event system (Events.ts), dedicated loaders for each format, web workers for parallel data fetching and sorting, and a texture management pipeline that handles LOD tile streaming, frustum culling, and adaptive quality levels. Beyond basic viewing, the repository provides a full suite of interactive features: measurement and annotation tools (distance, area, point labels, 3D tags, circle plans), a map viewer (Reall3dMapViewer) with GIS basemap integration, a first-person/third-person player mode with physics (rapier3d), weather effects (rain, snow), audio-driven text overlays, and a fly-through camera path system. The code is published as an npm package (@reall3d/reall3dviewer) and includes comprehensive demo pages with scene configuration JSON files. While primarily an application library, the project also exhibits data/research characteristics through its custom SPX format specifications, advanced compression techniques (WebP, gzip, xz, zstd), and spherical harmonics support up to degree 3. The source code demonstrates high engineering craftsmanship in areas like GLSL shader modularization, WebAssembly integration for format parsing, and efficient web worker communication patterns. However, there are some maintenance risks including a large monolithic event constant file (200+ auto-incremented integers), hardcoded demo URLs, and a build script that embeds worker code as base64, which complicates debugging. No automated tests are present.
Spatie's Laravel Fractal package provides a fluent, Laravel-native wrapper around the League Fractal library for transforming data into API-friendly formats. It offers a global `fractal()` helper function, a Facade, and a Laravel Collection macro, allowing developers to easily serialize collections, items, and paginated results with custom transformers. The architecture is a standard Laravel package: a service provider registers the config file, binds a singleton to the container, and bootstraps the Collection macro. The core `Fractal` class extends `Spatie\Fractalistic\Fractal` and adds Laravel-specific features: automatic parsing of `include`, `exclude`, and `fields` query parameters from the request, configurable default serializers and paginators, and a `respond()` method that returns a `JsonResponse` with flexible status code, headers, and encoding options. The package also includes an Artisan command `make:transformer` to generate transformer classes. External dependencies are `league/fractal`, `spatie/fractalistic`, `illuminate/support`, `illuminate/contracts`, and `nesbot/carbon`. The codebase is clean, well-tested with Pest, and follows Spatie's typical high-quality standards, though it is a relatively thin integration layer rather than a complex standalone library.
This repository is a SaltStack formula that manages Salt's own master/minion infrastructure. It is not a standalone service or CLI; it is a declarative configuration-as-code library invoked by the Salt configuration management engine. In production, applying these states installs Salt packages from official repositories, renders /etc/salt/master and /etc/salt/minion configuration files from Pillar data, writes cloud provider/roster/gitfs settings, and manages service states. The primary entry points are the SLS state files (init.sls, master.sls, minion.sls, api.sls, cloud.sls, syndic.sls, ssh.sls, standalone.sls, formulas.sls), which would be referenced from a Salt top file. Architecturally, the formula follows standard SaltStack Formula conventions: salt/map.jinja merges osfamilymap, osfingermap, and osmap data with Pillar overrides, while salt/libtofs.jinja implements the Template Override File System (TOFS) pattern that allows users to replace any managed config template without forking the formula. OS-specific package repository handling is organized under salt/pkgrepo/<os>. The project includes a broad Test Kitchen/Inspec integration matrix covering Linux, Windows, macOS, FreeBSD, OpenBSD, and other platforms, plus generated mapdata snapshots used for regression testing OS/version-specific package mappings. Overall this is a mature, professionally maintained infrastructure library rather than a typical software application; it has no hybrid data-research character.
This repository provides a regularly updated list of all public npm package names (including scoped packages) as a large JSON array. The primary artifact is `names.json`, which is versioned with Git LFS and updated daily via a scheduled GitHub Actions workflow. The core logic resides in `script/build.js`, which fetches normalized repository data from the `all-the-package-repos` npm package, extracts package names, filters out purely numeric names, and writes the result as a pretty-printed JSON array. The package exposes a Node.js entry point (`require('all-the-package-names')`) returning the array, and a CLI command that outputs newline-delimited names. Tests verify the array structure, size, and exclusion of numeric names. While the codebase is minimal and straightforward, it is professionally maintained with CI/CD, automated releases, and LFS support for large data. It serves as a dependency for many npm ecosystem tools that need offline name lookups or filtering.
apkeep is a Rust command-line application for downloading Android APK packages from Google Play, F-Droid, and APKPure. It accepts single app IDs or CSV batch lists, optionally with version fields, lists available versions in plaintext or JSON, and downloads in parallel with configurable concurrency and sleep throttling. Google Play is the default source and uses the gpapi crate with OAuth/AAS/AUTH token flows, device profiles, split APKs, OBB additional files, and DexMetadata. F-Droid downloads are backed by cryptographically verified repository indexes (CMS/X.509 fingerprint and SHA-256 digests) with ETag caching; APKPure is deliberately gated behind an explicit danger-acknowledgment flag. Architecturally this is a modular async CLI: src/main.rs handles clap parsing, CSV parsing, ini config loading, and dispatch; each backend in src/download_sources exposes download_apps and list_versions and uses futures_util::buffer_unordered for bounded concurrency with indicatif progress bars. The code is readable and well separated, but it has no test suite, leans heavily on unwrap/process::exit for error handling, and repeats the three-retry download pattern in every source. The strongest engineering is in the F-Droid index verification and cache logic, which is non-obvious and hard to get right.
Jotty is a self-hosted, file-backed notes/checklists/Kanban productivity application built on Next.js App Router, React 19, and TypeScript. Data is stored as Markdown files with YAML frontmatter under a data/ directory: notes and checklists are flat files, users/sessions/settings are JSON files, and a SQLite relations database indexes wikilinks, backlinks, and mentions. The app provides rich TipTap-based editing (tables, Mermaid, code blocks, Excalidraw/draw.io), a Kanban board with timers and time tracking, the 'Brain' 2D/3D force-graph visualization of item relations, granular sharing with inherited permissions and public links, PGP/XChaCha note encryption, audit logging, OIDC/LDAP/MFA authentication, and an admin panel. A companion MCP server (mcp-server/) wraps the REST API for AI-agent integration. Architecture is a hybrid: server actions handle all mutations with a consistent auth, permission check, data operation, audit log, WebSocket broadcast flow, while a contract-driven REST API layer (defineRoute + Zod schemas + generated OpenAPI spec) exposes read/write operations for external clients. Concurrency is managed via per-item lanes and single-flight helpers to protect flat-file writes. The frontend is client-heavy with many feature components (Notes, Checklists, Kanban, Brain, Admin) built on a reusable global UI kit (Modal, Input, Dropdown, Cards, Toasts) and Zustand/context providers. The codebase shows genuine engineering care: 100+ test files including dedicated security suites for path traversal, cross-user UUID access, shell injection, and actor spoofing; atomic file writes; timing-safe API key comparisons; and path fencing wherever user input touches the filesystem. However, it is a large monolith with notable debt: SHA-256 (unsalted) password hashing, shell-out grep/sed utilities for search and frontmatter extraction, duplicated client/server utilities, legacy migration paths, and scattered type casts. The maintenance trajectory is active (frequent releases, tags, CI workflows), and the code is valuable to study for its server-action conventions, permission model, and security hardening despite the sprawl.
svelte-stripe is a Svelte component library that wraps Stripe Elements and Stripe.js, providing drop-in Svelte components for building payment UIs. It exposes context-based components such as Elements, PaymentElement, CardNumber, CardExpiry, and CardCvc, and handles Stripe.js loading, element lifecycle, and SSR safety. The repository also includes a SvelteKit demo application with examples for credit card, SEPA, iDEAL, and express checkout, plus server-side payment intent creation and webhook signature verification. It is a library and example app, not a data pipeline.
This repository is a curated, interactive learning roadmap for building AI agents. It is not a software library or framework, but a single-page web application (index.html) that renders a comprehensive todo list, project ladder, and curated resource collection. The application allows users to track progress via checkboxes stored in localStorage, take Markdown notes per stage, search content, toggle dark mode, and navigate via a sidebar. The underlying data is a static JSON structure embedded in the JavaScript. The repo's primary value is its meticulously organized learning path covering agent loops, tool use, RAG, multi-agent coordination, skills/protocols, browser agents, evaluation, and production deployment. It references dozens of high-quality external resources (official docs, papers, open-source projects) and provides clear learning principles. While the repo contains no runnable agent code, the interactive frontend is a well-crafted tool for self-paced learning. The codebase is a hybrid: it is an application (web UI) but its content is a curated research/learning resource.
Apache Commons Codec is a mature Java library providing a comprehensive set of encoders and decoders for binary-to-text formats (Base16, Base32, Base64, Base45, Base58, Hex), digest and hash algorithms (MD5, SHA-1/2/3, MurmurHash, XXHash32, Blake3, CRC16/32), phonetic encoding (Soundex, Metaphone, Caverphone, Beider-Morse, Daitch-Mokotoff), and network codecs (URL encoding, Quoted-Printable, RFC 1522 MIME). The architecture is modular with clear package separation: `binary`, `digest`, `language`, `net`, and `cli`. Key design patterns include a builder pattern for configuring codecs (e.g., `Base64.builder()`), an abstract base class `BaseNCodec` with streaming support via `BaseNCodecInputStream`/`OutputStream`, and a `CodecPolicy` enum for strict vs. lenient decoding. The library has no production dependencies; only test dependencies on commons-lang3 and commons-io. It is widely used across the Java ecosystem, with extensive test coverage including RFC vectors and backward compatibility tests. However, some deprecated methods and known bugs (e.g., in MurmurHash3 legacy methods) are preserved for compatibility, and certain algorithms (SHAKE) require Java 25, introducing version drift.
TuiCss is a CSS framework and JavaScript library that enables developers to build retro-style text-based user interfaces (TUI) for the web, mimicking the aesthetic of MS-DOS applications and Turbo Vision. It provides a comprehensive set of SCSS components including windows, panels, buttons, forms, tables, charts, modals, progress bars, and a responsive grid system, all styled with high-contrast colors and monospace fonts. The accompanying vanilla JavaScript adds interactivity for tabs, collapsible side navigation, modal dialogs, and live clock displays. The codebase is well-organized with modular SCSS files, a build pipeline using Gulp, and a clean separation of concerns. While the library has no automated tests, its examples demonstrate functional correctness, and the component structure supports straightforward reuse or theming via SCSS variables. The project is published on npm and has a small but active community with a healthy issue tracker.