Projects sharing features with Bigint Hey

This project is a comprehensive educational resource and study guide focused on distributed systems architecture and backend infrastructure design. It provides a structured curriculum for mastering the principles of scalability, reliability, and performance required to design complex software systems. The repository distinguishes itself by offering a methodical approach to technical interview preparation, incorporating design patterns, architectural trade-offs, and spaced repetition tools to help users retain complex concepts. It emphasizes constraint-driven analysis, teaching users how to ev

Listmonk is a self-hosted email marketing platform and newsletter manager designed for high-volume bulk email distribution and transactional messaging. It provides a centralized system for organizing large subscriber databases and executing automated marketing campaigns directly from your own infrastructure. The platform distinguishes itself through its reliance on a relational database backend, which enables dynamic subscriber segmentation using complex query filtering at the time of delivery. It utilizes a concurrent worker pool to manage high-throughput email dispatch and incorporates a se

Skim is a cross-platform interactive fuzzy finder that runs as a terminal application, a Rust library, a Vim and Neovim plugin, and a shell integration tool. It provides real-time filtering and selection from lists of items, supporting keyboard and mouse navigation, live preview panes, and multi-select functionality across Linux, macOS, and Windows. The tool distinguishes itself through a composable query expression tree that supports fuzzy, exact, inverse, prefix, suffix, and logical AND/OR operators, combined with a Smith-Waterman scoring engine that penalizes typos and gaps for natural rel

Katana is a web crawler and spider designed for security reconnaissance and web application mapping. It functions as a utility for identifying endpoints, forms, and API structures across web targets by combining standard HTTP request traversal with headless browser automation to render dynamic, JavaScript-heavy content. The tool distinguishes itself through its ability to maintain authenticated sessions and handle complex web interactions, such as automated form submission and captcha resolution. It provides granular control over the discovery process, allowing users to define specific crawl

k6 is a performance testing framework used to measure the scalability and stability of network services and APIs. It functions as a JavaScript load testing tool that uses a Go engine to simulate concurrent user traffic. The tool enables the enforcement of service level objectives by comparing response time percentiles against quantitative performance thresholds. It also operates as a performance regression tool for continuous integration pipelines and a browser performance testing tool that executes scripts within a bundled headless browser instance. Its capabilities cover workload scenario

Locust is a distributed performance testing framework that allows users to define complex system stress scenarios using standard Python code. By modeling concurrent users as classes with weighted tasks and lifecycle hooks, it enables the simulation of realistic user behavior across large-scale environments. The tool functions as a scalable load generator capable of orchestrating traffic across multiple worker nodes to measure system stability and responsiveness under heavy, real-world conditions. The framework is distinguished by its protocol-agnostic architecture, which supports diverse comm

Anteon is a distributed load testing platform and automated performance testing suite designed to simulate high-traffic user scenarios and measure system performance across multiple global locations. It functions as an infrastructure anomaly detector and a service dependency mapper, providing a performance monitoring dashboard to track real-time resource usage across cluster instances. The project distinguishes itself by combining distributed traffic generation with service dependency mapping to identify system bottlenecks through network-level tracing. It incorporates an automated validation

Gatling is a load testing framework and traffic generation engine used to measure response times and error rates under heavy load. It functions as an as-code testing library, allowing users to define high-volume traffic simulations and performance tests through programming languages rather than graphical interfaces. The system enables multi-language load simulation and the ability to model concurrent user traffic to identify infrastructure bottlenecks and stability limits. It supports a test-as-code workflow, where version-controlled scripts are integrated into build pipelines as performance

Gor is a set of specialized utilities for recording, replaying, and shadowing network traffic to validate system behavior under real-world conditions. It functions as an HTTP traffic recording tool, a network traffic capture engine, and a system for duplicating live production traffic. The project provides capabilities for recording real-time HTTP network traffic and storing it for later playback or analysis. It can duplicate live production network traffic and redirect it to a staging environment in real time, or replay recorded network requests against a target environment to validate syste

Apache JMeter is a Java-based performance testing tool and multi-protocol traffic simulator used to analyze the stability and scalability of servers and networks. It functions as a distributed load testing framework that coordinates remote worker nodes from a single controller to generate high volumes of concurrent traffic. The project is distinguished by its ability to simulate traffic across diverse backend systems, including HTTP, JDBC, LDAP, JMS, FTP, and TCP. It provides a headless command-line interface for automated execution and a reporting system that transforms raw sample logs into

Vegeta is an HTTP load testing tool and library designed to measure the performance and stability of web services. It functions as a command-line utility, a programmable package for integration into other applications, and a distributed load generator capable of splitting request rates across multiple machines. The tool is distinguished by its constant-rate request scheduler, which dispatches requests at a fixed frequency regardless of target response times. It employs lazy target streaming to maintain low memory usage during large tests and uses a binary-encoded storage format to minimize di

Swell is an API development and testing client designed for interacting with modern network protocols, executing GraphQL operations, and running local mock servers. It provides a unified interface for connecting to endpoints served over HTTP/2, WebSockets, Server-Sent Events, gRPC, tRPC, and WebRTC, enabling live messaging, monitoring, and debugging. The platform includes a concurrent load testing engine that spawns parallel worker threads to evaluate endpoint performance under heavy traffic, alongside a local mock server engine for simulating backend responses during frontend development. It

k6 is a developer-centric load testing suite and command-line load generator designed for network performance validation. It functions as a JavaScript load testing tool that utilizes a Go-based runtime engine to simulate concurrent user traffic and validate API responses across HTTP, gRPC, and WebSockets. The project distinguishes itself by using code rather than a graphical interface to define workload scenarios and performance thresholds. It features a pluggable protocol architecture and an extension ecosystem that allows for the addition of custom protocols and specialized testing capabili

Speedtest-cli is a command-line utility designed to measure internet upload and download throughput by connecting to remote servers. It functions as a diagnostic tool for evaluating connection quality and verifying network performance against service provider claims. The utility identifies testing endpoints by calculating the physical distance between the client and available servers, ensuring measurements are based on responsive nodes. It manages the testing lifecycle by coordinating with remote services to fetch server lists and register results, which can be exported into machine-readable

pi-autoresearch is an autonomous research extension that automates iterative code-editing and performance-measurement loops driven by large language models. It functions as an experiment lifecycle automator, executing repetitive cycles of changes and benchmarks until a specific goal is reached. The system distinguishes itself by organizing successful experimental trials into independent git branches for review and merging. It includes a real-time research dashboard for monitoring metrics and status, and utilizes median absolute deviation to calculate confidence scores that filter benchmark no

Bombardier is a concurrent HTTP load generator and performance benchmarking tool written in Go. It functions as a latency distribution analyzer and benchmarking utility designed to measure the throughput and response speed of HTTP services by simulating high-volume request loads. The tool provides specific capabilities for TLS benchmarking, supporting client certificate authentication and the ability to bypass server certificate verification. It distinguishes itself through the use of a token-bucket algorithm for precise request rate limiting and the use of templates to export benchmark resul

iperf is IP network measurement software designed to quantify data transfer rates and network stability. It functions as a network performance benchmarking tool that tests capacity and throughput between two hosts to identify bottlenecks and performance limits. The tool specifically measures maximum bandwidth and packet loss over IP networks using TCP and UDP protocols. It also serves as a network data exporter, outputting performance results in JSON format for programmatic analysis and integration. The software covers a range of capabilities including network throughput analysis and traffic

This project is a comprehensive repository and curated index of resources, research papers, and development frameworks designed to support the construction and deployment of intelligent systems. It serves as a centralized knowledge base for developers seeking to navigate the technical landscape of artificial intelligence, ranging from foundational educational materials to specialized implementation guides. The repository distinguishes itself by providing structured directories for comparing generative artificial intelligence providers, including aggregated performance metrics, pricing data, a

This project serves as a comprehensive educational repository and technical reference collection, documenting a wide range of software engineering practices and modern development technologies. It provides a structured learning path for developers, curating tutorials and practical examples that cover the full lifecycle of application development, from initial project scaffolding to deployment and maintenance. The repository distinguishes itself by offering deep technical insights into complex architectural patterns, including actor-based concurrency models for managing parallel tasks and cont

MHDDoS is a command-line utility designed for volumetric stress testing and infrastructure resilience assessment. It functions as a comprehensive framework for simulating high-volume network and application layer traffic to evaluate the capacity and stability of web services and network infrastructure. The tool distinguishes itself through its ability to generate complex, protocol-specific traffic patterns and raw packet structures. By employing dynamic header randomization and specialized payload injection, it simulates diverse request behaviors intended to test the effectiveness of security

RoadRunner is a high-performance application server and process manager designed to serve PHP applications using a persistent worker model. It eliminates bootload overhead and initialization time by keeping application processes alive between requests, acting as a protocol-agnostic proxy that routes traffic to a pool of supervised workers. The server is built with a plugin-based modular architecture, allowing it to be extended with custom Go plugins and compiled into tailored binaries. It distinguishes itself by providing a unified execution model for a wide array of communication protocols,

GoReplay is a network traffic recording and replay tool used to capture live HTTP and binary protocol requests. It functions as a traffic shadowing proxy that duplicates incoming network requests to test environments and a utility for recording traffic to local or cloud storage for later analysis and playback. The system is capable of processing non-textual data formats, such as Thrift and Protocol Buffers, allowing for the capture and replay of specialized application-to-application communication. The tool supports live traffic capture and asynchronous duplication to validate infrastructure

Flagger is a Kubernetes operator designed to automate the lifecycle of application deployments through progressive delivery. It functions as a controller that monitors custom resource definitions to orchestrate complex release strategies, including canary, blue/green, and A/B testing. By continuously reconciling the desired cluster state with the actual environment, it ensures that deployments adhere to defined specifications while managing the underlying infrastructure required for traffic routing. The project distinguishes itself through a sophisticated metric-driven analysis loop that eval

MNN is a high-performance inference engine and framework designed for on-device machine learning. It provides a comprehensive environment for executing, optimizing, and deploying neural network models directly on mobile and resource-constrained edge devices. The framework distinguishes itself through a robust model optimization toolkit that supports quantization, compression, and structural graph manipulation to minimize memory footprint and maximize execution speed. It features a modular architecture that abstracts hardware-specific backends, allowing models to run efficiently across diverse

Cua is an agent benchmarking and desktop automation platform designed to evaluate autonomous agents and execute repetitive tasks within isolated, virtualized environments. It provides a framework for provisioning consistent workspaces and measuring agent performance against standardized desktop operations. The platform distinguishes itself by integrating virtual machine orchestration with headless interaction capabilities. By leveraging hypervisor-based virtualization, it runs operating systems at near-native speeds, while its automation layer injects commands directly into application proces

Fortio is a performance testing tool written in Go that generates constant request rates to measure latency histograms and response percentiles. It functions as a network performance benchmarker for analyzing system performance across HTTP and gRPC endpoints, and includes a specialized HTTP echo server for mirroring requests. The project distinguishes itself through a web-based HTTP load testing API used for triggering asynchronous tests and visualizing result data through graphs. It also provides server behavior simulation, allowing the echo server to inject artificial delays and vary respon

wrk2 is a high-performance HTTP benchmarking tool and constant throughput load generator. It is designed to measure server stability and throughput by sending a fixed number of requests per second, functioning as a high-resolution latency profiler and a Lua-scriptable performance tester. The tool distinguishes itself through a scriptable interface that uses a high-performance just-in-time compiler to define complex request formats and custom response reporting logic. It employs high-resolution histograms to capture precise response time distributions and high-percentile latency data. The pro