Metabase is an open-source business intelligence platform that enables users to query, visualize, and share data through an intuitive interface. The system is built as a full-stack application with a Clojure backend and React/TypeScript frontend, supporting both self-hosted and cloud deployments. The architecture follows a modular monolith pattern with clear separation between the core application, enterprise features, and embedding SDK components. The codebase demonstrates sophisticated engineering practices including a comprehensive plugin system that allows enterprise features to extend core functionality, a custom query builder with both GUI and SQL interfaces, and a robust embedding SDK for integrating Metabase components into external applications. The frontend utilizes modern React patterns with Redux for state management, while the backend employs Clojure's functional programming strengths for data processing and API handling. Key architectural highlights include the metabase-lib library for query construction and metadata management, a sophisticated visualization system with ECharts integration, and a multi-tenant embedding solution with JWT/SAML authentication. The codebase shows strong attention to internationalization, accessibility, and performance optimization through features like query caching, lazy loading, and bundle splitting.
Prometheus Alertmanager is a production-grade Go service that receives alert notifications from Prometheus or any HTTP client, deduplicates and groups them by routing rules, applies silences and inhibition rules, and dispatches notifications through 20+ integrations (Slack, PagerDuty, email, webhook, Telegram, Jira, etc.). It runs as a single binary with an embedded web UI, a REST API v2, an experimental Connect/gRPC API, and an amtool CLI. The architecture is a modular monolith: the app package wires together config loading, cluster membership, HTTP listeners, and a pipeline of notification stages (mute, dedup, retry, fanout).
Rocket.Chat is a production-grade, self-hosted team communication platform that provides real-time messaging, voice/video conferencing, omnichannel customer support (livechat), federation (Matrix), and an extensible app marketplace. The system is architected as a monorepo with a Meteor-based main application (apps/meteor) serving both the client (React with Fuselage UI) and server (Meteor methods, REST APIs via Hono, and microservices for enterprise features). Enterprise services (e.g., account, presence, authorization, DDP streamer) are implemented as separate polka-based microservices and gated by a license module. The client leverages React, TanStack Query, Zustand, and a rich component library (packages/ui-client). Data flows primarily through MongoDB (via typed model layers) with real-time updates pushed over DDP/WebSockets. File uploads use S3 or GridFS. Federation is achieved via Matrix protocol integration. The apps engine (packages/apps-engine) allows third-party apps to hook into message, room, and user events through a bridge pattern. The codebase includes extensive unit tests (Jest, Mocha), integration tests, Playwright e2e tests, and Storybook with a11y checks. External dependencies include MongoDB, Meteor, React, i18next, and a large set of npm packages managed by Yarn workspaces. The repository is actively maintained with frequent commits, changesets for versioning, and CI/CD pipelines.
slacrawl is a local-first Slack archiving CLI tool written in Go. It ingests messages, files, users, and channels from multiple sources—Slack API (bot/user tokens), Slack Desktop local cache (LevelDB + IndexedDB), MCP (Model Context Protocol) adapters, and external provider subprocesses—and stores them in a local SQLite database with full-text search (FTS5). The tool provides a rich command surface including sync, search, TUI browsing, analytics reports (digest, trends, quiet channels), retention purging, and Git-based archive sharing (publish/subscribe). It is designed for privacy-conscious users who want offline access to their Slack history without cloud dependency. The architecture follows a clean internal package separation: `cmd/slacrawl` is the entry point, `internal/cli` handles command routing via Kong, `internal/store` provides the SQLite persistence layer with schema migrations and batch writes, `internal/syncer` orchestrates multi-source synchronization, and `internal/slackapi`, `internal/slackdesktop`, `internal/slackmcp`, and `internal/provider` implement source-specific adapters. The codebase is well-tested with extensive Go tests, CI/CD via GitHub Actions, and cross-platform releases (Linux, macOS, Docker). While primarily an application, slacrawl exhibits data pipeline characteristics: it ingests raw Slack data, transforms it into a normalized relational schema with FTS indexing, and exposes analytical outputs (reports, digests). The embedding_jobs table hints at future ML integration. The Git archive sharing module is a novel pattern for distributed data replication. Overall, the codebase demonstrates strong engineering practices with reusable components like the generic MCP client, platform-specific file locking, and the external provider protocol.
Diun is a Go-based CLI daemon that monitors container image registries and notifies users when new versions or updates are available. It operates by polling container runtime environments (Docker, Swarm, Kubernetes, Nomad, containerd), or reading from YAML or Dockerfiles, to discover images, then compares their registry digests (or manifest list platform-specific digests) against a local bbolt database. When a change is detected, it sends notifications through one or more of 20+ channels (Slack, Discord, Telegram, email, webhook, MQTT, etc.). The system also exposes Prometheus metrics, a gRPC interface for image lifecycle management, and supports health checks via healthchecks.io. The architecture is modular: a scheduler component (cron-based with jitter and worker pool) triggers jobs that walk through configured providers (each implementing a `Handler` interface returning a list of `model.Image`), then for each image the registry client fetches the latest manifest (with tag sorting and filtering), compares it against the stored digest, updates the database, and dispatches notification entries through a notifier chain. The design cleanly separates provider discovery, registry inspection, state persistence, and notification delivery into independent packages. External dependencies include container runtime SDKs (Docker, containerd, Kubernetes, Nomad), the OCI distribution registry API, and each notification service's client library. The codebase is well-structured with strong test coverage, configuration via YAML and environment variables, and comprehensive CI/CD including e2e tests, static analysis, and vulnerability scanning. It is actively maintained with frequent releases and responsive issue triage. Primary entry points are `cmd/serve.go` (main daemon), `cmd/healthcheck.go`, `cmd/image.go` (gRPC-based image management), and `cmd/notif.go` (test notifications).
This repository is a comprehensive Node-RED package for building multi-platform chatbots with minimal coding. It provides a visual flow editor (Node-RED) with over 100 custom nodes for message handling, conversation management, AI integration (OpenAI, Dialogflow), and platform adapters for Telegram, Facebook Messenger, WhatsApp, Slack, Viber, Sinch, DeepChat, and more. The package also includes Mission Control, a React-based admin dashboard for managing users, content, messages, plugins, and device tracking, with a GraphQL API and WebSocket real-time updates. The architecture follows a middleware pattern (ChatExpress) for message normalization and platform abstraction, with a plugin system (code-plug) for extending the admin UI. While primarily an application, it includes some data persistence (SQLite via Sequelize) for chat logs, user records, and content management, but no data science or analytics pipelines.
This is a Go client library for the Slack API, providing comprehensive coverage of Slack's REST API, Real-Time Messaging (RTM) over WebSocket, Socket Mode for event-driven interactions, and the Block Kit for rich interactive messages. It enables developers to build Slack apps, bots, and integrations with full access to Slack's platform features including messaging, files, admin functions, workflows, and more. The library is organized into several packages: `slack` (main client with all API methods), `socketmode` (WebSocket client for Socket Mode), `slackevents` (Events API parsing), `slacktest` (mock server for testing), and `internal` (backoff, error handling). It uses a functional options pattern for API calls, context propagation for cancellation, and a pluggable retry system. The Block Kit is implemented with builder patterns and custom JSON serialization for type-safe block construction. Key entry points include `slack.New(token)` to create a client, `socketmode.NewClient` for WebSocket connections, and `slackevents.ParseEvent` for Events API payloads. The library handles authentication, rate limiting, pagination, and error responses. External dependencies are minimal, relying primarily on the Go standard library and a WebSocket library for real-time communication.
Zulip is a production-grade, open-source team chat application built as a Django monolith with a real-time Tornado event server. The backend uses Django ORM with PostgreSQL, RabbitMQ for async queue processing (email, push notifications, URL previews), Memcached/Redis for caching and rate limiting, and a custom typed-endpoint decorator pattern for API validation. The frontend is a mix of legacy jQuery/Handlebars and modern TypeScript with Zod schemas, Webpack bundling, and extensive UI components for chat composition, streams, topics, user groups, and settings. The system exposes a REST API (used by mobile and desktop clients), webhook ingestion for 50+ third-party services, and a full billing/support subsystem via Stripe. The architecture is a single monolithic Django application with separate Tornado process for real-time push, alongside queue workers and cron-like management commands. Key entry points include the Django WSGI server, Tornado event server, management commands (e.g., manage.py), and webhook view functions. External dependencies include PostgreSQL, RabbitMQ, Redis, Memcached, Stripe, pgroonga (full-text search), pyvips (image processing), and numerous npm packages.
Vigil is a microservices status page application written in Rust. It monitors distributed infrastructure services via multiple probe modes (HTTP, TCP, SSH, ICMP, push, script, local), aggregates their health status, and serves a public status page with real-time updates. It also sends alerts through various channels (Slack, Email, Twilio, Telegram, etc.) when services go down or recover. The architecture is a single binary with separate threads for probing, aggregation, and HTTP serving, using a shared in-memory state protected by RwLock. The codebase is well-structured, with clear separation of concerns: config reader, prober, notifier, aggregator, and responder modules. It includes an MCP server for AI agent integration. The project is actively maintained with recent commits and CI/CD pipelines.
Macro is a large open-source monorepo (AGPLv3) for an all-in-one collaborative productivity platform that unifies email, messaging, documents, tasks, CRM, AI agents, and more. The backend consists of 42+ Rust microservices following a consistent hexagonal architecture (domain/inbound/outbound), with PostgreSQL, OpenSearch, Redis, S3, Kafka/SQS/EventBridge for data storage and event-driven processing. The frontend is a SolidJS single-page application with a heavily customized Lexical editor, block-based content system, real-time collaboration via CRDT (Loro), and Tauri-based desktop/iOS apps. AI is a first-class feature with agent harnesses, MCP integration, and an AI editing worker. Infrastructure is managed via Pulumi and Docker Compose for local development. The codebase demonstrates high engineering craftsmanship with consistent patterns, extensive testing, and comprehensive observability, though the sheer scale and volume of generated code introduce some maintenance overhead.
This Terraform module provisions an AWS SNS topic and a Lambda function (Python 3.13) that forwards SNS notifications to a Slack channel via webhook. The Lambda function parses and formats various AWS event types—CloudWatch alarms, GuardDuty findings, Security Hub findings, AWS Health events, AWS Backup notifications, and generic messages—into structured Slack attachments. It supports encrypted webhook URLs via KMS, custom Lambda functions, VPC configuration, and SNS subscription filtering. The module is part of the terraform-aws-modules ecosystem and follows standard Terraform module conventions with comprehensive CI/CD, pre-commit hooks, and semantic release. The Python code includes unit tests with snapshot testing, linting, and type checking, demonstrating solid engineering practices.
Outline is a collaborative knowledge base platform built with React and Node.js. It provides real-time document editing via ProseMirror/Yjs, team workspaces with granular permissions, and extensibility through a plugin system. The application features rich text editing, document organization into collections, search functionality, notifications, and integrations with services like Slack, GitHub, and Notion. Architecture follows a monorepo structure with frontend (React/MobX/Styled Components), backend (Node.js/Koa/Sequelize), and shared utilities. Key entry points include the React root (app/index.tsx), Koa server (server/index.ts), and API routes (server/routes/api/). The system relies on PostgreSQL for primary data storage, Redis for caching and job queues, and S3/local storage for file attachments.
Colanode is a local-first collaboration workspace platform designed for self-hosting. It provides real-time editing of rich-text documents, customizable databases (table, board, calendar views), threaded chats, file management, and user roles. The architecture is a monorepo with separate packages for core types, client-side local persistence and sync, CRDT conflict resolution, and a shared UI library. The server runs on Fastify with PostgreSQL and Redis, exposing REST APIs and WebSocket connections for real-time synchronization. All data mutations are first applied locally in SQLite (via Kysely) and then synced to the server, enabling offline-first operation. Clients include a web application (React, Vite, service worker), a desktop app (Electron), and an experimental mobile app (Expo). The editor is built on TipTap/ProseMirror with custom extensions for blocks, mentions, files, and database nodes. External dependencies include PostgreSQL (with pgvector extension for optional vector search), Redis (for rate limiting and job queues), object storage (local filesystem, S3, GCS, or Azure), and optional AI/LLM providers for semantic search and assistant features. Many AI features are commented out or in development, indicating an incomplete experimental layer. The codebase is actively maintained with CI/CD pipelines, Docker images, Helm charts, and automated tests for critical server and web components.
OpenCrew is a multi-agent operating system designed to extend OpenClaw into a manageable AI team. It enables users to create specialized agents (Chief of Staff, CTO, Builder, CIO, Knowledge Officer, Operations, Research) that collaborate through messaging platforms like Slack, Discord, and Feishu. The system implements structured collaboration through role-based channels, thread-based task isolation, and agent-to-agent communication protocols. Key features include autonomy levels (L0-L3), task classification (QAPS), two-mode agent collaboration (delegation and discussion), and three-layer knowledge distillation. The application is actively maintained with recent updates focusing on cross-agent collaboration capabilities.
This is a monorepo for the Ember.js-based encrypted chat application 'emberclear', which provides end-to-end encrypted messaging with no server-side message storage. The architecture is modular, consisting of multiple Ember addons (crypto, networking, local-account, UI, test-helpers, tracked-local-storage) and a separate card game app (pinochle) that reuses the same networking and crypto infrastructure. The chat app uses public-key cryptography (tweetnacl, libsodium) via web workers, relays messages through Phoenix WebSocket relays, and persists data locally via IndexedDB and localStorage. It includes features like QR code identity sharing, channel voting with cryptographic chains, and a state-machine-driven setup wizard. The codebase is well-tested with QUnit, acceptance tests, and smoke tests, but shows signs of technical drift with outdated dependencies (Node 14, Ember 3.26.1), many TODO comments, and incomplete features (e.g., voting, QR login transfer). The pinochle game app appears experimental but demonstrates sophisticated state machine usage and animation systems.
Botdarr is a Java-based chat bot application that integrates with Radarr, Sonarr, and Lidarr media management services, allowing users to search, add, and monitor movies, TV shows, and music via chat platforms (Discord, Slack, Telegram, Matrix). The system uses a monolithic architecture with modular packages: API clients for each media service, command processing, chat platform adapters, and a SQLite database for persistence (e.g., user request limits, callback data). The main entry point is `BotdarrApplication`, which initializes the configured chat client and starts listening for commands. Data flows: user messages are received by the chat client, parsed by `CommandProcessor`, which executes commands that call the media service APIs (via `RadarrApi`, `SonarrApi`, `LidarrApi`), and responses are formatted by platform-specific `ChatClientResponseBuilder` implementations before being sent back. External dependencies include Apache HttpClient, Jackson, JDA (Discord), Slack SDK, Telegram Bot API, Matrix client-server API, and Flyway for database migrations. The codebase demonstrates solid engineering with strategy patterns for lookup/add/downloads, a command pattern for user interactions, and a clean abstraction for chat client response formatting. However, it suffers from technical drift due to reliance on Java 8, outdated libraries (JMockit 1.40, Jackson 2.13.4.1), and manual versioning. The Matrix client support appears incomplete, and response formatting logic is duplicated across platforms, increasing maintenance burden.
This repository is a community-maintained knowledge hub for students of the University of London BSc Computer Science programme, providing curated resources, module guides, FAQs, and automation scripts. Although classified as an application due to the presence of a Python script and CI/CD, its primary value is as a documentation and reference repository. The codebase is minimal, consisting of a single utility script (`update_week.py`) with a test suite and a GitHub Actions workflow that weekly updates the current academic week in the README. The bulk of the content is extensive markdown files covering module specifics, kinks (bugs), study tips, software recommendations, and Slack onboarding. The project demonstrates strong community organization, including issue templates, contribution guidelines, and all-contributors integration, but is not a traditional software application or data pipeline.
Franz is a desktop messaging aggregator that consolidates multiple chat services (WhatsApp, Slack, Telegram, etc.) into a single Electron application. It uses a plugin-based 'recipe' system to integrate each service via webviews or BrowserViews. The architecture is a monorepo with Lerna, containing reusable packages for UI components, forms, and theming. The main application is built with React 16, MobX 5, and JSS for styling, with a MobX store layer managing state and API calls. Features include service management, workspaces, todos, subscription tiers (freemium), and a feature toggle system. The codebase is well-structured but shows signs of age: it uses deprecated React lifecycle methods, @electron/remote, and outdated dependencies. The README explicitly states this is the predecessor of Franz 6 and is no longer actively developed, making it a legacy codebase.