Postiz is a full-stack, open-source social media scheduling and publishing platform that supports 30+ platforms (Instagram, TikTok, LinkedIn, YouTube, X, Facebook, etc.). The system is built as a pnpm monorepo with four main applications: a Next.js frontend (App Router), a NestJS backend REST API, a Temporal-based workflow orchestrator for reliable post publishing and token refresh, and a Chrome extension for cookie-based authentication. It also includes a CLI app, a public SDK (@postiz/node), and a shared libraries layer for business logic, database access (Prisma + PostgreSQL), and integrations. Key architectural patterns include an abstract social provider base class (SocialAbstract) that all platform integrations extend, a Temporal v1.8+ workflow engine with versioned posting workflows (v1.0.1 through v1.0.8), an upload factory abstracting local and Cloudflare storage, an MCP server for AI agent tools (scheduling, content generation via LangGraph), a plug/auto-reply system, and a short-link abstraction with multiple providers. The frontend uses Zustand for state management, SWR for data fetching, CopilotKit for AI textarea integration, and Mantine/Tailwind for UI. The system handles OAuth flows, subscription billing via Stripe, team collaboration, webhooks, and admin monitoring. The codebase demonstrates strong engineering with reusable abstractions for social integrations, storage, email, and short-linking, though it carries some technical debt from organic growth (multiple workflow versions, hardcoded strings, and suppressed TypeScript strictness).
Heroicons is a MIT-licensed SVG icon library providing 16x16, 20x20, and 24x24 pixel icons in outline and solid styles. The system consists of source SVG files that are optimized via SVGO and converted to framework-specific React and Vue components through a sophisticated build process. The library emphasizes tree-shakability, proper theming via currentColor, and accessibility attributes. It's distributed as separate npm packages (@heroicons/react, @heroicons/vue) with a base package containing raw SVGs.
Nodify is a production-grade WPF library for building node-based graph editors. It provides a comprehensive set of custom controls (NodifyEditor, ItemContainer, Connector, various connection types, Minimap, GroupingNode, StateNode, etc.) along with a sophisticated input processing system based on composable state machines. The library is designed for MVVM, exposes rich command and event hooks, and supports full theming with dark/light/Nodify themes. The codebase demonstrates high craftsmanship in its input state machine pattern (InputProcessor/InputElementStateStack), undo/redo framework (ActionsHistory), gesture customization system (EditorGestures), and performance optimizations (BoxValue, connector safe-zone hit-testing). It ships with five example applications (Calculator, Playground, Shapes, StateMachine, Workflow) that showcase real-world usage patterns including sub-workflows, real-time collaboration simulation, and undo/redo. The library targets a wide range of .NET frameworks from .NET Framework 4.7.2 through .NET 10 preview, with CI builds and NuGet publishing pipelines. Despite a large API surface and some mutable global settings, the code is well-organized, extensively documented, and actively maintained.
ConcurrentSim.jl is a discrete-event process-oriented simulation framework for Julia, directly inspired by Python's SimPy. It provides a simulation engine where user-defined processes (implemented as coroutines via the ResumableFunctions.jl @resumable macro) yield events that are scheduled on a priority-ordered event heap. The framework offers a complete set of resource primitives for modeling limited-capacity congestion points: Resource (a lock-like container with capacity ≥1), Container (arbitrary capacity with continuous levels), Store (unordered collection with item filtering), QueueStore (FIFO), StackStore (LIFO), and DelayQueue (FIFO with configurable latency). Event operators (&, |) provide combinatorial AND/OR synchronization, and the framework supports both Float64 simulation time and wall-clock DateTime-based scheduling. The architecture is cleanly separated across modules: the Simulation environment manages the event heap, clock, and active process; a shared BaseEvent struct implements the callback mechanism; processes integrate with the event loop via a custom finite-state machine iterator from ResumableFunctions; resources build on a common trigger/dispatch abstraction in resources/base.jl. The codebase displays mature engineering practices: CI across Julia 1.10–1.12 plus nightly (Windows, macOS, Linux), automated static analysis via Aqua and JET, a 14-file test suite with doctests, a benchmark suite comparing old and new process implementations, and comprehensive documentation. It is the successor to SimJulia and one of the longest-lived Julia packages. The repository also contains three example notebooks, but these are legacy artifacts targeting Julia 0.6 (using deprecated APIs like put/release/srand) and should be considered historical rather than current usage guides.
Searcharr is a Telegram bot application that interfaces with Sonarr and Radarr media management services. It allows users to authenticate, search for movies/TV shows, and add them to their media libraries through Telegram commands. The application features a modular architecture with separate layers for API communication, command handling, callback processing, and utilities. It includes robust authentication, conversation management for multi-step interactions, and internationalization support.
Lifo is a browser-based virtual machine and sandbox environment that emulates a Linux-like OS entirely in JavaScript. It provides a virtual filesystem (VFS), network stack, process management, shell, and an extensive Node.js compatibility layer that allows running real npm packages, dev servers (Vite, Expo, Express), and CLI tools inside the sandbox. The repository is a pnpm monorepo containing multiple packages: `@lifo-sh/core` (kernel, VFS, shell, node-compat), `@lifo-sh/ui` (React components for terminal, file explorer, preview), `lifo-sh` (CLI for daemon/session management), `apps/playground` (interactive web demo), `apps/desktop` (macOS-style web desktop), and many `lifo-pkg-*` command packages (git, ffmpeg, vi, etc.). The architecture is modular: the core kernel is framework-agnostic and can be embedded in Node.js or browser environments, while the UI and CLI are separate consumers. Key data flows involve user input through the shell, command execution against the VFS and network stack, and Node API calls intercepted by the compatibility layer. External dependencies include `acorn`, `browser-metro`, `ws`, and optional `esbuild`. The project is actively maintained with frequent releases, extensive tests, and a clear roadmap for expanding the sandbox capabilities.
Athens is a production-grade Go module proxy that implements the standard Go Modules download protocol (GOPROXY). It caches and serves Go module dependencies from upstream sources, providing reliable, fast, and private module access for development and CI/CD pipelines. The system is built as a web server using gorilla/mux with a middleware chain for caching, authentication, logging, request ID, and validation. It supports multiple storage backends including filesystem, S3, GCP, Azure Blob, Minio, MongoDB, in-memory, and an external HTTP interface, all unified under a common set of interfaces (Getter, Saver, Lister, Deleter, etc.). Key features include concurrent request deduplication (singleflight/stash) using Redis, etcd, or cloud-native leases, verification of module checksums against the Go checksum database, and an optional Go toolchain download proxy. The architecture is modular and extensible, with clear separation between protocol handling, storage, and observability (OpenTelemetry tracing, Prometheus metrics, structured logging). Extensive compliance test suites ensure backend correctness, and the codebase demonstrates strong engineering practices with clean abstractions and comprehensive testing.
openapi-python-client is a CLI tool and library that generates modern Python HTTP client libraries from OpenAPI 3.0 and 3.1 specification documents. It parses OpenAPI specs (YAML or JSON) into an internal representation of endpoints, models, and properties, then renders Jinja2 templates to produce a complete Python package with sync/async clients using httpx and attrs-based models. The generated code includes typed models with serialization/deserialization, endpoint functions with proper parameter handling, error types, and support for authentication, file uploads, and streaming responses. The architecture is modular: a schema layer (Pydantic models for OpenAPI objects), a parser layer that converts schemas into typed property objects and endpoint collections, a template layer (Jinja2 templates for all generated files), and a project builder that orchestrates generation and post-processing (ruff formatting/linting). The tool supports extensive customization via YAML/JSON config files, including class name overrides, field prefixes, content type overrides, custom template paths, and post-generation hooks. The codebase demonstrates strong engineering practices: comprehensive test coverage (unit, integration, end-to-end, and fuzz testing), security-conscious string handling to prevent code injection, a well-designed property type hierarchy with a protocol interface, and careful handling of OpenAPI edge cases like allOf merging, circular references, and union types. While the project is still in 0.x with breaking changes, it is actively maintained with regular releases and a responsive issue tracker.
Nebula is a local-first security workspace that combines AI-assisted chat interfaces, project management, security testing tools, and evidence collection into a desktop/web hybrid application. The system features a Python/FastAPI backend with SQLAlchemy/Alembic for data persistence, a TypeScript/React frontend with Tauri/Rust desktop shell, and extensive integration with external AI providers (Ollama, vLLM, Claude) and harnesses (Codex, Grok). Core functionality includes engagement scoping, asset discovery, vulnerability validation, remediation tracking, AI-powered agent workflows via subagents, structured result inspection, and diagnostic monitoring. The architecture emphasizes modularity with clear separation between domain models, storage, API, UI components, and state management, enabling extensibility through configuration-driven tool and provider integrations.
DIJI-NES is a high-performance NES (Nintendo Entertainment System) emulator designed to run on the ESP32-S3 microcontroller. It emulates the 6502 CPU, PPU graphics, and APU audio with cycle-level accuracy, supporting mappers 0-4 (NROM, MMC1, UxROM, CNROM, MMC3). The system renders 256x240 pixel frames at near-60 FPS to an ST7789 display via LovyanGFX and outputs audio through an I2S DAC (MAX98357A). It features a dual-core architecture: Core 0 handles audio generation and display DMA, while Core 1 runs the emulation loop. The firmware includes a ROM browser menu, save/load state support, volume control, and a particle boot animation. The codebase demonstrates deep NES hardware knowledge and aggressive optimization for embedded systems, including IRAM placement, lookup tables, bank caching, and frame-skip logic. While the main application is tightly coupled to the ESP32-S3 platform, the core emulation components (CPU, PPU, APU, cartridge) are well-isolated and could be extracted for reuse in other NES emulation projects.
GB Studio is a production-grade Electron desktop application for creating Game Boy and Game Boy Color games without writing code. It is a full visual IDE: scene and tilemap editors, sprite/metasprite editor, a music tracker with piano roll and instrument editing, a script event system (event definitions compile to GBVM bytecode), asset management for backgrounds/sprites/tilesets/fonts/sounds, and a debugger with ROM usage analysis. A separate web app (GBS Music) shares core music logic and offers a standalone browser-based tracker. The application is architecturally substantial: the Electron main process hosts multiple isolated renderer windows (splash, project, music, preferences, plugins), the renderer uses React 19 with Redux Toolkit for normalized entity state, Web Workers offload image processing and background scans, and a shared lib layer is reused across desktop and web builds.
eslint-plugin-project-structure is a TypeScript-based ESLint plugin that enforces scalable, consistent project architecture through three configurable rules: folder-structure enforcement, file-composition constraints (e.g., `**/*.consts.ts` may only contain variables, `**/*.types.ts` only interfaces/types), and independent-modules enforcement to prevent massive dependency trees. The plugin parses all import syntaxes — ESM, CJS, dynamic `import()`, `require()`, `jest.mock()`, `jest.requireActual()`, plus `ExportAllDeclaration`/`ExportNamedDeclaration` — and validates file paths against micromatch glob patterns. Configuration is provided via JSON files validated against a bundled JSON schema, enabling IDE autocompletion and early error detection. The codebase is a standard ESLint plugin library: rules receive AST nodes and report violations, with utility modules handling import classification, cross-platform path resolution (Windows/POSIX), and multi-pattern glob matching. It is distributed as compiled CommonJS (`dist/index.js`) with a self-referencing dev dependency for integration testing. The project ships with comprehensive tests covering edge cases like Windows paths, `@types/` scoped packages, and external-import detection, plus CI running type checks, format checks, lint, and tests via Yarn 3.6.3.
obsidian.nvim is a Neovim plugin that integrates Obsidian vault functionality directly into Neovim. It provides note creation, linking, completion, navigation, image handling, synchronization, and templating features for markdown-based notes. The plugin leverages Neovim's API for LSP integration, autocommands, buffer management, and picker interfaces (telescope, fzf, snacks, mini) to deliver an Obsidian-like experience within Neovim. It maintains a cache of note metadata for performance and supports multiple workspaces with per-workspace overrides. The architecture is modular, separating concerns into commands, LSP handlers, note management, workspace handling, caching, search, picker abstraction, and completion sources.
ByteRover CLI is an AI-powered development assistant that provides persistent, structured memory for AI coding agents through a context tree. It features a multi-layered architecture with CLI (OCLIF), TUI (React Ink), and WebUI (React/Vite) interfaces, backed by a daemon service handling core agent logic. The system enables knowledge curation, synthesis, version control for context trees, swarm-based querying across multiple LLM providers, and integration with external AI agents via MCP. Key capabilities include tool execution (file operations, code execution), review workflows for AI-generated changes, and telemetry tracking.
This repository provides a moment.js plugin for Jalaali (Persian) calendar support. It extends the moment.js library with additional methods and formatting tokens to parse, manipulate, and display dates in the Jalaali calendar system. The plugin includes bidirectional conversion between Gregorian and Jalaali calendars, language loading for Persian (with dialect and digit options), and full compatibility with moment.js API. It is designed for use in both Node.js and browser environments.
WhisperPlus is a Python library that provides enhanced speech processing capabilities built around Whisper models. It offers a modular pipeline architecture for speech-to-text transcription with optimizations like quantization and flash attention, text summarization (including long-text handling), speaker diarization, text-to-speech conversion, video auto-captioning, and retrieval-augmented generation for chatting with video content. The library integrates with Hugging Face Transformers, Apple MLX for optimized inference on Apple silicon, and various external services like YouTube downloading and vector databases for RAG functionality. The architecture follows a modular design with clearly separated pipelines for each functionality: core speech-to-text (whisper.py), summarization (summarization.py, long_text_summarization.py), text-to-speech (text2speech.py), diarization (whisper_diarize.py), auto-captioning (whisper_autocaption.py), and RAG chatbots (lancedb_chatbot.py, autollm_chatbot.py). Utility modules handle YouTube media downloading (download_utils.py) and text formatting (text_utils.py). The library provides both programmatic API access and a Gradio-based web interface (app.py) for interactive use, along with a CLI entry point (cli.py). Data flows typically begin with audio/video input (from files or YouTube URLs), proceed through specialized processing pipelines (transcription, summarization, etc.), and produce text, audio, or video outputs. For RAG features, transcripts are processed into vector stores enabling question-answering interactions. The library relies on established dependencies including torch, transformers, ffmpeg, pyannote.audio for diarization, and MLX-specific libraries for Apple silicon optimization, demonstrating practical integration of state-of-the-art models into an accessible toolkit.
proxpi is a caching reverse-proxy server for PyPI and any PEP 503-compatible package index. It fronts one or more upstream indices, serves the Python simple repository API to pip clients in both HTML (PEP 691 v1.0) and JSON (PEP 691 v1.1) forms, and performs correct HTTP content negotiation including Accept, Accept-Encoding, and Vary headers. Index responses (project list and per-project file lists) are cached in memory with per-index TTLs; package files are cached on disk with a configurable size cap and least-frequently-used eviction. When a requested file is still downloading in the background, the server emits a 302 redirect to the upstream URL rather than blocking the client. The system is a single-process Starlette ASGI application (proxpi.server:app) designed for multi-threaded serving under Gunicorn/Hypercorn, configured entirely through environment variables (index URLs, TTLs, cache size/dir, connect/read/download timeouts, SSL verification toggle, log level). Its main target is reducing pip install latency and upstream load in CI pipelines. The implementation is a compact three-layer design: server.py handles routing, templating, and compression; _cache.py holds the caching engine (a File abstraction with FileFromHTML/FileFromJSON parsers for the dual-format simple repository API, an _IndexCache with per-package locks and a fast-path that fetches project pages without refreshing the full index, and a _FileCache with background downloads, atomic os.replace writes, and LFU eviction); _server_utils.py provides RFC-correct content-negotiation helpers built on the stdlib email header parser. The code is thread-safe by design (per-key locks, exception-storing worker threads) and memory-efficient, streaming HTML index parsing through lxml.iterparse via a custom file-like response adapter. The test suite is notably strong: parametrized integration tests against mock HTML/JSON indices covering yanked files, core-metadata hashes, gpg-sig attributes, content negotiation edge cases, cache invalidation, and 404 paths, plus end-to-end tests that run real pip downloads against live PyPI. CI runs the matrix across Python 3.8-3.14, lints with black/isort, and publishes multi-arch Docker images with fully hash-pinned dependencies. One caveat: the README is stale, documenting the pre-1.3 Flask implementation, while the code has already migrated to Starlette (listed in CHANGELOG as unreleased), and the Docker image now runs Gunicorn with an ASGI worker.
Relm4 is a mature Rust GUI framework for GTK4/libadwaita that implements an Elm-inspired model/view/update architecture. The workspace ships four crates: relm4 (core components, factories, typed views, shared state, actions, workers, bindings), relm4-macros (procedural view!, component, factory, widget_template, and menu macros), relm4-components (reusable open/save dialogs, alert, web image, combo rows), and relm4-css (Adwaita CSS constants). Applications are built by defining a component struct and launching it via RelmApp::new(...).run::<App>(...); UI is described declaratively in view! with lifecycle hooks, message sending, and property bindings. Under the hood, the framework provides synchronous and asynchronous component/factory variants, diff-based factory collection updates, type-safe wrappers around GTK's ListView/GridView/ColumnView, message brokers for decoupled inter-component communication, and background workers. It depends on gtk4-rs, libadwaita, libpanel, flume, futures, tokio, and proc-macro2/syn, with feature flags for GNOME versions. The examples directory demonstrates production-style app patterns: multi-window apps, async workers, file dialogs, to-do lists, drag-and-drop, drawing, and tab factories. Maintenance is active and CI runs on GTK container images, but the codebase carries medium technical drift: it requires a high MSRV (edition 2024), allows several deprecated GTK APIs, and has significant duplication between sync/async factories and typed view implementations. The macro parser/codegen is intricate but well-tested with trybuild compile-fail tests. Overall this is a strong, reusable framework rather than a single application.
This is a full-stack cultivation world simulator game (xianxia RPG) with a Python backend (FastAPI + asyncio) and a Vue 3 + TypeScript + PixiJS frontend, supported by an optional Electron desktop shell for Epic Games Store distribution. The simulation engine runs a month-by-month tick system orchestrating ~29 phases (lifecycle, actions, social, war, world events, etc.) producing emergent narratives driven by LLM calls (OpenAI/Anthropic compatible) for character decisions, story generation, world lore rewriting, and roleplay interactions. The codebase is heavily data-driven with static game configurations (sects, techniques, items, regions) loaded from CSV files and multi-language localization via gettext PO files. It exposes a public REST API (query/command) and WebSocket for real-time state updates, supports save/load with JSON snapshots and SQLite event storage, and includes comprehensive test coverage (pytest, vitest, Playwright) and CI/CD workflows. While the architecture shows strong engineering patterns (effect system, action registry, single-choice decision framework, phased simulation pipeline), it carries risks from tight coupling of global singleton registries, LLM dependency, and use of `eval` in effect conditions.
This repository is a curated collection of tips, scripts, and a Claude Code plugin (dx) that enhances developer workflows with Claude Code. It is primarily a knowledge base and tooling repository, not a standalone application. The core deliverable is the dx plugin, which bundles skills for GitHub Actions debugging, conversation half/quarter-cloning, context handoffs, Reddit/HN research, private GitHub search, and version checks. The repository also includes a custom status line script (context-bar.sh), a setup script for recommended configurations, and extensive markdown content documenting 49 tips for using Claude Code effectively. The architecture is a mix of bash scripts, skill definitions (markdown with YAML frontmatter), and a plugin manifest. The standout component is the half-clone-conversation.sh script, a 400+ line bash utility that clones Claude Code conversations with careful edge-case handling, cross-platform support (macOS, Linux, Windows Git Bash), and a comprehensive 19-test suite. The repository demonstrates high craftsmanship in its bash scripting, thorough testing, and detailed documentation of workarounds for platform limitations (e.g., Reddit's blocking, GitHub's private repo search).