Open-source alternatives to DoKit

Quantaxis is a quantitative trading framework designed for building, backtesting, and executing automated strategies across global equities, futures, and cryptocurrencies. It integrates an event-driven backtesting engine, a multi-market execution gateway for order routing, and a quantitative data pipeline for ingesting and storing multi-asset market data. The system features a Rust-accelerated financial library that utilizes Apache Arrow for high-performance technical indicator calculation and zero-copy data processing. It provides a containerized infrastructure model designed for orchestrati

Tracy is a real-time performance profiling framework for C and C++ applications. It provides a software instrumentation library that captures high-resolution telemetry data, which is then visualized through a separate graphical interface to identify bottlenecks and resource allocation issues. The system utilizes a client-server architecture that enables remote profiling, allowing performance data to be captured on a target machine and analyzed on a workstation. It employs lock-free event logging and shared-memory ring buffers to minimize the overhead of data collection, ensuring that the main

Matrix is a suite of mobile application performance management and analysis tools. It provides a plugin-based monitoring system for capturing crashes, lags, and memory leaks, alongside a static binary auditor for reducing installation package size and a bytecode instrumentation tool for performance tracking. The project distinguishes itself through native memory debugging and a SQLite query linter that identifies inefficient database patterns. It employs native interception techniques to detect memory leaks and heap corruption without requiring source code recompilation, and uses a custom run

Mitmproxy is an interactive, programmable network proxy engine designed for traffic analysis and protocol manipulation. It functions as a gateway that intercepts, inspects, and modifies network traffic in real-time, supporting HTTP, HTTPS, WebSocket, DNS, and generic TCP or UDP streams. By acting as a trusted certificate authority, the proxy can dynamically generate and sign certificates to decrypt and analyze secure TLS-encrypted connections. The project distinguishes itself through a highly extensible, event-driven architecture that allows users to automate traffic transformation using cust

Easy Profiler is a performance profiling library for C++ applications designed to measure execution duration and identify bottlenecks. It provides a framework for instrumenting code blocks to track performance metrics, allowing for the analysis of thread activity and system behavior through detailed timeline visualization. The library distinguishes itself by utilizing scope-based instrumentation to automatically track code lifecycles, minimizing manual overhead. It employs thread-local buffering and asynchronous data flushing to reduce synchronization contention, ensuring that performance dat

This project is a comprehensive technical guide and diagnostic manual for analyzing memory, performance, and asynchronous behavior within Node.js applications. It provides detailed methods for asynchronous tracing, memory diagnostics, and performance analysis to resolve runtime errors and execution bottlenecks. The resource distinguishes itself by covering advanced diagnostic workflows, including the use of flame graphs for CPU profiling, the capture and comparison of heap snapshots for memory leak detection, and the mapping of asynchronous call stacks. It also provides technical guidance on

Laravel Debugbar is a web-based debugging toolbar and application profiler for Laravel. It provides a visual interface to inspect database queries, logs, and performance metrics in real time to identify and resolve bugs during development. The tool features a database query monitor to capture SQL statements and timings, as well as a request inspector for analyzing route metadata, loaded views, and HTTP request data. It includes a profiler for measuring execution time and memory usage to identify bottlenecks in the request lifecycle. Its observability capabilities cover exception capture, app

ClusterFuzz is an automated platform that runs coverage-guided fuzzers at scale to find security and stability bugs in software. It orchestrates libFuzzer and AFL++ across distributed clusters of worker bots, collecting coverage feedback to guide input mutation and discover crashes. The platform provides a web-based dashboard for configuring fuzzing jobs, monitoring progress, and inspecting crash reports, with role-based access control to restrict sensitive features. The system automates the full fuzzing lifecycle, from build pipeline integration and corpus management to crash triage and bug

BCC is an eBPF development toolkit and tracing framework used for monitoring and analyzing the Linux kernel. It functions as a performance analysis tool and debugging utility to capture system events, measure kernel latency, and provide network observability. The project distinguishes itself by providing a build system that integrates with LLVM to compile C-like code into BPF bytecode at runtime. It utilizes BPF Type Format data for relocations to maintain cross-kernel compatibility and extracts kernel headers to ensure the generated programs match the specific kernel version. The toolkit co

This project is an IntelliJ IDE plugin that provides an integrated development environment for Rust. It serves as a build system orchestrator and debugger interface, offering comprehensive language analysis, syntax highlighting, and intelligent code editing assistance. The plugin integrates with a language server to provide real-time type inference and code navigation. It includes a dedicated static analysis tool for detecting code duplicates, analyzing memory leaks, and measuring test coverage. The toolset covers toolchain management and Cargo integration for dependency and manifest handlin

TikTok-Unlock is a utility designed for the management and retrieval of historical mobile application versions. It functions as a network traffic proxy that intercepts and inspects outgoing requests from desktop applications to identify and download specific software release identifiers. The tool utilizes man-in-the-middle traffic interception to capture and modify encrypted network requests between a client and remote servers. By performing dynamic API response injection and client-side request redirection, it enables the identification of legacy build metadata, allowing users to access and

This project provides a comprehensive architectural framework and set of standardized patterns for building, securing, and scaling production-ready Node.js applications. It serves as a foundational guide for establishing consistent development workflows, operational observability, and reliable service integration across distributed software systems. The framework distinguishes itself by emphasizing a schema-first approach to API development, ensuring that interface definitions drive the creation of server stubs, client libraries, and type definitions. It promotes a cloud-native posture by int

Reactotron is a desktop-based development environment designed for inspecting, monitoring, and manipulating mobile and web applications in real time. It functions as a centralized hub that connects to a running application via a persistent WebSocket connection, allowing developers to observe internal state, network traffic, and console output without manual instrumentation. The tool distinguishes itself through a modular plugin architecture that enables custom debugging commands and specialized extensions. It provides advanced diagnostic capabilities, including the ability to overlay design m

Firefox is a cross-platform web browser engine designed to render web content, execute JavaScript, and manage secure browsing sessions. It utilizes a multi-process isolation architecture that distributes browser tasks across independent operating system processes to ensure stability and prevent site-specific failures from impacting the entire application. The engine incorporates a sandboxed execution environment to restrict web content and untrusted scripts to isolated memory compartments, enforcing security policies that prevent unauthorized access to system resources. The project distinguis

This project is an AI frontend code generator and design system framework designed to convert visual references and images into functional frontend source code. It provides a system for translating image layouts and styling into code while ensuring layout and styling accuracy. The framework includes a prompt engineering library and portable style instructions that enforce the generation of complete, production-ready source code, preventing the use of placeholders or unfinished segments. It utilizes a multi-modal feedback loop and visual-to-code mapping to maintain consistency between high-fid

This project is an agentic framework designed to enable autonomous web navigation and browser automation. It functions as a controller that translates natural language instructions into deterministic browser actions, allowing agents to interact with websites, perform data extraction, and manage complex authentication flows. By leveraging accessibility trees and semantic element resolution, the framework mimics human-like navigation, moving beyond brittle DOM selectors to interact reliably with modern web interfaces. The framework distinguishes itself through its focus on secure, scalable exec

The Android NDK samples provide a comprehensive collection of code examples demonstrating how to integrate C and C++ native code into Android applications. This repository serves as a practical guide for developers utilizing the Android Native Development Kit to implement performance-critical application components that require direct hardware access and low-level system interaction. The project highlights the use of the Java Native Interface to bridge managed code with native modules, enabling cross-language function calls and efficient data exchange. It demonstrates how to manage native act

The project is a development kit and compilation toolchain that builds C and C++ source files into native machine code libraries and shared library packages for mobile execution. It integrates target architecture toolchains with standard build systems to transform source code into deployable native modules. The toolset includes debugging and profiling capabilities that bridge low-level system debuggers with compiled binaries to inspect runtime execution states, register contents, and memory layouts. It provides performance monitoring instrumentation to measure execution bottlenecks and resour

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

Quarkus is a Kubernetes-native Java framework designed for building high-performance, memory-efficient applications. It utilizes ahead-of-time native compilation to transform Java code into standalone, optimized binaries that eliminate the need for a virtual machine, enabling rapid startup and reduced memory consumption. By performing code augmentation during the build phase, it shifts heavy processing tasks away from runtime, ensuring that applications are optimized for cloud-native environments. The framework distinguishes itself through a unified approach to reactive and imperative program

Czkawka is a cross-platform utility designed for storage optimization and filesystem maintenance. It functions as a comprehensive file analysis engine that identifies redundant data, including duplicate files, empty directories, broken symbolic links, and temporary files. By utilizing hash-based content verification, the tool ensures accurate identification of duplicates regardless of file names or metadata. The project distinguishes itself by offering both a native graphical user interface and a command-line interface, allowing for both interactive management and automated, headless system m

Eruda is a mobile browser developer console that provides a web-based inspector for debugging HTML pages and viewing logs directly on mobile devices. It functions as a browser element inspector for analyzing DOM and CSS styles and an in-page JavaScript console for executing code and monitoring runtime errors on devices that lack native developer tools. The project enables mobile web debugging and on-device element inspection without requiring a connection to a desktop computer. This allows for the evaluation of web applications on actual mobile hardware and the troubleshooting of remote sites

Async-profiler is a sampling profiler for Java applications that tracks CPU time and stack traces across execution frames to identify performance bottlenecks. It is designed to capture profiling data without introducing timing bias. The project provides capabilities for JVM memory analysis to locate native and heap allocation hotspots and memory leaks. It also includes system contention analysis to identify resource bottlenecks through the tracking of contended locks and hardware performance counters. The tool converts raw profiling data into visual performance reports, including interactive

Mockserver is a multi-protocol mock server and API verification proxy used to simulate HTTP, gRPC, and WebSocket endpoints. It functions as a tool for testing client applications without relying on live backend services, providing a system to simulate chat completions and streaming responses for large language model integrations. The project automates behavior by generating request expectations and response behaviors from OpenAPI and Swagger specification files. It differentiates itself through a network traffic simulator that introduces latency, dropped connections, and failures to verify ho

Samply is a cross-platform CPU sampling profiler and performance analysis utility. It consists of a command-line tool for recording process stack traces at regular intervals and a visual interface for analyzing the resulting execution data. The system includes a debug symbol resolver that maps raw memory addresses to human-readable function names using local or remote symbol information. It transforms recorded execution data into flame graphs and timelines to pinpoint function-level hotspots. The tool provides capabilities for CPU execution recording, stack unwinding, and symbol resolution a

Memlab is an automated browser memory profiler and JavaScript memory leak analyzer. It provides a toolkit for detecting and analyzing memory leaks by inspecting and comparing heap snapshots to identify unbound object growth and detached DOM elements. The system distinguishes itself through an automated leak testing framework that executes end-to-end browser interaction sequences to programmatically isolate memory regressions. It utilizes heap snapshot diffing, retainer chain tracing, and heuristic-based filtering to determine why objects remain in memory and to map the shortest path from garb

w3af is a web penetration testing suite and security audit framework designed to identify and exploit vulnerabilities in web applications. It functions as a vulnerability scanner that crawls targets to find injection points and a fuzzer used to discover hidden endpoints and test input validation. The project distinguishes itself by providing an intercepting HTTP proxy for capturing and modifying traffic, combined with a knowledge-base driven exploitation system. It enables the execution of security exploits to gain remote shell access and supports post-exploitation activities, such as routing