PROJECT 01 · Trading systems

This project is a high-performance Python application designed to replay historical and live trading data while calculating mid-prices with latency filtering. It provides a unified abstraction for processing large volumes of financial data, supporting dynamic switching between historical replay and live simulation via WebSocket. The system utilizes Redis Streams for a high-throughput message queue and includes a separate application for mid-price calculation that filters messages based on configurable latency thresholds. It features state persistence to resume processing from the last point and uses structured logging throughout. The codebase is built with Python 3.12+ and relies on libraries including asyncio-mqtt, numpy, pandas, pydantic, redis, and sentence-transformers. It is containerized using Docker and docker-compose. The project contains unit tests with 100% coverage and includes markdown documentation. It is currently a working-tool suitable for simulation and testing environments.

PROJECT 02 · Trading systems

This project is an advanced machine learning trading platform designed for multi-chain decentralized and centralized exchange integration. It implements a multi-indicator system combining SCHR_LVLS, WAVE2, and SHORT3 targets within a cascade ensemble structure that utilizes voting, meta-learning, and filters. The system supports risk management through position sizing and drawdown control, alongside real-time drift detection and alerting. It integrates with Binance for spot trading and multiple DEX protocols across Ethereum, BSC, Polygon, Arbitrum, Optimism, and Solana. The technical stack includes Python, LightGBM, XGBoost, and MLX-optimized deep learning models with attention mechanisms. Development relies on tools like pytest, Docker, and CMake, with a diverse set of dependencies covering web frameworks, data processing, and blockchain interaction. The codebase contains over 1000 files including notebooks, tests, and source code, reflecting a substantial development effort. The project is currently in a working-tool state, offering capabilities for training, prediction, paper trading, and live trading execution.

PROJECT 03 · Trading systems

This project is a verification tool designed to identify common backtest errors such as look-ahead bias, hidden trading costs, and overfitting in strategies developed by AI agents and humans. It is built using Python, with core components relying on numba, numpy, and pandas for numerical processing, and httpx2 and cryptography for secure API interactions. The system distinguishes itself by providing a structured environment for validating strategy logic before deployment, supported by extensive documentation, Docker containerization, and integration capabilities via the Model Context Protocol. Based on the file structure and repository history, it functions as a working tool with a mature codebase, though specific performance metrics or claims regarding profitability are not included in the available information.

PROJECT 04 · Trading systems

This project is a collection of professional Expert Advisors for the MetaTrader 5 platform, developed by Shcherbyna Rostyslav to provide global and specialized trading functionality. It includes multiple expert advisors such as SCHR_Global and SCHR_Machine, which support various trading strategies including global direction filtering, open price signals, and trailing stops. The system implements risk protection through margin and position count limitations, along with configurable volume and stop loss parameters. It relies on a suite of custom indicators like SCHR CORE, SCHR MOM, and SCHR Trend to determine market direction and momentum. The codebase consists of thirteen MQL5 files and one markdown documentation file, with no declared external dependencies. The project is currently in a working state, indicated by the README status for the main experts, though it lacks build manifests and formal dependency declarations.

PROJECT 05 · Trading systems

This project serves as a research implementation of a proprietary analytical framework designed to process market dynamics and detect specific technical patterns. It functions as a working tool that integrates data processing, pattern recognition algorithms, and a web-based interface for validation and demonstration. The system utilizes a Python-centric stack including FastAPI, Pandas, NumPy, and various machine learning libraries such as CatBoost and LightGBM, alongside visualization tools like Plotly and Bokeh. Its distinguishing strengths lie in its modular architecture, which supports real-time data ingestion via WebSocket connections and asynchronous processing using asyncio. The project is currently in an experimental state, characterized by an active development history and a collection of validation scripts intended to test the underlying analytical logic rather than a finalized production environment.

PROJECT 06 · Trading systems

The project implements a multi-level meta-model for trading on Binance spot markets, designed to search for alpha edges while rigorously eliminating false signals through leak-proof validation and cost-aware walk-forward analysis. It utilizes Python, NumPy, Pandas, Numba, SciPy, PyArrow, and Redis to manage data pipelines, feature engineering, and execution logic. The system distinguishes itself by enforcing a strict "honest framework" where R&D outcomes, including negative results, are explicitly documented and used to prevent repetition of failed strategies. Currently, the system is in an experimental state as an Iteration 5 prototype; while the infrastructure for paper trading and risk management is complete, no edge has been identified, and live trading is structurally blocked.

PROJECT 07 · Trading systems

This project is a native macOS application designed to visualize financial market structures and generate trading signals based on a proprietary analytical framework. It ingests market data from external exchanges and processes it through a custom engine to render interactive 3D representations of market dynamics. The system distinguishes itself by performing all core calculations natively in Swift rather than relying on external Python libraries, enabling direct integration with the visualization layer. It supports multiple rendering modes and displays various market indicators such as candlesticks, volume, and wave patterns with associated confidence metrics. The application includes a camera system for navigating the 3D space and playback controls for reviewing time-series data. It is currently in an experimental state, evidenced by the presence of debug files, unit tests, and a limited set of documentation, which confirms it is a work in progress rather than a finalized product.

PROJECT 08 · Trading systems

This project is a trading platform designed to facilitate smart decisions and informed arbitrage across multiple markets, prioritizing analytical intelligence over execution speed. It utilizes Python 3.13, the uv package manager, and MLX for hardware acceleration on Apple Silicon, alongside a terminal user interface built with textual and rich. The system distinguishes itself through a modular architecture featuring a master analyst that orchestrates various analytical modules, a modern TUI for real-time monitoring, and a professional backtesting engine capable of processing millions of data points. It includes extensive documentation, unit and integration tests, and a comprehensive system audit script to ensure integrity before deployment. The codebase is actively maintained with a significant git history, though it remains in a research-prototype state as it is currently intended for testing and validation rather than live trading.

PROJECT 09 · Trading systems

This collection consists of documentation and configuration files related to decentralized exchange arbitrage strategies on the Fantom blockchain. It contains multiple PDF documents covering topics such as DEX scanning, arbitrage calculation, execution, and monitoring, alongside scripts for RPC commands and cloud storage preparation using Alpine Linux. The materials describe a system designed to operate nodes on home infrastructure or cloud environments like Oracle Always Free tiers and AWS EC2. The project is currently in a research-prototype state, as indicated by the absence of build manifests, declared dependencies, and test files, with only a single markdown readme and a limited git history.

PROJECT 10 · Trading systems

This project is a Python-based framework designed to enable remote control of a VMware Fusion Windows 11 guest environment, specifically for automating MetaTrader 5 terminals and MQL5 development workflows. It facilitates bidirectional file synchronization between the macOS host and the Windows guest, alongside capabilities for executing shell commands and capturing real-time screenshots. The system relies on the VNC protocol for GUI interaction and uses the paramiko library for SSH-like operations, supplemented by pydantic for data validation and pillow for image processing. Its distinguishing strengths include automated reconnection logic for VNC sessions, programmatic management of MQL5 compilation and script testing, and direct interaction with MT5 chart analysis and indicator monitoring. The project is currently in an alpha state, indicated by version 0.1.0, and serves as a functional prototype for automating trading terminal operations within a virtualized environment.

PROJECT 11 · Trading systems

This is a research system designed to determine if a specific proprietary indicator contains a tradable edge that survives rigorous out-of-sample testing, walk-forward validation, and Monte Carlo simulation. The system operates under strict constraints, utilizing only a single indicator source and avoiding any other technical analysis tools. It validates findings through a disciplined progression from paper trading to testnet execution before considering live deployment, ensuring that no trading dashboard is presented until the strategy is proven. The project relies on a local infrastructure comprising a PostgreSQL database and a Redis cache to handle market data, while the analysis engine is built using Python with specific numerical libraries. It functions as a command-line interface for researchers to query evidence and status, maintaining a clear separation between the research phase and any potential future commercial application. The system is currently in a research-prototype state, representing a frozen R&D studio environment rather than a live trading platform.

PROJECT 12 · Trading systems

This project serves as a professional portfolio and research log documenting the development of algorithmic trading systems and quantitative infrastructure. It exists to showcase a workflow for turning trading ideas into testable, reproducible systems, covering domains from MQL5/C++ domain depth to Python and C++ trading infrastructure. The repository contains a single markdown document outlining the author's focus on quantitative validation, backtesting, and AI-assisted R&D, alongside references to several archived prototypes like a data replay engine and DEX scanner skeletons. The distinguishing strength lies in the explicit distinction between active work, such as the Monte-Neo verifier for AI-generated strategies, and archived prototypes which are kept read-only for reference only. The project is currently in an archived-skeleton state regarding its listed prototypes, as they are described as engineering exercises or stubs rather than working trading products.

PROJECT 13 · Trading systems

This project is an archived C++20 skeleton for a Solana DEX arbitrage bot, designed to explore the architecture of decentralized exchange trading but never intended as a functional trading tool. It serves as a historical reference for the initial design of RPC endpoint discovery and scanner modules, while the core trading logic, including market data retrieval, opportunity detection, transaction signing, and risk management, consists entirely of stubs that return empty results or placeholders. The system relies on CMake and a standard C++20 toolchain, integrating libraries such as Boost, OpenSSL, and nlohmann_json to handle network connectivity and data serialization. Its distinguishing strength lies solely in the implemented CLI parser and the basic HTTPS-based RPC endpoint discovery mechanism, which can load endpoint lists from chain sources. The project is explicitly marked as an archived prototype; it is not functional, has not been maintained since September 2026, and contains no working arbitrage engine or live market data processing capabilities.

PROJECT 14 · Trading systems

This project is an archived C++23 console tool designed to scan Ethereum Virtual Machine chains for decentralized exchange factory contracts and liquidity pools via public JSON-RPC endpoints. It collects basic swap statistics and implements multi-threaded scanning for factory creation logs, though the original intent of arbitrage detection and execution was never implemented, leaving those core modules as stubs. The system relies on CMake and Makefile build manifests with declared dependencies on CURL, GTest, PkgConfig, and Threads. Its distinguishing strengths include support for multiple EVM chains such as Ethereum, BSC, Polygon, Fantom, and Avalanche, along with CLI flags and rate limiting per RPC endpoint. However, the DEX address catalog contains known errors with duplicated and incorrect addresses, and the project is explicitly marked as an archived prototype with no further development or security updates planned.

PROJECT 15 · Quant research

The project implements a proprietary analytical framework designed to provide a unified interface for calculating specific market metrics and models. It serves as a bridge between trading engines and quantitative research environments, supporting execution across multiple programming languages. The system distinguishes itself by porting its core computational logic into distinct languages to optimize performance for different target environments, including C++ for fast engines and Python for machine learning workflows. It relies on a modern technology stack featuring FastAPI for the HTTP server, CMake for build management, and Docker for containerization, alongside standard numerical libraries. The software is currently in an experimental state, with the embedded compute core remaining at an early semantic version while the API server has reached a readiness milestone for external integration.

PROJECT 16 · Quant research

This project is a local, production-oriented system designed to refine the SCHR PHL Levels indicator using machine learning for financial analysis. It addresses a specific data availability constraint where high, low, close, and tick volume values for a given bar are only known after the bar closes, requiring a same-row prediction strategy where targets are built against the current bar's final values rather than shifted future data. The system enforces strict rules regarding data leakage and feature lead-lag relationships, particularly concerning pressure metrics, to ensure model integrity during training and evaluation. It is currently in an experimental state, intended for research and walk-forward out-of-sample verification against costs, with a default status of DO_NOT_TRADE_YET until these validations are complete. The codebase consists of production-grade Python modules, configuration files, and comprehensive unit and integration tests, supported by detailed documentation in both English and Russian.

PROJECT 17 · Quant research

This project serves as a proprietary research pipeline for analyzing SCHR PHL indicators to support meta-machine learning experiments regarding predicted high/low prices and directional signals. It exists to facilitate rigorous R&D through walk-forward analysis and Monte Carlo stress testing, extracting calibrated probabilities rather than direct trading signals. The system utilizes Python 3.10, the uv package manager, and a specific stack including httpx for native API communication, alongside data and modeling libraries such as pandas, numpy, scikit-learn, and torch. Its distinguishing strength lies in its structured pipeline for downloading spot OHLCV data, enriching it via a QWC API server, and executing a full validation and training workflow with strict 100% test coverage on core modules. The project is currently in a research-prototype state, explicitly designated as research software with no guarantees of profit, requiring further stress testing before any potential deployment.

PROJECT 18 · Quant research

This project is a proprietary research initiative focused on developing a one-bar machine learning alpha model that integrates a specific proprietary indicator with standard OHLCV market data. The system is designed to validate whether this combined signal framework can achieve higher performance metrics than a baseline model using only price data, specifically targeting a strict out-of-sample improvement after accounting for transaction costs. It operates within a controlled research environment using walk-forward validation to test hypotheses regarding price prediction and residual edge analysis. The project relies on a Python-based technology stack including pandas, numpy, scikit-learn, and sentence-transformers for data manipulation and model training, alongside joblib for caching and prometheus-client for monitoring. Currently, the system exists as a research prototype, utilizing sample data to validate mechanical execution logic rather than providing live trading evidence.

PROJECT 19 · Quant research

This is an open-source research strategy factory designed to manage the lifecycle of quantitative hypotheses through a structured workflow. It accepts initial hypotheses, binds them to specific datasets, and performs automated triage followed by historical validation using multiple statistical proof methods. The system implements evidence gates to determine if a strategy warrants further development or publication, operating with a fail-closed safety floor that prevents live trading execution from the dashboard interface. It serves as a controlled environment for generating evidence-based research outputs rather than a live trading platform.

PROJECT 20 · Quant research

This project is a private research and development environment designed to validate a hypothesis regarding the Wavelet DFMDDF decomposition as a no-ML multiscale fingerprint for time series. It establishes a local benchmark contour to test whether these fingerprints can retrieve meaningful time-series analogs more explainably than simple baselines on fixed tasks involving synthetic data. The system utilizes Python with dependencies including matplotlib, numpy, pandas, and pyyaml to implement mathematical cores for wavelet decomposition, saturation scoring, and deterministic fingerprint generation. Its distinguishing strength lies in its rigorous mathematical proof of energy conservation and monotonicity within the decomposition, alongside a structured testing protocol that compares results against Euclidean and DTW baselines. Currently, the system exists as a research-prototype, as it has not yet demonstrated superiority over methods like Matrix Profile or utility on real-world datasets such as those from Sentinel or NASA.

PROJECT 21 · Quant research

This project is a local, production-oriented research system designed to refine the SCHR PHL Levels indicator using machine learning. Its primary purpose is to validate the indicator's potential as a forecast or meta-layer by enforcing a strict same-row prediction contract, where targets are derived from the current bar's high and low without using future data. The system distinguishes itself by separating the forecast generation logic from trade permission logic, ensuring that model accuracy is not conflated with economic edge before costs. It includes a dedicated synthetic ideal branch to formally specify data requirements and metrics, allowing for the verification of leakage-free predictions and negative controls. The codebase is organized with production-grade source code, unit and integration tests for leakage, and extensive markdown documentation defining agent rules and project contracts. Currently, the system remains in a research-prototype state, explicitly marked as "DO_NOT_TRADE_YET" pending a successful walk-forward out-of-sample validation against transaction costs.

PROJECT 22 · Quant research

This is a proprietary research laboratory designed to develop proprietary products with verifiable evidence for time-series analysis in trading and non-trading domains. The system relies on a local PostgreSQL database for market data and utilizes a custom API server to access proprietary analytical frameworks and indicators. It operates under a strict protocol requiring pre-registration of hypotheses before analysis begins, ensuring that negative results are treated with the same rigor as positive findings. The environment is structured to support AI agents and human researchers through documented workflows and read-only access to external source projects.

PROJECT 23 · Quant research

This project is a local Python-only environment designed for learning and demonstrating autonomous quantitative research workflows. It operates entirely offline on a MacBook Pro M1 Pro with 16 GB of RAM, ensuring the final capstone runs without network connectivity. The system relies on FastAPI and Uvicorn to manage local services, with a directory structure including artifacts, a dashboard, documentation, SQL scripts, source code, and tests. A single markdown file serves as the primary documentation, while configuration is handled via TOML files and environment variables. The setup process involves creating a virtual environment, installing dependencies, and executing a series of make commands to initialize the database, run smoke tests, and launch the application or dashboard. It functions as a self-contained sandbox for experimenting with research logic in an isolated setting.

PROJECT 24 · Quant research

This system is a proprietary event-driven research framework designed to ingest global events from public sources, normalize them into vectors, and construct causal chains linking events to market outcomes. It employs a Monte-Carlo simulation engine optimized for Apple Silicon Metal GPUs to generate probabilistic forecasts and trading signals based on these chains. The project utilizes a Python stack incorporating httpx, lightgbm, mlx, numpy, and pyarrow for data processing and machine learning, alongside PostgreSQL with pgvector for persistent storage. Its distinguishing strength lies in its ability to perform real-time event polling and backfill historical data for specific domains like seismic activity and global news, updating Bayesian estimates through a self-learning loop on paper trading results. Currently, the system exists as a research prototype with a documented architecture and testing suite, though it is strictly limited to paper trading simulations and is not intended for live financial deployment.

PROJECT 25 · Quant research

This project is an advanced financial analysis platform designed to support interactive ML trading strategy development and comprehensive technical indicator analysis. It utilizes a modern software stack including Python 3.8+, the UV package manager for dependency management, Docker for containerization with native Apple Silicon support, and FastAPI for backend services. The system distinguishes itself through its integration of adaptive testing frameworks, data quality checks, and tools for dead code analysis to maintain code hygiene. It is currently in a research-prototype state, serving as a foundational environment for experimentation rather than a production-grade trading system.

PROJECT 26 · Quant research

This project serves as a proprietary analytical framework for quantitative research, designed to provide a unified interface for calculating specific metrics and market states. It functions as a multi-language computational engine capable of executing complex calculations across different execution environments. The system distinguishes itself through its implementation of a core mathematical kernel ported to multiple distinct languages to optimize performance for various target platforms, including algorithmic trading environments and machine learning workflows. It relies on a technology stack comprising C++, Python, and MQL5, supplemented by Swift and Metal Shaders for visualization tasks. The project currently exists as a research-prototype with a significant portion of its core components in a production-frozen state, while the associated HTTP API server has reached a maturity level suitable for external integration.

PROJECT 27 · Quant research

This is a proprietary research laboratory environment designed to facilitate the development of time-series analysis products with rigorous, reproducible evidence standards. It serves the domain of quantitative research and trading systems by providing a structured framework for hypothesis testing and model validation. The system utilizes a stack including numpy, pandas, polars, psycopg, and scipy to manage data processing and statistical analysis. Its distinguishing strength lies in enforcing a strict protocol of pre-registration and immediate publication of results, ensuring that negative findings are treated with the same weight as positive ones to prevent bias. The project is currently in a research-prototype state, functioning as a foundational skeleton where the core framework is established but active investigation has not yet commenced.

PROJECT 28 · Quant research

This project serves as an archive containing materials for a hypothesis regarding the reverse-engineering of trading alpha by comparing synthetic market feeds against real data. It aims to demonstrate how a specific trading rule performs on a generated feed and then analyzes why the same rule fails on real assets like AAPL or GBPUSD, ultimately attempting to restore the alpha layer by layer. The collection consists of files including markdown documentation, an Excel trade report, and several visual charts comparing synthetic and real OHLCV data across assets such as BTCUSD, gold, and AAPL. The materials are strictly proprietary and not intended for public repositories or cloud hosting. The project is currently in an archived-skeleton state, representing a one-time discovery during a portfolio inventory rather than an active development cycle. To fully execute the hypothesis, critical components such as the synthetic feed generator, the exact trading rule formulation, and the specific raw data series for the referenced period are still missing and require reconstruction.

PROJECT 29 · Quant research

This project serves as a sanitized export documenting a multi-protocol software research and development track focused on time-series anomaly research, specifically illustrating an honest no-go closure where utility gates failed to yield replication candidates. It functions as a public methodology case study for the ClaimBound education initiative, providing a transparent record of the evidence chain from protocol to negative record without containing proprietary code or raw payloads. The system relies on markdown documentation and configuration files to maintain the research narrative and evidence structure, utilizing a static export approach where sanitization and verification tests were conducted in a private source repository prior to publication. Its distinguishing strength lies in its commitment to transparency regarding research outcomes, explicitly documenting both successful foundation gates and closed black-box tracks to prevent misleading claims of production readiness or commercial viability. The project remains in a research-prototype state, acting as an archive of a completed experimental inquiry rather than an active development tool or production-grade system.

PROJECT 30 · Quant research

This project serves as a repository for frozen raw external data snapshots, specifically public scientific datasets, intended to support reproducible experiments. It contains no executable code, build manifests, or declared dependencies, functioning strictly as a collection of input files for future analysis. The collection includes specific datasets such as NASA power and NOAA COOPS, organized into dated directories alongside a single markdown documentation file. Its primary utility lies in providing a static, unchanging baseline of data to ensure that any subsequent research or modeling efforts can be replicated with identical inputs. The system is currently in an archived-skeleton state, representing a data archive rather than a functional computational tool or active research prototype.

PROJECT 31 · ML for time series

This project is a Python-based toolkit designed to establish baseline methods for anomaly detection in time-series data across energy, blockchain, and supply chain domains. It serves as a reusable open-source resource for researchers and practitioners, focusing on resilient applications such as energy stability, blockchain security, and supply chain disruption monitoring. The system implements a comprehensive framework for both reactive detection and planned predictive early warning capabilities, utilizing standard statistical and machine learning approaches. Its distinguishing strengths include a command-line interface for automated processing, extensive visualization features using Plotly, and a structured methodology for comparing detection methods while assessing false positive costs and estimating net return on investment. The toolkit relies on a technology stack comprising Python, NumPy, Pandas, Scikit-learn, Prophet, and Jupyter, with containerization support via Docker. Currently, the system exists as a research prototype.

PROJECT 32 · Market-data infrastructure

This project is an archived engineering exercise designed to test a scalable financial data processing system capable of handling historical data replay and live data simulation. It was built to explore latency-aware timing by replaying quotes in the order they arrived rather than exchange-stamped order, a concept now carried over to another system. The system utilizes Python with asyncio, Redis Streams for high-throughput messaging, and pandas for data handling. Its distinguishing strength lies in the unified abstraction for replaying both historical and live data while respecting timestamp plus latency for correct sequencing. The project is currently in an archived state, no longer maintained as of late 2026, with live mode functionality limited to a demo timer and lacking a functional API or CLI for mode switching.

PROJECT 33 · Developer tooling

This project serves as a personal operations kit for Hermes on macOS, designed to manage policies, skills, and numbered shell scripts without storing secrets in version control. It provides a structured environment for maintaining system workflows, featuring documentation in both English and Russian, along with specific scripts for synchronizing skills to the local Hermes directory. The system relies on shell scripting to execute tasks and manage dependencies, utilizing a test suite to validate functionality. Its distinguishing strength lies in its strict separation of sensitive data from the repository, ensuring security while maintaining a reproducible workflow for the user. The project is currently in a working-tool state, evidenced by its active commit history and functional test infrastructure, though it remains specific to the individual user's Hermes environment.

PROJECT 34 · Developer tooling

This collection of files serves as a repository containing source code, documentation, and build configurations for various software components. It includes scripts, shell utilities, and project metadata files organized into directories such as ExchangeAggregator and Py connect mt5. The repository holds thirteen files in total, with a single markdown document providing minimal context and one test file. The project relies on no declared external dependencies and lacks formal build manifests. Its distinguishing feature is the presence of a specific shell script designed to modify authorship information in the Git history. The system is currently in a research-prototype state, indicated by the sparse documentation and the absence of established dependency management or continuous integration artifacts.

PROJECT 35 · Developer tooling

This system is a local, private repository designed to manage the launch and development of a professional profile on Upwork for a quantitative researcher. Its purpose is to facilitate securing an initial paid contract and transitioning sequentially from small verification projects to long-term work in quantitative development, algorithmic trading, backtesting, and trading infrastructure. The project organizes documentation, portfolio cases, service catalogs, sales playbooks, and operational roadmaps within a structured directory including assets, docs, output, and sources. It strictly enforces security by prohibiting the storage of sensitive credentials, proprietary source code, and trading strategies, while requiring verifiable proof for any public metrics. The system utilizes semantic versioning to track changes to the launch package, distinguishing between text edits, new portfolio entries, and major shifts in positioning or business models.

PROJECT 36 · Developer tooling

This is a C++17 application designed to connect to Slack via Socket Mode and display native notifications on macOS, while outputting logs on Linux and Windows. The project implements a custom WebSocket client over OpenSSL, includes a rate limiter, and provides macOS Keychain integration for secure credential storage. It supports event filtering, slash commands, and HTTP API requests, with a strict architectural rule limiting individual source files to 300 lines. The codebase relies on CMake for building and Docker for cross-platform execution, utilizing smart pointers and RAII for resource management. It is currently archived as of September 2026, read-only, and explicitly not intended for production use due to the availability of official SDKs.

PROJECT 37 · AI infrastructure

The project provides a system for generating and validating evidence cards that address narrow public claims regarding AI, machine learning, and data. It establishes a frozen protocol utilizing hashed sources and honest result status to ensure claims are backed by verifiable documentation. The implementation relies on Python, with core dependencies including numpy, pdfplumber, and pypdf for processing. Its distinguishing strength lies in the structured approach to evidence verification, organizing artifacts into a registry of cards. The repository contains extensive documentation and test suites, representing a mature state as a working tool available for installation via pip, conda, and uv.

PROJECT 38 · AI infrastructure

This project serves as a configuration repository designed to enable the safe installation and operation of a specific local AI stack on Apple Silicon hardware. It orchestrates the deployment and execution of OpenClaw, Codex, Ollama, and GitHub CLI, establishing a secure workflow that separates autonomous agent capabilities from sensitive credentials. The system implements a multi-agent architecture where a remote coding orchestrator handles primary research tasks while a local agent layer manages routine analysis and report generation using local models. Security is enforced through strict policies that prevent a single agent from holding constant secrets or full shell access, utilizing fine-grained GitHub workflows and sandboxed execution environments to mitigate risks associated with autonomous tool usage.

PROJECT 39 · AI infrastructure

This project serves as the single source of configuration and deployment for the this project-Brain stack, providing documentation, security policies, and deployment manifests. It is designed to support local development and research with a focus on safety, cost-free operation using local models, and controlled knowledge accumulation in a local PostgreSQL database. The system manages a Kubernetes environment via k3d, orchestrating local LLMs and a chat interface through Ollama, while enforcing strict security measures like secrets management and data classification. It relies on microservices running on FastAPI with dependencies including httpx, prometheus-client, psycopg, and uvicorn. The repository contains extensive documentation covering Kubernetes setup, local LLM integration, and an operator handbook for management. With over 75 commits recorded between March and August 2026, the project maintains a structured workflow using Git and the gh CLI for operations. It currently functions as a working tool for local experimentation and deployment rather than a production-grade system, evidenced by its reliance on local clusters and free API limits.

PROJECT 40 · AI infrastructure

This is a local-first coding assistant designed for a single MacBook Pro, operating without cloud calls or fine-tuning. It answers requests by escalating through a hierarchy of verification methods, starting with cache and associative memory checks, moving to symbolic derivation and codemods, and only using small-model completion as a last resort. Every result is validated by a real verifier, such as a compiler or solver, with the write-back serving as the learning step without gradients. The system relies on pretrained weights loaded by an on-device runtime tuned for Apple Silicon, utilizing Metal and the Accelerated Neural Engine.

PROJECT 41 · AI infrastructure

This system is a local LLM orchestration framework designed to manage complex software development environments on MacBook M1 Pro hardware. It enables rapid navigation across numerous repositories and services by utilizing a lightweight SQLite catalog and live runtime tools rather than heavy background graph servers. The project implements a priority-based source of truth hierarchy, favoring live process states and current code over cached metadata to ensure accuracy without exhausting system memory. It supports multiple quantized models with automatic selection based on available RAM and task complexity, explicitly rejecting configurations that exceed hardware limits. The implementation relies on Python scripts for control logic, llama.cpp for inference, and PostgreSQL for persistent research logging. Its distinguishing strength lies in the strict memory management strategy that prevents context window overflow by narrowing problem scope before querying. The system is currently in an experimental state, as benchmarks indicate that 27B parameter models are rejected for this specific hardware, and 1-bit quantization remains an experimental tier with known quality trade-offs.

PROJECT 42 · AI infrastructure

This project provides a complete setup for running a local open-weight model coding agent on an M1 Pro MacBook with 16 GB of RAM. It is designed to offer a free and fast AI solution for coding tasks within VS Code or VSCodium using the Continue.dev extension. The system includes shell scripts for environment management and server startup, alongside Python code and configuration files to integrate the model via a local API. Its distinguishing strength lies in its optimization for specific hardware constraints, utilizing a 4-bit quantized model to fit within 16 GB of memory while supporting safe context handling for one or multiple repositories simultaneously. The project is currently in a research-prototype state, serving as a functional reference implementation for local deployment rather than a production-grade tool.

PROJECT 43 · AI infrastructure

This project implements a Phase 3 local AI system designed to provide enhanced large language model capabilities entirely offline. It addresses the need for autonomous task execution and code analysis without relying on external cloud services. The system utilizes Python modules for model ensemble voting, multi-tier caching strategies, and specific adapters for code generation and autonomous operations. Its distinguishing strengths include 100% local operation, zero monthly subscription costs, and significant performance speedups through caching mechanisms. The project is currently in a research-prototype state, evidenced by the absence of build manifests, declared dependencies, and test files, despite containing comprehensive documentation and benchmarking scripts.

PROJECT 44 · MQL / MetaTrader code

This project is a collection of professional MQL5 indicators designed for MetaTrader 5, intended to support advanced trading strategies through multiple trading rules and signal systems. It aggregates various technical analysis tools including trend detection, volatility analysis, wave pattern recognition, and momentum indicators, all optimized for open price calculations. The system relies on MQL5 for implementation and includes a structured repository of indicator files alongside documentation and a license file. Its distinguishing strengths lie in its extensive configurability with numerous input parameters and a multi-rule trading logic that supports multiple distinct signal types. The collection also features visual signal displays with color-coded outputs and an integrated alert system for notifications. Based on the provided file structure and documentation, this work represents a working-tool or experimental archive of trading logic rather than a live production system, as it lacks build manifests and explicit performance metrics.

PROJECT 45 · MQL / MetaTrader code

This project functions as a proprietary analytical framework designed to estimate dynamic price zones for range trading strategies on higher timeframes. It operates as a deterministic system utilizing internal calculation methods rather than machine learning or artificial intelligence. The implementation relies on the MQL5 programming language and includes a dedicated source file for the core indicator logic alongside a supporting header library for on-open price handling. Documentation is maintained in Markdown and includes specific instructions for AI agents in Russian, alongside public market materials available in multiple languages. The system is currently in an experimental state, representing an early development phase aimed at evolving a legacy version into a more stable commercial product for a specific marketplace.

PROJECT 46 · MQL / MetaTrader code

This project is a proprietary financial market analysis system designed to support quantitative research and trading indicator development within the MetaTrader 5 environment. It serves as a collection of analytical tools and documentation focused on market behavior assessment, risk evaluation, and strategy testing. The system relies on a file-based structure containing compiled indicators, statistical manuals, and reports rather than a unified software build. Its distinguishing strength lies in its integration of specific quantitative methodologies with multi-timeframe analysis capabilities for various currency pairs. The project is currently in a research-prototype state, evidenced by the lack of automated build manifests, zero test files, and minimal version control history, which marks it as an experimental archive of analytical concepts rather than a production-ready tool.

PROJECT 47 · MQL / MetaTrader code

This collection consists of source code and documentation related to MQL5 development, containing MQL5 files, a header file, and various documents including a Word file and a Markdown readme. The repository includes a directory for MQL5 code and another for a Netcat network framework, representing an attempt to integrate network communication capabilities within the MetaTrader 5 environment. The project lacks build manifests and declared dependencies, remaining a self-contained or minimally configured set of files. With a limited commit history spanning from October 2024 to August 2026, the work exists in an early experimental phase, serving as a reference or prototype for implementing specific trading logic or network utilities rather than a fully developed system.

PROJECT 48 · MQL / MetaTrader code

This project consists of a small collection of source files and documentation, including one script with a .mq5 extension, a shell script for managing git authorship, and a single markdown readme. It functions as a lightweight utility or experimental code snippet rather than a full application, given the absence of build manifests, declared dependencies, or test files. The repository contains a directory named RPythonScripts, implying a potential integration or exploration of Python alongside the .mq5 code, though no specific functionality is described in the available documentation. The project has a long development history spanning over a decade, with 71 commits recorded between 2016 and 2026, reflecting sustained but likely sporadic maintenance over time. Currently, it functions as an archived skeleton or a personal reference repository, as the readme provides no functional description and the code lacks any visible testing or deployment infrastructure.

PROJECT 49 · MQL / MetaTrader code

This collection consists of source files and documentation related to a software initiative involving MetaQuotes language implementations. The repository contains files in specific extensions, one compiled executable, a shell script, and a markdown document, showing a focus on specific platform development without external declared dependencies. The project history spans from early 2016 through late 2026, implying a long-term maintenance period or a simulated timeline within the codebase. The absence of build manifests and test files, combined with a minimal file count, points to a limited scope centered on specific utility scripts or library components rather than a full-scale application. The work remains in a state of archival or minimal active development given the lack of recent structural changes or testing infrastructure.

PROJECT 50 · MQL / MetaTrader code

This project is a comprehensive collection of free MQL5 indicators designed for the MetaTrader 5 trading platform, serving as a curated repository of technical analysis tools for market analysis. It aggregates various indicators from internet sources to provide users with insights into market conditions, covering categories such as trend analysis, moving averages, momentum, and volatility. The system relies exclusively on the MQL5 language for implementation and contains no declared external dependencies or build manifests. Its distinguishing strength lies in the sheer volume of available tools, including multi-timeframe smoothed ADX, adaptive ATR channels, and Bollinger band variations, which allow for extensive strategy exploration without the need for custom compilation. The project is currently in an archived-skeleton state, evidenced by a lack of build manifests, zero test files, and a static file count of 333 indicators with only one markdown documentation file.

PROJECT 51 · MQL / MetaTrader code

This project is a comprehensive collection of MQL5 include files designed to provide modular, reusable functionality for MetaTrader 5 Expert Advisors and Indicators. It exists to support the development of sophisticated trading systems by offering advanced capabilities in position management, risk control, and technical analysis. The system utilizes MQL5 for core trading logic and shell scripts for build automation. Its distinguishing strengths include universal position handling for both Netting and Hedging accounts, comprehensive position calculations, and support for multiple closing strategies with 52 different triggers. The codebase also features dynamic array management for efficient memory usage and FIFO closing support for regulatory compliance. Based on the file extensions and content, the project is a collection of library files intended for integration into larger trading applications rather than a standalone executable. The repository contains 35 files with a history spanning from 2016 to 2026, reflecting long-term maintenance. The README explicitly references a global Expert Advisor file, implying these components are built to work in conjunction with a primary system. The project is currently in an archived-skeleton state, as it lacks build manifests and test files, serving primarily as a reference library for developers working within the MetaTrader 5 environment.

PROJECT 52 · Visualization

This project is a native macOS application designed for the visualization of financial data analysis, specifically focusing on a proprietary analytical framework involving pattern detection and graphical representation. It serves as a research tool to explore the relationship between mathematical calculations and market data structures through interactive graphical output. The system utilizes Swift, SwiftUI, and Metal for high-performance rendering, leveraging the Accelerate framework for mathematical operations and Combine for reactive programming. Its distinguishing strengths include the ability to render large datasets with intelligent streaming, achieving high frame rates on Apple Silicon hardware. The application features interactive playback controls, multiple visual view modes, and camera presets to examine data from various perspectives. Currently, the system is in an experimental stage, having completed implementation with synthetic data generation but lacking support for external file imports or live market data integration.

PROJECT 53 · Scientific theory

This project serves as a documentation-only repository containing the theoretical foundations for a proprietary research framework. It consists primarily of markdown notes and a collection of mathematical definitions intended to feed future implementation projects rather than functioning as a standalone executable system. The repository lacks build manifests, declared dependencies, or test files, and relies entirely on markdown documents and a single shell script for organization. This approach allows the author to maintain a clear separation between abstract concepts and practical code execution.

PROJECT 54 · Automation & DevOps

This system is an automated utility designed to run macOS antivirus updates and scans alongside Homebrew package updates at system startup. It provides multiple implementation options, including a native Swift version utilizing Swift Concurrency for optimal performance, alongside Python and Shell alternatives. The tool features a configurable launcher with a CLI interface, supports auto-start via LaunchAgent, and includes fail-safe execution that continues processing on errors. It is backed by comprehensive testing using pytest and modern dependency management with uv. The project is currently in an experimental state, serving as a functional prototype for automating security maintenance tasks on the platform.

PROJECT 55 · Automation & DevOps

This project serves as a structured documentation and workflow management system designed to organize research notes, project descriptions, and operational guidelines. It defines a specific multi-agent process involving roles such as Documentor, Reviewer, Curator, Security Gate, and Ops/Cloud to maintain content accuracy, security compliance, and version control. The system relies on a repository containing a collection of markdown documents alongside scripts and configuration files, utilizing a defined pipeline where agents prepare changes, verify facts against source code, scan for secrets, and approve releases. Its distinguishing strength lies in the explicit, rule-based automation of the documentation lifecycle, ensuring that updates follow a strict sequence of preparation, fact-checking, and security validation before publication. The system is currently in a research-prototype state, evidenced by its active development history and the presence of experimental agent roles intended to streamline the maintenance of technical records.

PROJECT 56 · Automation & DevOps

This collection consists of shell scripts and configuration files organized into directories for dashboards, documentation, and scripts. It is a lightweight utility or experimental setup focused on operational tasks, given the presence of shell scripts and JSON files without any declared dependencies or build manifests. The project includes markdown documents and a README file, emphasizing documentation over complex software architecture. With a git history spanning from February to August 2026, the system represents a small-scale initiative, likely serving as a prototype or a personal tool for managing specific workflows rather than a production-grade solution.

PROJECT 57 · Automation & DevOps

This collection consists of documentation and configuration files related to Oracle Cloud Infrastructure resource management and environment setup. It includes shell scripts for initialization, utilities for configuration handling, and extensive Markdown documentation in both English and Russian. The repository serves as a reference archive for managing OCI host capacity and associated deployment workflows. The materials are organized into directories and files covering setup procedures, security guidelines, and parsing logic, though no build manifests or declared dependencies are present. The content functions as a static set of instructions and scripts rather than a functional application with automated testing or continuous integration pipelines.

PROJECT 58 · Other

This collection of Swift source files and playgrounds serves as an experimental repository for exploring various Swift programming concepts and application structures. The system contains multiple isolated entries ranging from console applications and database prototypes to specific interactive logic implementations, organized within a single workspace without declared external dependencies. Its primary utility lies in providing a sandboxed environment for rapid prototyping of Swift syntax and logic, supported by a minimal set of markdown documentation and a single shell script for authorship tracking. The project remains in an early experimental stage, characterized by a lack of build manifests and a scattered file structure that indicates ongoing, unstructured development rather than a finalized tool or production system.

PROJECT 59 · Other

This project is a minimal collection of documentation and a shell script, containing only a README file and a top-level executable script. It serves as a basic container for project information and operational commands without any defined dependencies or automated build processes. The system relies entirely on manual execution of the provided shell script and reads instructions from the markdown documentation. It currently lacks any implementation of quantitative logic, data processing, or trading algorithms, functioning instead as a simple placeholder or initial setup for a future development effort.

PROJECT 60 · Other

This project consists of a minimal collection of files intended to demonstrate tool usage, containing a single script and a markdown document. It serves as a basic example rather than a functional application, lacking any build configuration or declared external dependencies. The distinguishing feature is its simplicity, relying solely on the script file without additional libraries or complex architecture. Currently, the project remains in a research-prototype state, as it contains no test files, no executable entry point beyond the example script, and no evidence of integration into a larger system or deployment pipeline.

PROJECT 61 · Other

This project implements an offline probabilistic geolocation system designed to estimate a user's position in Zaporizhzhia without internet access. It utilizes a smartphone's telemetry vector, including relative height changes, rotations, and steps, to match movement traces against pre-calculated offline elevation profiles of city streets. The core algorithm progressively narrows down possible locations to 30-meter grid squares rather than providing a single precise coordinate, acknowledging that a single height measurement is insufficient for exact positioning. The system relies on offline digital elevation models and a street graph to correlate the device's movement history with the urban terrain. Implementation involves Python scripts for data processing and algorithmic matching, alongside Swift code for the iPhone core to handle runtime orchestration and telemetry collection. Documentation is extensive, covering the concept, experiment plans, and specific roadmap items like alerting and voice detection. The project is currently in a research-prototype state, serving as an experimental framework to validate the feasibility of offline geolocation through vector matching and elevation analysis.

PROJECT 62 · Other

This project is a collection of source code and documentation files organized into directories for configurations, data, and scripts, with a README stating it is a project. It utilizes generic text-based configuration formats and includes Markdown documentation in both English and Russian. The repository contains a significant number of configuration files and test suites, implying a focus on structured setup and validation. The system is currently in a research-prototype state, as shown by the minimal build manifests and lack of declared dependencies, serving primarily as an archive of experimental work rather than a functional tool.

PROJECT 63 · Other

This project consists of a minimal collection of markdown documentation files without any executable code, build manifests, or declared dependencies. It serves as a simple repository intended for storing notes or documentation, lacking any functional implementation, testing suite, or automated build process. The reliance on standard markdown files indicates a straightforward approach to content organization, while the complete absence of build tools or libraries confirms its nature as a static archive for information rather than an active software system or research tool.

PROJECT 64 · Other

This project consists of a collection of source files and documentation without a defined build system or declared dependencies, implying it is an experimental or archival repository rather than a functional application. The codebase includes Swift files alongside assets for Metal graphics rendering, pointing toward work in graphics programming or simulation, though no test files or README documentation exist to clarify the specific purpose or implementation details. The presence of storyboard and plist files implies a user interface component, yet the lack of a README or build manifests prevents any assessment of its maturity or intended use case.

PROJECT 65 · Other

This collection consists of a large assortment of data files and documentation, primarily comprising JSON and CSV datasets alongside a few compressed archives and text files. It serves as a repository for various data sources, including entries related to NASA telemetry, household power consumption, and specific invocation logs, organized into distinct directories. The project currently lacks any build manifests or declared dependencies, demonstrating that it is not a compiled software application but rather a static aggregation of raw data and supporting markdown documentation. Its distinguishing strength lies in the sheer volume of structured data available, though it remains in a state of unknown maturity as no active development tools, testing frameworks, or specific functional descriptions are present to define its current utility or lifecycle stage.