This repository is the official compiler, standard library, and toolchain for the V programming language. It is a self-hosting, multi-backend compiler (primarily targeting C, with experimental JS and WASM backends) that produces highly optimized native executables. The standard library is exceptionally comprehensive, offering built-in support for cryptography (AES, SHA3, Ed25519, TLS via mbedtls), compression (gzip, zstd, lz4, snappy), database connectivity (SQLite, MySQL, PostgreSQL, MSSQL, Redis), a full web framework (veb), graphics (gg, sokol), and CLI development tools. The architecture is a monolithic compiler with a modular standard library. The compiler pipeline involves scanning, parsing, type-checking, and code generation. The build system uses a multi-stage bootstrap process. The codebase demonstrates extremely high craftsmanship, with clean abstractions, extensive test coverage, and reusable components. It is actively maintained with a large community. Key reusable components include the pure-V implementations of cryptographic primitives (Ed25519, SHA-3), compression algorithms (LZ77, Snappy), data structures (lock-free ring buffer, FSM), and the CLI framework. These modules are isolated, well-tested, and could be extracted for use in other projects with minimal modification.
Fusion Transpiler (fut) is a self-hosting, multi-target transpiler that translates code written in the Fusion language into C, C++, C#, D, Java, JavaScript, Python, Swift, TypeScript, and OpenCL C. The repository contains the complete compiler implementation written in Fusion itself, including a lexer, parser, semantic analyzer, and a family of code generators organized via a visitor pattern. It also includes a comprehensive test suite, command-line interfaces for multiple host languages (C++, C#, Java, Node.js), editor integrations (VS Code, Vim, Sublime, Visual Studio, LSP server), and packaging for Debian, Windows, and RPM. The architecture follows a classic compiler pipeline with a clear separation of concerns, and the self-hosting bootstrap ensures the compiler is exercised on its own code. This is a pure application project with no data processing or research components; it is a production-quality compiler toolchain.
This is a Laravel package that enables self-hosting of Google Fonts by fetching font CSS and asset files from Google's servers, storing them locally on a configurable filesystem disk, and serving them via Blade directives. The core logic resides in the `GoogleFonts` service class, which handles downloading, caching, and rendering fonts either inline or as external stylesheets with optional preload support. The package provides a fallback mechanism to load fonts directly from Google if local storage fails. It is well-tested with Pest and snapshot assertions, supports a wide range of Laravel versions (8–13) and PHP 8.0+, and follows Spatie's typical high-quality package structure with clean separation of concerns, config-driven behavior, and a dedicated Artisan command for prefetching fonts.
PrivateBin is a self-hosted, zero-knowledge pastebin web application. The PHP backend (Controller, Model, Data) handles paste/comment lifecycle, expiration, deletion, traffic limiting, and storage backend selection; the JavaScript frontend performs all encryption/decryption in the browser using AES-256-GCM (WebCrypto) with PBKDF2 key derivation and optional zlib/WASM compression. The server only ever stores ciphertext and metadata, never plaintext. Data flows from browser encryption into a pluggable persistence layer (filesystem, PDO database, Google Cloud Storage, S3), then back to the browser for decryption; JSON API endpoints accept and return encrypted bodies. Architecturally it is a classic server-rendered MVC app with a frontend state layer: index.php bootstraps a Controller, which delegates to Paste/Comment models over an AbstractData storage interface. Views are rendered via PHP templates with Bootstrap 3/5 themes, and the frontend is a vanilla-JS module namespace (PrivateBin) with submodules for encryption, editor, viewer, discussion, attachments, and i18n. The feature set includes expiration times, burn-after-reading, password-protected pastes, discussion threads, file attachments, URL shortening proxies (YOURLS/Shlink), QR codes, dark mode, and multi-language support. Engineering practices are strong for a mature open-source project: PHPUnit tests cover backend behavior, fast-check property tests cover frontend utilities, CI includes CodeQL/Snyk scans, and security hardening (DOMPurify, CSP, SRI hashes, HTTPS guidance) is explicit. Maintenance is active with recent commits and issue triage. Technical drift is moderate: the project retains legacy browser support and old Bootstrap 3/darkstrap assets, still supports PHP 7.4, and ships a monolithic JS file without a build step, but pinned frontend libraries (Bootstrap 5.3.8, Showdown 2.1.0, DOMPurify 3.4.17) are current.
This repository is a full-stack Next.js application that serves as the world's largest open-source prompt library for AI. It provides a platform for users to create, share, discover, and manage prompts for various AI models (ChatGPT, Claude, Gemini, etc.). The core functionality includes CRUD operations for prompts with types (text, image, video, audio, skill, taste), voting, commenting, versioning, change requests, collections, and moderation tools. It features AI-powered capabilities such as semantic search via OpenAI embeddings, prompt improvement, translation, quality checking, and media generation through plugin-based providers (Fal.ai, Wiro.ai). The application supports multi-tenancy for self-hosting with configurable branding, authentication plugins (OAuth, OIDC, GitHub, Apple, Google), and storage backends (S3, DO Spaces). Beyond the web app, it includes a CLI tool (packages/prompts.chat) for browsing and running prompts locally, a Raycast extension for quick access, and an MCP server for integration with AI coding assistants. Additionally, it bundles an interactive educational book on prompt engineering (28+ chapters) and a gamified kids learning section, both fully localized into 17 languages. The codebase is well-structured with a plugin registry pattern, configuration-driven design, and extensive use of modern Next.js patterns (App Router, server components, streaming).
Coolify is a self-hosted Platform-as-a-Service (PaaS) that enables users to deploy and manage applications, databases, and services on their own infrastructure. It serves as an open-source alternative to Heroku, Netlify, or Vercel, supporting Docker-based deployments with Git integration (GitHub, GitLab, Gitea, Bitbucket), multiple build packs (Railpack, Nixpacks), and one-click service templates. The system manages servers, reverse proxies (Traefik/Caddy), SSL certificates, scheduled backups, and multi-channel notifications (email, Discord, Slack, Telegram, Pushover, webhook). The architecture is a Laravel monolith with a Livewire + Alpine.js frontend for the v4 UI and a React + TypeScript canvas-based interface for the v5 UI. Background jobs are handled by Laravel Horizon with dedicated queues for deployments, cron tasks, and reconciliation. Real-time updates use Soketi (a Pusher-compatible WebSocket server) and Laravel Echo. The system integrates with cloud providers (Hetzner, Vultr, DigitalOcean) for server provisioning and Stripe for subscription billing. A Model Context Protocol (MCP) server exposes resources and tools for AI assistant integration. Key data flows include: webhook ingestion from Git providers triggering deployment jobs, SSH-based remote command execution on managed servers, Docker Compose parsing and environment variable injection, database backup scheduling with S3 storage, and proxy configuration generation. The v5 architecture introduces a control-plane/agent split with Flux (HTTP socket) and coold (gRPC) components for improved scalability and isolation. External dependencies include Docker, PostgreSQL, Redis, Soketi, Stripe API, cloud provider APIs, and various notification service endpoints. The codebase is actively developed with frequent schema migrations and a dual v4/v5 code path, indicating ongoing architectural evolution.
TriliumNext/Trilium is a full-stack, cross-platform hierarchical note-taking application with rich text editing, LLM integration, sync, encryption, and a plugin-based architecture. The monorepo contains a Node.js Express server (SQLite backend), a Preact/React SPA client, an Electron desktop wrapper, a standalone browser-SQLite-WASM build, and a Capacitor mobile app. The system manages notes as a tree with cloning, attributes, relations, and multiple content types (text, code, mind maps, canvases, spreadsheets, calendars, etc.). It provides custom CKEditor5 plugins for math, footnotes, mermaid diagrams, and AI assistance, as well as a full-featured LLM chat with tool execution and skill sheets. The codebase is well-tested with over 2000 spec files, uses modern TypeScript and pnpm workspaces, and includes comprehensive import/export (Evernote, OneNote, Obsidian, Notion, Google Keep, OPML, Markdown, HTML) and sync capabilities. Key architectural patterns include a provider abstraction for platform-specific services (crypto, zip, messaging, clipboard), a component-based widget system on the client, and a centralized entity cache (becca/froca) that is synchronized via WebSocket.
Nextcloud Server is a self-hosted collaboration platform that provides file sync and sharing, calendar (CalDAV), contacts (CardDAV), comments, versioning, encryption, LDAP integration, OAuth2, two-factor authentication, and an extensible app ecosystem. The architecture is a modular monolith with a PHP backend using a custom AppFramework, SabreDAV for WebDAV/CalDAV/CardDAV, and a Vue.js frontend (mixing Vue 2 and Vue 3). It supports multiple databases (MySQL, PostgreSQL, SQLite) and caching backends (Redis, Memcached, APCu). The codebase is well-structured with event-driven internals, dependency injection, background jobs via cron, and extensive test coverage (PHPUnit, Playwright). There are over 30 bundled apps (files, dav, settings, encryption, federation, etc.) that follow plugin architecture. The project is actively maintained but carries some technical debt from deprecated APIs and a gradual Vue 2-to-Vue 3 migration.
This repository is a documentation/runbook, not a software application. It teaches how to secure a Linux server through a long, well-organized markdown guide aimed primarily at Debian-based systems. The content covers SSH key authentication and sshd_config hardening, PAM-based 2FA/MFA and password quality, UFW firewall configuration including Docker interactions, intrusion detection/prevention with fail2ban, CrowdSec, and PSAD, and auditing tools such as AIDE, ClamAV, rkhunter, chkrootkit, logwatch, Lynis, and OSSEC. It also includes a separate kernel sysctl hardening reference table and a short nginx security headers guide. In production, the repository itself does not run anything; its value is the curated collection of copy-paste-ready shell commands, configuration snippets, and operational guidance that a human administrator applies to a server. The architecture is a set of static markdown files with a consistent section pattern (Why, How It Works, Goals, Steps, References), backup-before-edit conventions, and validation steps after changes. The main README is effectively an evolving security runbook with a detailed table of contents, while the auxiliary markdown files serve as standalone reference assets. Recent updates show active maintenance: the guide has been revised for Debian 13 systemd-timesyncd, OpenSSH 9.1 RSA size enforcement, Docker and UFW bypass caveats, and CrowdSec installation. However, some older recommendations remain dated—for example, certain sysctl keys in the hardening table are obsolete or no longer present in modern kernels, and several linked references are from 2018-2019. Because this is a documentation repository rather than executable code, quality assessment focuses on information architecture, practical utility, and reusability rather than software engineering structure.
Ruby2JS is a Ruby-to-JavaScript transpiler with a modular filter architecture. It converts Ruby source code into JavaScript by parsing Ruby AST (via Parser gem or Prism) and applying a pipeline of filters that transform Ruby idioms into JS equivalents. The project includes a self-hosting capability (transpiles itself to JS), a Rails-like micro-framework called 'juntos' for building full-stack JS apps, and build tool plugins for Vite, esbuild, Rollup, and Webpack. It supports multiple output targets (ESM, CJS, JSX, React, Lit, Stimulus, etc.) and framework-specific filters for Rails, Phlex, Vue, Svelte, Astro, and more. The architecture is well-structured with clear separation between parsing, filtering, conversion, and serialization. The codebase is actively maintained with extensive test coverage and a monorepo structure for npm packages.
Khue's Homelab is a GitOps-driven infrastructure-as-code framework that automates a complete self-hosted Kubernetes platform from bare metal to user-facing applications. The codebase is organized into five layers: metal (Ansible roles that PXE-boot Fedora Server, bootstrap a k3s cluster with kube-vip HA, and install Cilium for networking/load balancing), system (bootstrap Helm charts for ArgoCD, cert-manager, ingress-nginx, Rook Ceph, and monitoring), platform (Gitea, Woodpecker CI, Grafana, Kanidm identity, Dex SSO, zot container registry), apps (Jellyfin + the *arr stack, Matrix, Paperless, Ollama, and more), and external (Terraform-managed Cloudflare DNS, tunnel, and ntfy alerting). ArgoCD ApplicationSets watch the git repository and deploy every Helm chart, making the repo itself the source of truth; a single top-level `make` drives the entire pipeline. The project demonstrates strong IaC craftsmanship: idempotent Ansible roles with checksum-verified downloads and run_once state handling (k3s token genesis, kubeconfig extraction), an ephemeral PXE server with per-MAC kickstart files and DHCP-proxy mode, declarative random secret generation via a small Go tool combined with the External Secrets Operator for cross-namespace secret sync, and a Terraform module that creates least-privilege Cloudflare API tokens injected directly into the cluster. It also includes a Nix dev shell for reproducible tooling, pre-commit hooks, Woodpecker CI that renders Helm diffs on pull requests, and Terratest-based smoke/integration/version tests. The author explicitly labels the project ALPHA and recommends forking for personal use. It is best treated as a reference architecture and a collection of reusable provisioning patterns rather than a turnkey product; some portions (scripts/hacks, take-screenshots, the gitea config job) are acknowledged work-in-progress, and a few pinned versions lag the ecosystem (Go 1.19 in-cluster compile jobs, k3s 1.30, several stale container image tags).
This monorepo houses the entire Start9 ecosystem, centered on StartOS—a self-hosted Linux distribution for personal servers. The repository encompasses multiple products: StartOS (server OS with container orchestration, backup, networking, and marketplace), StartWRT (router firmware based on OpenWrt), StartTunnel (WireGuard-based tunnel service), StartCLI (command-line tool), StartRegistry (package registry), and StartSDK (TypeScript SDK for building service packages). The architecture is a hybrid of Rust backend services (using async Tokio, axum, and a custom RPC toolkit) and Angular frontends (using Taiga UI and a reactive PatchDB state store). Key orchestration is handled by the container runtime (Node.js with LXC) and a custom diff-based database (PatchDB) for real-time UI synchronization. The system manages service lifecycle, ACME certificates, DNS, port forwarding, VPNs, encrypted backups, and firmware updates. External dependencies include Linux kernel features (LXC, btrfs, eCryptFS, FUSE, nftables), WireGuard, and standard Rust/Angular libraries. The codebase is actively maintained with frequent version migrations and CI/CD pipelines, but carries some duplication across products and technical debt from rapid evolution.
Nanocl is a distributed container orchestration system designed as a Kubernetes alternative, focusing on simplicity and declarative state management. The system manages workloads termed 'Cargoes' (containers), 'VMs', and 'Jobs' using Docker as the underlying runtime. It features a client-server architecture with a CLI (`nanocl`), a central daemon (`nanocld`), and auxiliary sidecar services for proxying (`ncproxy`) and DNS (`ncdns`). The architecture relies on Rust for performance and safety, utilizing `ntex` for async HTTP handling and `diesel` for database persistence. The core operational model is driven by declarative Statefiles (YAML/TOML/JSON) processed with Liquid templating. These files define the desired infrastructure state, which the daemon reconciles against the actual runtime state. The system integrates directly with the Docker daemon via the `bollard` library to manage container lifecycles, networking, and images. It features a robust event-driven architecture where state changes trigger sidecar updates, such as Nginx configuration regeneration for routing. The codebase demonstrates a modular design with shared crates for error handling, stubs, and utilities. It implements a generic repository pattern for database access and abstract lifecycle traits for resource management. The API is versioned and documented via OpenAPI/Swagger, supporting RESTful CRUD operations and real-time event streaming. While the project shows strong architectural patterns, it carries medium technical drift due to API versioning fragmentation and heavy dependency on Docker API behavior.
This repository is a large collection of Bash scripts that automate the deployment, configuration, and update of self-hosted services on Proxmox VE, primarily through LXC containers and VMs. It is a provisioning and automation framework rather than a runtime application: each ct/*.sh script declares resource variables (CPU, RAM, disk, OS template) and an optional update_script(), while install/*.sh scripts run inside an existing container to install a specific application. Usage is typically a one-line curl command executed as root on the Proxmox host, after which the script creates a container/VM, installs dependencies, generates credentials, writes systemd units or OpenRC init scripts, and configures databases and reverse proxies. The architecture is layered: hundreds of app-specific scripts wrap a smaller set of shared Bash function libraries in the misc/ directory (build.func, install.func, vm-core.func, core.func, error_handler.func). These shared functions handle common operations such as fetching GitHub releases, setting up language runtimes, creating databases, backing up configs before updates, and standardizing error handling. Update flows generally stop the service, back up configuration/data, fetch the latest release, restore the backup, run migrations, and restart the service. This consistency is the project's main strength and makes adding a new container recipe relatively straightforward. Weaknesses are typical of a large community-driven shell-script collection: no unit tests, heavy reliance on third-party installers fetched via curl|bash, some hardcoded versions, and external dependencies on GitHub release asset names and remote core-library URLs. Many scripts assume Debian/Ubuntu or Alpine bases and run as root with no signature verification. Despite these risks, the codebase is actively maintained, consistently formatted, and the shared function libraries are practical examples of reusable Bash abstractions for Proxmox automation.
ScaleTail is a curated collection of Docker Compose configurations for self-hosting 80+ services with a consistent Tailscale sidecar pattern. Each service directory contains a `compose.yaml` that defines a `tailscale` container (using `tailscale/tailscale:latest`) and an application container using `network_mode: service:tailscale`, enabling secure HTTPS access via Tailscale Serve or MagicDNS. The repository provides environment-driven configuration (`.env` files), health checks, and per-service READMEs. It is not a standalone application or library but a deployment template repository. The dominant character is 'application' as it facilitates deploying applications, though it is purely configuration and documentation. The pattern is highly reusable for any Docker-based self-hosted service wanting Tailscale integration.
ownCloud Core is the server-side component of ownCloud Classic, a file synchronization and sharing platform. In production, it provides file storage, synchronization, sharing (internal and federated), WebDAV/CalDAV/CardDAV access, versioning, trash bin, system tags, comments, external storage backends (SMB, SFTP, WebDAV, Google Drive, etc.), encryption, user/group management, and a plugin architecture for extending functionality. The system handles file upload/download via WebDAV or OCS API, manages sharing permissions and propagation, runs background jobs for maintenance (expiration, cleanup, sync), and supports federation between ownCloud instances. The architecture is a monolithic PHP application with a plugin system (apps) that register capabilities, routes, settings panels, and background jobs. Key entry points include index.php (main request handler), occ CLI (Symfony Console commands for admin tasks), cron.php (background job execution), and apps/dav/appinfo/v2/remote.php (WebDAV server). The codebase uses a custom PHP framework with namespaced public interfaces (OCP) and internal implementations (OC), SabreDAV for WebDAV/CalDAV/CardDAV, Symfony Console for CLI, Doctrine DBAL for database migrations, and Guzzle HTTP client for federation. Primary data flows involve file operations (upload, download, move, copy) through the filesystem abstraction layer, with metadata stored in a relational database (MySQL, MariaDB, PostgreSQL, SQLite). Sharing creates permission records and propagates changes via event hooks. Federation uses OCM protocol for cross-server sharing. Background jobs handle trash expiration, version cleanup, external storage scanning, and federation sync. External dependencies include a database server, optional memcached for caching, and external storage services (SMB, SFTP, WebDAV servers, Google Drive). The codebase is large (7844 files) with extensive localization (20+ languages) and testing (PHPUnit, Behat acceptance tests, JS specs). It shows signs of ongoing maintenance with recent commits and CI activity, but also contains legacy code, deprecated interfaces, and a custom PHP dialect (traits via use keyword) that may hinder standard tooling.