LocalAI is a modular AI inference server providing OpenAI-compatible APIs for running diverse models (LLMs, vision, audio, video) locally. It features a polyglot architecture with Go core services, pluggable backends (C++/Go/Python), and a React-based web UI. The system supports distributed deployment via NATS/PostgreSQL, model gallery management, and multimodal processing. Key capabilities include model loading from Hugging Face, quantization, PII detection, and real-time transcription. The codebase demonstrates strong engineering practices with dependency injection, middleware chains, and clean separation of concerns.
BiTchat is a native Swift messaging application for iOS and macOS that provides secure, decentralized communication over Bluetooth Low Energy (BLE) mesh, with optional Nostr and Tor transport. The codebase implements end-to-end encryption using the Noise protocol (XChaCha20-Poly1305), Ed25519 signatures, prekey forward secrecy, and a vouching trust model. It includes rotating peer IDs, fingerprint verification, recognition tags that avoid leaking social graphs, and panic-wipe capabilities. The app is structured around SwiftUI views, view models, and coordinators, with a central ChatTransportEventCoordinator routing inbound transport events (messages, noise payloads, delivery status, verification, peer lifecycle) to the UI layer.
Activitypub-federation is a high-level Rust framework for implementing ActivityPub federation. It provides abstractions for handling incoming and outgoing activities, fetching remote objects, managing HTTP signatures, and integrating with web frameworks like Actix-web and Axum. The library uses a trait-based design where users define their own data structures and implement Object, Activity, and Actor traits to plug into the federation system. It includes sophisticated features like an activity queue with exponential backoff retry logic (1 minute, 1 hour, 2.5 days), automatic caching of remote objects, and comprehensive security measures including HTTP signature verification.
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 is the official reference implementation of the AT Protocol (atproto) by Bluesky, implemented as a large TypeScript monorepo. It provides production-grade services for a decentralized social networking platform: a Personal Data Server (PDS) for user data storage, the Bluesky AppView (bsky) for social feed APIs, the Ozone moderation service, an OAuth 2.0 provider and client, and numerous supporting libraries for identity, cryptography, Lexicon schema validation, repository storage, and syncing. The architecture is microservice-oriented with internal gRPC communication (ConnectRPC) between the AppView and data plane, and relies on PostgreSQL, Redis, and AWS KMS for persistence and caching. The codebase is actively maintained with frequent commits, extensive test coverage, and a well-structured monorepo with many reusable packages.
OrbitDB is a serverless, peer-to-peer distributed database library built on IPFS and libp2p. It provides a Merkle-CRDT (conflict-free replicated data type) log as its core primitive, supporting multiple database types like Events (append-only log), Documents (indexed JSON), KeyValue, and KeyValueIndexed. The architecture is modular: it separates storage backends (memory, LevelDB, IPFS blocks, LRU cache), identity management (pluggable providers), access control (static ACL or dynamic ACL stored in a keyvalue database), and encryption (pluggable). The primary entry point is `createOrbitDB()`, which returns an OrbitDB instance that can open databases of any registered type. Data flows involve appending operations to an immutable, signed log of IPLD entries, syncing with remote peers via pubsub-based replication, and handling conflict resolution using Last-Write-Wins. External dependencies include Helia (IPFS), libp2p, LevelDB, and various multiformats libraries. The library is designed for both Node.js and browser environments, with a comprehensive test suite covering unit and integration scenarios.
MiroTalk P2P is a self-hosted, open-source WebRTC video conferencing application that enables real-time peer-to-peer video calls, audio calls, screen sharing, chat, whiteboard collaboration, file sharing, and recording. The architecture consists of a Node.js/Express server with Socket.IO for signaling and a REST API (v1) for programmatic meeting management, token generation, and statistics. The client is a single-page application with modular JavaScript files handling UI components, media processing, accessibility, and integrations. Key features include end-to-end encrypted media (SRTP/DTLS), noise suppression via RNNoise AudioWorklet, live captions (Web Speech API and server-side Whisper transcription), ChatGPT integration, OIDC authentication, JWT-based API security, and an embeddable support widget. The system is designed for privacy: no persistent storage of signaling data, chat, or media; recordings stay in the browser as Blobs. Deployment options include Docker, Kubernetes, and bare-metal, with support for CoTURN TURN servers, ngrok tunneling, and email alerts via Nodemailer. The codebase is well-structured with separate modules for security (XSS sanitization, input validation, host protection), logging, and integration helpers, though the main server.js is monolithic (~2000 lines) and the client-side CSS is large (~5000 lines combined).
This repository is a TypeScript monorepo implementing the Waku v2 protocol stack for decentralized, peer-to-peer messaging. It provides a comprehensive SDK (`@waku/sdk`) for building light nodes that support relay, filter, light push, and store protocols, along with advanced features like rate-limiting nullifiers (RLN) for spam protection, structured data synchronization (SDS) for reliable ordered delivery, and message encryption (ECIES/symmetric). The architecture is modular, with separate packages for core protocol logic, peer discovery (DNS, peer exchange, local cache), Ethereum Node Records (ENR), protobuf definitions, React hooks, and a local development environment via Docker Compose. The codebase targets both Node.js and browser environments, with extensive unit and integration tests using Mocha, Karma, and Playwright. While the core protocols are mature, some packages (SDS, RLN) are experimental and show signs of rapid iteration, with skipped tests and generated code that may drift from upstream specifications.
EdgeVPN is a decentralized peer-to-peer VPN and overlay networking tool built on libp2p. It provides a VPN tunnel (TUN interface), TCP service tunneling (ngrok-like), HTTP egress proxy, DNS resolution, file transfer, and a distributed ledger for network state coordination. The architecture is a single Go binary with an embedded React SPA dashboard, exposing a REST API (Echo framework) and CLI (urfave/cli v2). The core innovation is a blockchain-style ledger that stores machine, service, DNS, and health records, with optional signed ownership enforcement and liveness-based reaping. The system uses libp2p for peer discovery (DHT, mDNS), pubsub (gossipsub), relays, and circuit v2. It is designed for decentralized networks without central coordination, and is used in production by Kairos (Kubernetes) and LocalAI (P2P distribution). The codebase demonstrates strong engineering with functional options patterns, comprehensive test suites, documentation generation from CLI code, and a design system for the React UI. However, it carries technical debt from experimental features (PeerGuard, DHCP, IPv6), a forked libp2p-pubsub dependency, and documentation drift that requires manual regeneration.
Jumble is a full-featured Nostr client for exploring relay feeds and engaging with the nostr social protocol. It is built as a Progressive Web App (PWA) with an optional Electron desktop wrapper, offering a rich set of features including notes, reactions, zaps, encrypted direct messages (NIP-17/NIP-4e), relay management, custom emoji packs, long-form articles, polls, media upload (Blossom/NIP-96), and translation services. The architecture is a React 18 + TypeScript single-page application with Vite as the build tool, using state management via React Context and service singletons with IndexedDB/localStorage persistence. The desktop variant adds native secret storage, auto-updater, and a custom media server. The codebase demonstrates high craftsmanship in areas such as relay connection management (SmartPool/ElectronPool with retry and health checks), an LRU-based caching abstraction (BoundedMap), a robust content parser, and a well-structured draft event creation pipeline. However, it also exhibits some monolithic services and tight coupling across providers, which limits modular reuse. Overall, it is a mature, production-grade implementation of a decentralized social media client with active development and a broad feature surface.
Berty is a full-stack, privacy-focused, peer-to-peer messaging application. The system consists of a Go backend implementing the Wesh protocol (based on IPFS, libp2p, and OrbitDB) that provides core messaging, push notifications, authentication, replication, and directory services. The backend is exposed via gRPC and consumed by multiple clients: a React Native mobile app (with both a legacy JS variant and a newer Expo-based variant), a Go CLI with a terminal UI (mini) and a desktop GUI (Fyne), and native bridges for iOS and Android. The architecture is modular, with separate packages for error handling, authentication, push relay, and bot framework. Key entry points include the `berty daemon` CLI command, the mobile app entry points (`App.tsx` in both `js/packages` and `berty-bridge-expo/mobile`), and the bridge framework (`go/framework/bertybridge`). Data flows involve gRPC streams from the Go backend to the mobile clients, with event-driven state management and local encrypted storage via SQLCipher. External dependencies include libp2p, OrbitDB, gRPC, protobuf, and various platform-specific native modules for BLE, mDNS, and push notifications. The repository also contains auxiliary tools for infrastructure testing, rendezvous servers, and debugging (Tyber).
RetroShare is a decentralized, peer-to-peer communication and file-sharing application built with C++ and Qt. It provides encrypted messaging, chat lobbies, forums, channels, file transfer, photo sharing, microblogging (The Wire), and a plugin system (VOIP, FeedReader). The architecture is a monolith with a core library (libretroshare) providing services like GXS (Generic eXchange System) for distributed group data, a Qt-based GUI (retroshare-gui), a headless service (retroshare-service), and a standalone friend server for Tor-based peer introduction. The codebase is large and mature, with extensive unit tests and a simulation framework for peer-to-peer testing. While many components are well-crafted, there is unfinished code, disabled tests, and some technical debt from long-term evolution.
This is the research archive for the Hyperspace P2P network, a distributed AGI system. The repository primarily contains documentation, leaderboards, trained model weights, and configuration files for autonomous research agents. It serves as a durable record of experiments run by agents across 5 research domains (machine learning, search, finance, skills, causes). The main outputs include a collaboratively trained language model (qwen2.5-0.5b-hyperspace-v1) trained by 32 anonymous nodes using DiLoCo + SVD compression, and live leaderboards updated via GitHub Actions. While the repo itself is mostly static artifacts, it references a larger codebase (the Hyperspace CLI and P2P stack) that is not included. The repository is hybrid: primarily a research data archive, but also includes a standalone CLI tool (agentboard) for a blockchain-based message board.
SparkleShare is a cross-platform desktop file synchronization application that uses Git as its backend, similar to a self-hosted Dropbox. It provides a system-tray-based GUI for Linux (GTK+), macOS (Cocoa), and Windows (WPF), allowing users to sync folders with remote Git repositories via SSH. The application supports encryption (AES-256-CBC), Git LFS for large files, and real-time sync signals via a centralized announcement service. The core sync logic is implemented in the shared 'Sparkles' library, with platform-specific controllers and UIs. The codebase is written in C# using Mono/Xamarin and targets .NET 4.5. The project has been in maintenance mode since its last release in November 2020, with the author seeking sponsors. The architecture is a monolith with a shared core and platform-specific frontends, but the technology stack is aging (GTK+2, WebKit, jQuery 1.6.1) and the build system is fragmented (meson + legacy .csproj). There is minimal test coverage and several abandoned features (e.g., listener layer). Despite these issues, the core sync engine and SSH abstraction demonstrate reasonable engineering for its era.
This repository is a curated list (awesome list) of projects, tools, and resources related to the Matrix communication protocol ecosystem. It contains no executable code, libraries, or data pipelines. The sole substantive file is README.md, which organizes links into categories such as clients, servers, bots, bridges, SDKs, research papers, and more. The repository serves as a community-maintained directory, not a software application or data research project. It follows the standard awesome-list format with contribution guidelines and a pull request template. There is no architecture, data flow, or reusable software components to analyze.