Projects sharing features with Distribute Crawler

Weibospider is a distributed web crawler designed to extract posts, profiles, and interaction data from the Weibo social network. It functions as a social media data extractor that utilizes a distributed task queue to scale scraping operations across multiple worker nodes. The system includes a graphical administrative interface for configuring crawler settings, target user identifiers, and search keywords. It employs a distributed architecture to increase data throughput and manage large-scale collection of social media content. The tool covers a wide range of data collection capabilities,

rq is a distributed task queue and background worker system for Python that uses a Redis backend to decouple task submission from execution. It functions as a reliable message queue and task scheduler, allowing Python functions or asyncio coroutines to be processed asynchronously across multiple worker processes. The project distinguishes itself through reliable queuing mechanisms that prevent job loss during worker crashes using atomic operations. It provides specialized orchestration capabilities, including the prevention of duplicate jobs, job execution prioritization, and the ability to m

Sidekiq is a Ruby background processing framework and asynchronous task runner. It functions as a Redis-backed background job processor that offloads heavy or time-consuming work from web requests to separate worker processes to ensure the main application remains responsive. The system operates as a Redis task queue, storing pending jobs in Redis to be processed concurrently by multiple threads. It provides a framework for distributed task queueing and asynchronous job scheduling to coordinate work across multiple server instances. The project covers Ruby application scaling by executing ba

Bee-queue is a Node.js background processing system that uses Redis for job queueing and persistence. It is designed to offload heavy tasks from the main execution thread to background workers to maintain application responsiveness. The project provides distributed job processing, allowing worker nodes to run across multiple processes to handle large volumes of tasks concurrently. It ensures reliable task execution through automatic retries and the recovery of stalled processes. Its capability surface covers asynchronous task scheduling for delayed jobs, concurrency control for worker nodes,

Resque is a Ruby library for enqueueing and processing asynchronous tasks using Redis as a data store. It functions as a distributed task processor and queue manager, allowing long-running work to be moved out of the main request cycle. The system executes background jobs in isolated child processes to prevent memory leaks and provides a web-based dashboard for monitoring queue depths, worker activity, and failed job statistics. Capability areas include distributed worker coordination via signals, error handling with job retry mechanisms, and priority-ordered queue management. It also suppor

This project is a distributed headless Chrome web crawler and data extraction framework. It functions as a JavaScript rendering engine that uses a headless browser to process dynamic pages, extracting structured data from websites that require JavaScript execution. The system is designed for scalable data collection across multiple nodes, using distributed task synchronization and shared caches to prevent duplicate work. It distinguishes itself through the ability to emulate specific client environments by configuring user agents and viewport dimensions, while capturing visual evidence such a

Bull is a Node.js library for managing distributed jobs and message queues using Redis as the primary data store. It functions as a distributed task worker, job scheduler, and priority queue manager designed to handle asynchronous workloads across multiple processes. The project distinguishes itself by providing a persistent communication channel that decouples servers through the exchange of serializable data objects. It ensures distributed system reliability by detecting stalled tasks and recovering from process crashes to ensure every queued job is completed. The system covers a broad ran

Go-workers is a background job processor for Go applications that coordinates asynchronous task execution using Redis queues. It implements the Sidekiq-compatible wire protocol and payload structures, allowing interoperability with existing background processing ecosystems and clients. The system manages task distribution through atomic list operations on a shared data store to guarantee reliable message delivery and prevent lost tasks during abrupt worker failures. It features configurable concurrency limits to control throughput per queue by dispatching incoming tasks across bounded synchr

yacysearchserver is a decentralized indexing system and peer-to-peer search engine. It functions as a distributed web crawler and intranet search appliance that allows for the discovery and indexing of web content without reliance on a central authority. The project enables the creation of private search portals for indexing internal websites and file systems. It utilizes a peer-to-peer network to share search indices and distribute query routing across multiple server instances, scaling search results through decentralized index management. The system covers recursive web crawling, web co

DotnetSpider is a .NET web crawler framework and programmable tool designed for traversing websites and capturing structured data from web pages. It functions as a distributed crawling engine that enables the automation of web crawling to discover and extract data. The framework is designed for distributed data extraction, allowing crawling tasks to be spread across multiple servers to process large volumes of web content. This architecture supports high-performance web scraping and enterprise data collection workflows for gathering structured information.

Asynq is a distributed background job processing framework for Go applications. It manages asynchronous task queues by offloading heavy operations to persistent storage, allowing the main application to remain responsive while background workers handle workloads. The system utilizes Redis to manage task state, concurrency, and message distribution across multiple worker instances. It employs atomic Lua scripting and sorted sets to ensure reliable job acquisition, precise scheduling of delayed tasks, and fault-tolerant processing through a two-stage acknowledgement flow. The framework support

BullMQ is a Redis-backed message queue library and background processor designed for distributed task queueing. It functions as a distributed queue manager and task scheduler, utilizing Redis to manage asynchronous job processing and persistence. The system distinguishes itself through its role as a job workflow orchestrator, enabling the definition of complex parent-child job dependencies and hierarchies for multi-step workflows. It provides sandboxed process execution to isolate heavy workloads and prevent event loop blocking, alongside distributed rate limiting to protect downstream servic

Redis is a high-performance in-memory key-value store that functions as a distributed cache, message broker, and NoSQL database. It provides sub-millisecond read and write access to data stored in RAM and can operate as a vector database for indexing high-dimensional embeddings. The system supports a wide range of data storage and synchronization primitives, including the management of strings, hashes, lists, sets, and JSON documents. It enables real-time data operations through atomic transactions, hybrid persistence using snapshots and append-only logs, and high-availability configurations

This is a distributed voting application designed to demonstrate a multi-service architecture. It uses stateless web frontends for submitting votes and viewing live results, with a Redis-backed queue to buffer incoming votes and a PostgreSQL database for persistent tallying. The application is built around asynchronous message queue processing, decoupling the vote submission from the tallying workflow. The project showcases how to deploy a multi-service application using container orchestration tools. It provides YAML-driven declarative deployment manifests for Docker Compose, Docker Swarm, a

Scrapy-Redis is a library that transforms Scrapy into a distributed web crawling framework by replacing its in-memory scheduler with a Redis-backed component. This allows multiple Scrapy spider workers to coordinate through a shared request queue, enabling them to consume URLs concurrently while a Redis set tracks seen URLs across all workers to prevent duplicate crawls. The system persists crawl state—including pending requests and already-crawled URLs—in Redis, so a paused or crashed spider can resume from where it left off without losing progress. The library provides a Redis-based duplica

Delay Queue is a distributed delayed task queue backed by Redis that schedules, polls, and manages time-sensitive jobs for asynchronous processing. It functions as an asynchronous job scheduler that accepts jobs with delay durations for execution at future timestamps, alongside operating as a distributed message broker where clients can poll queues for due tasks and acknowledge completion. The service incorporates lease-based job acknowledgment to assign temporary processing locks and explicit completion tokens, preventing duplicate executions and managing unacknowledged retries. Delivery is

Faktory is an open-source work server that queues, dispatches, and manages background jobs across multiple programming languages. It stores job payloads as JSON hashes in a Redis-backed queue and provides language-specific client and worker libraries that enable any language to push jobs to the server or fetch and execute them. The server includes a batch workflow orchestrator that groups jobs into batches with completion tracking for coordinating multi-step asynchronous workflows. It features a configurable job uniqueness filter that prevents duplicate enqueues within a time window, an expon

ECommerceCrawlers is an educational collection of Python-based crawler scripts designed to extract data from a variety of public websites, including e-commerce platforms, social media sites, news outlets, and multimedia sources. The project serves as a learning resource for web scraping techniques, offering ready-to-run examples that demonstrate practical data extraction methods. The toolkit covers a broad range of data types, including product listings and prices from online retail platforms, public posts and profiles from social networking sites, articles from news and blogging platforms, p

Kue is a Redis-backed job queue library for Node.js that provides a complete system for defining, scheduling, and processing background work. It stores job metadata and state in Redis lists and sorted sets, enabling persistent, in-memory operations with configurable concurrency control and priority-sorted processing. The library includes a RESTful HTTP API for managing jobs and a web-based monitoring dashboard for inspecting job status, progress, and logs. The system distinguishes itself through its event-driven worker model, where workers listen for job events via Redis pub/sub and process j

Horizon is a background job orchestrator and worker manager for Redis queues. It provides a monitoring dashboard to track job throughput, wait times, and failure rates, alongside a system for managing job retries, execution timeouts, and worker distribution. The project distinguishes itself through a Redis-backed monitoring interface that identifies system bottlenecks and a queue alerting system that sends notifications when background job wait times exceed defined thresholds. Worker processes are managed via version-controlled configuration files to ensure consistent balancing and scaling ac

Osmedeus is a security workflow orchestration engine that coordinates AI agents, shell commands, and scanning tools through declarative YAML pipelines. It functions as a distributed security scanner, a declarative workflow automator, and an AI agent framework for security, enabling automated multi-step security analysis with conditional branching, parallel execution, and distributed workers. The engine distinguishes itself through a hybrid runner model that executes workflow steps on the local host, inside Docker containers, or over SSH to remote machines, selected per step or module. It supp

.. image:: https://media.charlesleifer.com/blog/photos/huey3-logo.png

Cube is a time-series analytics platform and event data store designed for real-time performance monitoring. It functions as a metrics engine that ingests timestamped event streams and persists raw logs to enable the computation of statistical summaries, quantiles, and histograms. The system distinguishes itself through a reactive processing model that automatically invalidates metric caches when new events arrive, ensuring query results remain current. It supports both real-time event streaming via persistent connections and the calculation of post hoc statistics from stored event sets. The

This project provides a search service designed to retrieve and rerank web content for use in large language model applications. It functions as a retrieval augmented search engine that processes natural language queries to fetch contextually relevant information from external web sources. The system distinguishes itself through a combination of semantic retrieval and precision-focused reranking. It converts user queries into high-dimensional embeddings to perform similarity searches across indexed collections, then refines these results by passing candidate pairs through a secondary model to

Trio is an asynchronous I/O runtime and concurrency library for Python. It provides a system for executing non-blocking network and disk operations through a centralized event loop and task scheduler. The library is built on a structured concurrency model, which ensures that asynchronous tasks are bound to a specific lifetime and cannot outlive the scope that started them. It utilizes a nursery-based task manager to track task lifecycles in a parent-child tree, preventing orphaned concurrent operations by requiring child tasks to be joined before their parent scope exits. The framework cover

Netdata is a real-time infrastructure monitoring tool and multi-node observability platform. It functions as a high-resolution monitoring agent, log and metric aggregator, and time-series database designed to provide full-stack visibility into server health. The system is distinguished by its per-second metric sampling and zero-configuration auto-discovery, which allows for immediate infrastructure tracking upon installation. It utilizes edge-based machine learning and unsupervised models to detect system anomalies and abnormal metric patterns locally on each node. For distributed environment

evpp is a C++ network library and framework designed for building high-performance network services using TCP, UDP, and HTTP protocols. It provides an asynchronous event loop to manage nonblocking I/O operations and concurrent network connections across multiple threads. The framework includes specialized tools for asynchronous DNS resolution and a system for asynchronous task scheduling using a managed thread pool. It also features a nonblocking HTTP server and client with integrated connection pooling. The project covers low-level transport layer connectivity for TCP and UDP, as well as hi