AFFiNE is a cross-platform, block-based knowledge management application that combines notes, whiteboards, and databases in a local-first, real-time collaborative environment. Built on the BlockSuite editor framework, it features a modular architecture with extensible components, AI-powered capabilities (Copilot), and support for embedding external content. The application consists of a web client, desktop client (Electron), and mobile clients (iOS/Android), backed by a Node.js/NestJS server with Prisma ORM and Rust performance modules. Data is synchronized via Yjs CRDTs with a custom storage layer (nbstore) for offline-first capabilities.
Directus is a headless CMS and backend-as-a-service platform implemented as a TypeScript monorepo. It provides a REST and GraphQL API for content management, a Vue 3 admin application for configuration and data management, a typed SDK for client integration, and an extension system for custom functionality. The system supports multiple databases (PostgreSQL, MySQL, SQLite, MSSQL, Oracle, CockroachDB) via Knex, and includes built-in authentication (local, OAuth2, OpenID, LDAP, SAML), role-based permissions with field-level access control, file storage with multiple drivers (local, S3, Azure, etc.), and a flows automation engine. Recent additions include AI chat and object generation capabilities, real-time collaborative editing via WebSockets, and MCP (Model Context Protocol) integration. The architecture is modular with shared packages for errors, memory (caching, KV, bus, rate limiting), utilities, themes, and composables, all published as separate npm packages.
This repository is a web application for generating privacy policies and terms of service for mobile and web apps. Built with Vue.js 3 and Bulma CSS, it features an 8-step wizard interface where users configure policy type (Simple, No Tracking, GDPR), app details, platforms, features, and third-party services. The application generates customized HTML/Markdown policies deployable to Flycricket or downloadable directly. It includes a PWA with service worker for offline support, internationalization (English/German), and a persistent theme toggle. The architecture centers on Vue composables for state management (app state, wizard navigation, content generation) and a Go-based build system that processes Go templates, compiles Less to CSS, and minifies assets. Key reusable patterns include modular template mixins, a flexible modal system, and utility functions for DOM manipulation. An ancillary tool in `tools/reviews-page-generator` fetches GitHub issue comments to generate a static testimonials page. The codebase demonstrates strong engineering practices: comprehensive Playwright test suite, golden HTML regression tests, dependency management via Go modules and package.json, and automated deployment workflows. While the custom build pipeline adds slight complexity, the separation of concerns and reusable components indicate maintainable, craftsmanship-driven development.
This is a Home Assistant addon that runs Tailscale inside a supervised container, providing a zero-config VPN for building secure networks. The addon orchestrates multiple processes via s6-overlay: tailscaled, a web UI, nginx for ingress, and dnsmasq for MagicDNS proxying. It handles complex networking including iptables DNAT for forwarding tailnet connections to the host, MSS clamping, subnet route protection to avoid collisions with tailnet routes, and Tailscale Serve/Funnel for exposing Home Assistant with TLS. It also supports Taildrop file sharing and Taildrive directory sharing. The architecture is a single container with tightly integrated services, all configured through Home Assistant's addon options. The codebase is well-structured with robust error handling and health checks, but is tightly coupled to the Home Assistant Supervisor environment via bashio and the hassio-addons base image.
Papra is a self-hostable, open-source document management platform that provides a full-stack solution for archiving, organizing, and searching documents. The system consists of a Hono-based API server with SQLite (via Drizzle ORM and libsql/Turso), a SolidJS web client, a React Native mobile app (Expo), a CLI tool, and several standalone packages. It supports multi-tenant organizations, role-based access, document upload with content extraction (OCR via Tesseract, Mistral OCR, Azure Document Intelligence, Docling, and a custom HTTP strategy), full-text search via SQLite FTS5 with a custom query parser, tagging with automatic tagging rules, document sharing with password-protected links, intake emails, webhooks, and subscriptions with Stripe integration. The architecture is modular, using repository and usecase patterns, an in-process event system, and a driver-based approach for storage (filesystem, S3, Azure Blob), email delivery, and KV stores. The codebase is heavily tested with unit, integration, and e2e tests, and includes a comprehensive demo mode.
Piral is a production-grade micro-frontend framework that enables building modular single-page applications (SPAs) with independently developed, runtime-integrated modules called pilets. The repository is a monorepo containing the core framework (piral-core, piral-base, piral), a CLI toolchain (piral-cli, piral-cli-webpack5), over 20 feature plugins (authentication, UI components, state management, search, notifications, etc.), and 15+ framework converters (React, Vue, Angular, Svelte, Blazor, etc.). The core architecture provides a shell application with pilet loading, extension slots, event system, shared dependency management via import maps, and state management using Zustand. The CLI supports scaffolding, building, debugging, validation, and publishing of both pilets and Piral instances. The codebase demonstrates strong engineering practices with extensive TypeScript, unit tests (Vitest), and a consistent plugin/converter pattern. Some technical drift exists in legacy pilet specifications and multiple router version adapters, but the project remains actively maintained.
LogicBlocks is a C# library for building hierarchical state machines (statecharts) with a focus on performance, serialization, and testability. It provides a `LogicBlock` base class that manages state transitions via input handlers (`IGet<TInput>`), supports pushdown automaton history, async task integration, and observable bindings. The library includes an `AutoBlock` extension for automatic state preallocation and serialization using Chickensoft's introspection and serialization frameworks, and a Roslyn source generator (`DiagramGenerator`) that produces PlantUML state diagrams from annotated state classes. The codebase is well-structured with extensive unit tests, clean separation of concerns, and a fluent API for bindings. It is designed for AOT environments and game development (Godot). The repository also contains a tutorial and a vending machine example.
learnX is a React Native/Expo mobile application designed for Tsinghua University students to access the Web Learning platform (learn.tsinghua.edu.cn). It provides features such as SSO authentication, course management, assignment tracking, file handling, calendar synchronization, and course information sharing via the courseX platform. The app uses Redux for state management, React Navigation for routing, and React Native Paper for UI components, with TypeScript ensuring type safety. It includes background data synchronization and supports iOS, Android, macOS, and Windows (via WSA).
An Android application that converts websites and web applications into standalone native Android APK/AAB packages. It bundles multiple server runtimes (Python, Node.js, PHP, Go) and generates a self-contained app that runs the web server on-device, providing a full native shell with WebView/GeckoView rendering. The app also includes an AI agent system that can read, edit, and manage web app projects, a Chrome extension module system, privacy isolation features, and a comprehensive APK builder with binary XML patching, permission pruning, and signing. The codebase is well-structured with a modular design (app, shell, clone-host), extensive test coverage, and a strong emphasis on security and privacy.
EhViewer is a high-performance Android client for browsing, reading, and downloading galleries from the E-Hentai / ExHentai image hosting sites. It is a modern fork of the classic EhViewer app, built entirely with Kotlin Multiplatform for shared logic and Jetpack Compose with Material Design 3 for the UI. The architecture is modular (app, core/common, core/data, core/ui, core/i18n) and leverages Rust via JNI for performance-critical HTML parsing and image processing (border detection, QR code detection, WebP animation). The app features a full-featured reader with multiple reading modes, a foreground download service with speed tracking, comprehensive offline support via Room/SQLite, and integration with GitHub releases for updates. The codebase is actively maintained, uses the latest Kotlin, Compose, and Ktor versions, and demonstrates strong engineering practices with clean abstractions, coroutine-based reactive state, and type-safe preferences. It is a dedicated application project with no data science or research components.
Butterfly is a cross-platform, open-source note-taking application built with Flutter, offering an infinite canvas for drawing, writing, and organizing notes. It supports a wide range of tools including pen, eraser, shape, text, laser, ruler, stamp, and area management, along with features like layers, pages, waypoints, backgrounds, textures, and real-time collaboration via WebSocket or Swamp protocols. The application can export to PDF, SVG, PNG, and Xournal++ formats, and integrates with WebDAV for file synchronization and backup. It is available on Android, Windows, Linux, macOS, iOS, and web platforms. The architecture follows a BLoC/Cubit pattern for state management, with a clear separation of concerns: handlers manage tool interactions, renderers draw elements on the canvas, and selections provide property editing UIs. The core data models are defined in a separate Dart package (`butterfly_api`) using freezed and json_serializable for immutable, serializable objects. The app uses a custom file system abstraction (`lw_file_system`) to support local, WebDAV, and Android SAF storage backends. Keyboard shortcuts are declaratively defined via an Action/Intent system, and the app supports embedding via a postMessage bridge for iframe integration. Key entry points include `app/lib/main.dart` for app bootstrap, `app/lib/bloc/document_bloc.dart` for central document state, and the various handler and renderer files in `app/lib/handlers/` and `app/lib/renderers/`. The application relies on external dependencies such as Flutter SDK, flutter_bloc, freezed, archive, phosphor_flutter, pdfrx, and material_leap. The codebase is actively maintained with frequent releases, extensive localization (20+ languages), and a comprehensive documentation site built with Astro/Starlight.
Sniffnet is a cross-platform desktop GUI application for real-time network traffic monitoring and analysis, written in Rust using the Iced framework. It captures packets via pcap (live or from PCAP files) and also supports IPFIX flow collection over UDP. The application parses Ethernet, IP, TCP/UDP, ICMP, IGMP, ARP, and VLAN headers using a dedicated packet-parser library. It enriches captured traffic with geolocation (MaxMind GeoLite2 and IPinfo MMDB databases), ASN lookups, service identification (from a port-to-service map derived from nmap-services), and local process identification (via the listeners crate). The GUI provides multiple pages: an overview with live traffic charts and donut charts, an inspect page with a filterable and sortable connection table, a notifications page for alerts (thresholds, favorites, IP blacklists), and settings pages for themes, filters, and export. The application supports 25 languages, custom themes, and thumbnail mode for minimal monitoring. It is packaged for Linux (deb, rpm, AppImage), macOS (dmg), and Windows (msi), with CI/CD pipelines for cross-compilation and code signing.
Weylus is a cross-platform application that turns tablets and smartphones into graphic tablets/touch screens for computers. It operates by running a local web server that serves a web page to the tablet's browser. The web page captures pointer, touch, stylus, keyboard, and wheel events via JavaScript PointerEvents and sends them over a WebSocket connection to the server. The server then simulates these input events on the host machine using platform-specific mechanisms: on Linux it uses the uinput kernel module for full stylus/touch/mouse/keyboard support; on macOS and Windows it falls back to the autopilot library for mouse/keyboard simulation and Windows-specific synthetic pointer injection for touch/pen. Simultaneously, Weylus captures the screen (or a selected window/monitor) using platform-native APIs: X11 shared memory (XShm) on Linux X11, PipeWire/GStreamer on Wayland, CoreGraphics on macOS, and DirectX via captrs on Windows. The captured frames are encoded into a fragmented MP4 H.264 video stream using a statically linked ffmpeg (libx264) with optional hardware acceleration (VAAPI, NVENC, VideoToolbox, MediaFoundation). The video stream is sent to the browser via the same WebSocket connection and played using the Media Source Extensions API. The application provides a GUI (built with FLTK) for configuration and a headless mode for automation. It supports access codes, custom input areas, and multiple simultaneous clients.
Gifski is a polished macOS application that converts video files into high-quality animated GIFs. The application uses a hybrid architecture: a SwiftUI frontend handles the user interface, video decoding (via AVFoundation), real-time preview compositing (via Metal shaders), and system integration (Share Extension, Shortcuts), while the core GIF encoding is performed by a companion Rust library (gifski-api) exposed through a C API. Key data flows involve decoding video frames, optional cropping/trimming/resizing, temporal denoising and palette quantization in the Rust engine, and finally writing the GIF output. The codebase demonstrates solid engineering with actor-based concurrency, comprehensive unit tests, and reusable UI components. However, it carries technical drift from macOS version workarounds and deprecated Rust API usage, and targets a future macOS version (26+) not yet generally available.
Latest is a native macOS application that aggregates and manages software updates from multiple sources: the Mac App Store (via private frameworks CommerceKit/StoreFoundation), Sparkle-based apps (by parsing appcast feeds), and Homebrew Cask (via the Homebrew API). It scans local application directories, identifies installed apps, checks for updates, and provides a unified UI to view release notes, update individual apps, or update all at once. The architecture follows a monolith pattern with clear separation: model layer (App, Update, Version), update checkers (MacAppStoreCheckerOperation, SparkleCheckerOperation, HomebrewCheckerOperation), update executors (MacAppStoreUpdateOperation, SparkleUpdateOperation), and a Cocoa-based UI with table views, search, and Touch Bar support. The codebase demonstrates solid Swift engineering with custom NSOperation subclasses, observable patterns, and a well-tested version parser. However, it relies on private macOS frameworks and has some code quality issues (forced unwraps, fatalError usage, a typo in struct name 'Sparke'). The project is actively maintained with extensive localization and community contributions.
FairEmail is a fully-featured, open-source, privacy-oriented email client for Android. It supports IMAP, POP3, SMTP, OpenPGP, S/MIME, and OAuth for major providers (Gmail, Outlook, Yahoo). The app is built as a standard Android application with Activities, Fragments, Services, and WorkManager workers. It uses Room for local persistence, LiveData for reactive UI, and a custom async pattern (SimpleTask) for background operations. The codebase is notable for its extensive use of vendored libraries: it includes modified copies of JavaMail (javax.mail, com.sun.mail), AndroidX internals (Room, Paging, Emoji2, RecyclerView Selection), Google Protocol Buffers, and native language/encoding detection engines (CLD3, compact_enc_det). This hybrid approach provides deep email protocol support and privacy features like tracker blocking, certificate transparency, and DANE, but also introduces maintenance overhead and potential drift from upstream versions. The app integrates AI features (Gemini, OpenAI) for summarization and rule actions, and includes a full rule/filter engine. Despite the heavy vendoring, the core application code demonstrates solid engineering with clean abstractions, custom views that work around Android platform bugs, and a consistent async pattern. The repository is actively maintained with frequent releases and responsive issue triage.
Pydoc-Markdown is a Python library and CLI tool for generating API documentation in Markdown format from Python source code. Unlike many documentation tools, it does not execute the code but instead parses it using the docspec library, making it safe for use with untrusted code. The system features a plugin architecture with loaders (currently only Python), processors (for converting docstrings from Google, Sphinx, Pydoc-Markdown formats to Markdown), renderers (for outputting to Markdown files, MkDocs, Hugo, Docusaurus, or Jinja2 templates), and source linkers (for generating links to source code on GitHub, GitLab, etc.). It can be configured via YAML, TOML, or used programmatically. The project also integrates with Novella for Markdown preprocessing, allowing inline @pydoc tags in documentation files. The codebase is well-structured with clean interfaces, comprehensive test coverage, and a well-defined plugin system. It demonstrates solid software engineering practices including dependency injection, configuration via dataclasses, and entry-point-based plugin discovery. The project has been actively maintained with regular releases and community contributions, though the maintainer has noted limited time for development. The architecture supports extensibility, making it suitable for integration into documentation pipelines for Python projects.
SmsForwarder is an Android application written in Kotlin that monitors SMS messages, incoming calls, and app notifications on a device and forwards them to multiple third-party channels such as DingTalk, WeChat Work, Feishu, Telegram, email, Bark, Webhook, and others. It also provides a local HTTP server for remote control (query/send SMS, call logs, contacts, battery status, location, and Wake-on-LAN) and an automation engine with configurable conditions (cron, battery, network, Bluetooth, location, screen state, etc.) and actions (forward, send SMS, trigger alarm, control frpc tunnels, etc.). The architecture follows a standard Android pattern with Room database, WorkManager for background tasks, XUI for UI components, and a fragment-based navigation system. The codebase is large and feature-rich, with over 15 sender channels and a flexible rule engine, but exhibits some technical debt such as deprecated API usage, hardcoded vendor-specific intents, and a few large monolithic fragments.
DevDocs is a web application that aggregates and serves API documentation for hundreds of programming languages, frameworks, and tools in a unified, searchable, offline-capable interface. The backend is a Ruby/Sinatra server that provides the static assets and a minimal API, while the frontend is a custom JavaScript single-page application with client-side search, keyboard navigation, and a service worker for offline access. The core data generation pipeline consists of Ruby scrapers that fetch documentation pages from official sources, apply a chain of filters (HTML cleaning, entry extraction, URL normalization, image optimization), and produce normalized JSON indexes and cached pages stored on disk. The architecture is largely monolithic with a strong separation between the scraping pipeline (lib/docs) and the frontend (assets/javascripts). While primarily an application, it contains a substantial data engineering component in its scraper/filter system, which is reusable and generalizable for other documentation aggregation projects.
Spam Call Blocker is an Android application written in Kotlin that blocks unwanted incoming calls using a combination of local blocklists, pattern matching, and real-time checks against multiple online phone reputation services (UnknownPhone, Tellows, Truecaller, and regional directories). It registers a call screening service to intercept calls, evaluates them against user-defined rules and external APIs, and can block, mute, or answer-and-hangup spam calls. The app provides a full settings UI for managing blocked/whitelisted numbers, pattern-based blocking, API toggles, and export/import of configuration. It also includes a donation screen and automatic update checking via GitHub releases. The codebase is well-structured with clear separation of concerns, uses Kotlin coroutines for concurrent API checks, and supports multiple languages.