WebTorrent is a JavaScript library implementing BitTorrent client and seeding behavior for both Node.js and browsers. At runtime, a WebTorrent instance accepts torrent identifiers (magnet links, info hashes, .torrent files), parses them into metadata, discovers peers via DHT, HTTP/UDP trackers, LSD, and PEX, then negotiates connections over TCP/uTP in Node or WebRTC in the browser. The engine orchestrates a block-request pipeline, verifies piece hashes, writes chunks into pluggable chunk stores (fs, fsa, memory), and exposes files as streams, HTTP endpoints, or Service Worker responses. It also seeds existing files/buffers back to the swarm. This repo is not the standalone CLI; it is the core client library consumed by webtorrent-cli and desktop applications. Architecturally, the code follows a modular small-package style: central WebTorrent and Torrent classes coordinate discovery, peer management, and piece selection, while focused helpers handle transport factories, shared listener pools, piece-range selection, rarest-first availability, and HTTP/Service Worker streaming. It depends on the established BitTorrent ecosystem: bittorrent-dht, bittorrent-tracker, bittorrent-protocol, create-torrent, parse-torrent, torrent-discovery, ut_metadata, ut_pex, and optional native utp-native. Browser/runtime variation is handled through package.json browser/chromeapp aliases and webpack builds. The test suite exercises real network workflows over local DHT/tracker/LSD and direct IP connections, covering PE/MSE encryption, metadata exchange, web seeds, blocklists, seeding while downloading, throttling, and server streaming. Code quality is generally strong, though lib/torrent.js is large and contains legacy comments/TODOs, and there are stale tests referencing a removed swarm module. Overall, this is a high-craft, production-grade P2P streaming library with several genuinely reusable internal components.
Rats Search is a decentralized BitTorrent search engine implemented as a Qt6/C++ desktop application with a headless server mode. It crawls the BitTorrent DHT network to discover torrent metadata, indexes it using Manticore Search (a Sphinx-compatible full-text database), and provides a full-featured GUI for searching, downloading, and managing torrents. The application also includes a P2P replication layer for synchronizing databases between peers, a REST/WebSocket API for remote control, and support for torrent creation, seeding, and metadata export. The codebase is well-layered (domain, data, services, net, ui, rest) with clear separation of concerns, extensive unit and integration tests (15+ test files), and a professional CMake build system with CI for Windows, macOS, and Linux. A legacy Electron/Node.js version (v1.x) is preserved in the `legacy/` directory but is not actively developed. The project demonstrates high craftsmanship in its data layer (hash-based row IDs, safe SphinxQL query builders, resumable database dumps) and service architecture (cancel tokens, progress reporting, event-driven updates via Qt signals). However, the main window (`mainwindow.cpp`) exceeds 2400 lines, and the presence of the legacy codebase adds maintenance overhead.
This repository provides a robust, production-ready implementation of a BitTorrent tracker, including both client and server components. The client can announce to HTTP, UDP, and WebSocket trackers to discover peers in a swarm, while the server can track multiple swarms, respond to announce and scrape requests, and expose statistics via a web interface. The architecture is modular, with separate tracker protocol implementations (HTTP, UDP, WebSocket) inheriting from a common base class, and a server that manages swarms using an LRU cache for peer storage. The codebase is well-tested, uses modern ESM modules, and is actively maintained as part of the WebTorrent ecosystem. It is primarily a library for Node.js, but also supports browser usage via bundlers.
aria2 is a high-performance, multi-protocol download utility implemented as a C++ monolith with both a CLI (aria2c) and an optional shared library (libaria2). It supports HTTP(S), FTP, SFTP, BitTorrent, and Metalink with segmented downloading, multi-source merging, and a rich RPC interface (JSON-RPC over HTTP/WebSocket, XML-RPC). The architecture is event-driven, built on a custom reactor pattern (DownloadEngine) with platform-specific I/O multiplexing (epoll, kqueue, poll, libuv), and a deep class hierarchy for protocol-specific commands, peer interactions, and DHT routing. External dependencies are abstracted behind internal interfaces (e.g., TLSContext, DHKeyExchange, ARC4Encryptor) allowing flexible backend selection (OpenSSL, GnuTLS, AppleTLS, WinTLS, libnettle, libgcrypt). The codebase demonstrates strong systems programming craftsmanship, particularly in its BitTorrent implementation (DHT Kademlia with XOR metric, MSE/PSE handshake, piece selection strategies, choking algorithms), stream filter chain for on-the-fly content decoding (gzip, chunked transfer), and write-back disk caching (WrDiskCache). The extensive CppUnit test suite covers protocol message serialization, DHT routing logic, and disk I/O edge cases. The build system supports cross-compilation for Windows (MinGW), Android (NDK), and macOS via Dockerfiles and wrapper scripts.
XIU2/TrackersListCollection is a curated, daily-updated collection of BitTorrent tracker URLs. It provides several pre-filtered lists (best, all, HTTP-only, no-HTTP) in both plain text and Aria2-compatible formats, served via CDN. The core of the repository is a GitHub Actions workflow (`update-trackers.yml`) that automatically fetches trackers from multiple public sources, normalizes and deduplicates them, applies a blacklist, validates DNS resolution, and performs TCP connectivity checks on HTTP/HTTPS trackers. The resulting lists are committed back to the repository and mirrored to Bitbucket. While the repo is essentially a static data repository with no application logic, the CI pipeline demonstrates a clean, modular ETL pattern using bash and standard Unix tools. The primary value is the curated tracker data itself, which is widely used in BitTorrent clients to improve download speeds.
Gopeed is a high-performance, cross-platform download manager written in Go with a Flutter frontend. It supports HTTP/HTTPS, BitTorrent, Magnet links, ed2k, and HLS streaming protocols. The backend provides a REST API, CLI, and an MCP server for AI agent integration. The frontend is a full-featured Flutter app for desktop (Windows, macOS, Linux), mobile (Android, iOS), and web. Key features include multi-connection downloads with slow-start and work-stealing, a JavaScript extension system (goja) with polyfills for fetch, XHR, Blob, and streams, archive extraction (zip, 7z, rar), webhook/script notifications, and browser impersonation via TLS fingerprinting. The architecture is modular: protocol-specific fetchers implement a common interface, the download engine manages task lifecycle and persistence (BoltDB), and the UI communicates via RPC or FFI. The codebase is well-tested with extensive integration tests and includes a legacy Flutter UI (ui/flutter_old) alongside the current one, indicating an ongoing migration from GetX to Riverpod.
PikaTorrent is a cross-platform BitTorrent client built with Flutter, supporting Windows, macOS, Linux, Android, and iOS. It provides a modern, user-friendly interface for downloading and streaming torrents, with features like sequential downloading, media playback with subtitle/audio track selection, torrent tagging and filtering, and platform-specific integrations (system tray, background service, file association). The application follows a clean architecture with an engine abstraction layer (currently backed by the Transmission library via flutter_libtransmission), provider-based state management (AppModel, SessionModel, TorrentsModel), and separate HTTP servers for streaming content and subtitles. The codebase is generally well-organized, though it contains some hardcoded values and minor code smells. The project is actively maintained with a full CI/CD pipeline and multi-platform release automation.
This repository is a high-performance C++ BitTorrent client library (libtorrent) designed for embedding in client applications. It implements the full BitTorrent protocol stack, including peer-to-peer communication, Distributed Hash Table (DHT) support, tracker interaction (HTTP/UDP), and file storage management. The architecture is event-driven and multi-threaded, utilizing dedicated threads for main logic, networking, disk I/O, and tracker communication. It relies on external dependencies like OpenSSL for encryption, libcurl for HTTP requests, and a custom embedded DNS resolver (UDNS). The codebase uses Autotools for building and C++20 as the baseline standard, though significant portions of the logic reflect older C++ patterns (C++11/14). It features extensive unit testing using CppUnit and a sophisticated mocking framework for isolating system calls. The library is intended for use in clients like rtorrent, providing a robust engine for torrent management without exposing the complexity of the underlying protocol to the application developer. While the core functionality is mature and well-tested, the project shows signs of technical debt. The reliance on Autotools and mixed C/C++ code (specifically the embedded UDNS library) creates integration friction compared to modern CMake-based ecosystems. Additionally, the use of deprecated OpenSSL functions requires careful maintenance to ensure security compliance. Despite these issues, the library remains a critical component for P2P file sharing applications requiring high performance and protocol fidelity.
vlc-bittorrent is a VLC media player plugin that enables direct streaming of .torrent files and magnet links. It integrates libtorrent-rasterbar to handle the BitTorrent protocol, providing three VLC submodules: a stream_directory module to list torrent contents as a virtual directory, a stream_extractor module to stream individual files with on-demand piece downloading and priority-based piece selection, and an access module to resolve magnet URIs by downloading metadata from peers. The plugin manages a single libtorrent session shared across multiple torrents, handles asynchronous alerts via a dedicated thread, and supports interruptible I/O compatible with VLC's blocking read model. It includes a comprehensive test suite with TAP output and deterministic expected results.
rTorrent is a high-performance BitTorrent client designed for headless (daemon) or ncurses-based terminal use. Its architecture is a monolithic event-driven application with clearly separated subsystems: core download management (libtorrent binding), display abstraction (ncurses windows and stubs), input handling, an extensive RPC layer supporting XMLRPC, JSONRPC, and SCGI, session persistence with async write-back, and a Lua scripting engine. The system exposes hundreds of commands for controlling torrents, trackers, peers, throttles, and DHT. Remote administration is a first-class feature, and the terminal UI is fully customizable via configuration. The codebase is mature and professionally structured, with strong test coverage and well-defined modular boundaries, though it carries some legacy dependencies (autotools, vendored TinyXML2, CppUnit) and deprecated command aliases.
This repository provides a curated, automatically updated collection of public BitTorrent trackers. It contains plain-text lists of tracker URLs categorized by protocol (UDP, HTTP, HTTPS, WebSocket, I2P, Yggdrasil), as well as subsets for the 'best' trackers and IP-address-based lists to avoid DNS resolution issues. The data is generated by an external bot that checks tracker availability, removes duplicates and blacklisted entries, and sorts by popularity and latency. There is no application code in the repository itself; it serves as a data resource consumed by BitTorrent clients and third-party tools. The project is heavily star-favored and actively maintained with daily updates.
LeechCraft is a modular, cross-platform desktop internet client built with C++ and Qt. It provides a plugin-based architecture where each plugin implements standard interfaces (IInfo, IPlugin2, IHaveSettings, IHaveTabs) and can be dynamically loaded. The core handles plugin loading, entity-based inter-plugin communication, settings management via XML dialogs, and a hook system for customization. Plugins cover a wide range of functionality: instant messaging (Azoth with XMPP/IRC/Tox), web browsing (Poshuku), RSS/Atom feed aggregation (Aggregator), music player (LMP with GStreamer), document viewer (Monocle with PDF/ePub/DjVu), email client (Snails), BitTorrent client, system monitoring, power management, and more. The codebase uses modern C++20 coroutines for async operations, a custom compile-time ORM (oral) for SQLite persistence, and functional utilities (Either, Visitor, ScopeGuard). Despite its ambitious scope and well-structured plugin system, the project shows signs of age: many plugins have incomplete translations, deprecated Qt patterns (old-style SIGNAL/SLOT macros), and external dependencies that may be difficult to build with current toolchains. The last meaningful development appears to have stalled, making the repository more valuable as a reference for plugin architecture and Qt patterns than as an actively maintained application.