Changelog

Turns Pi into a fan-out orchestrator: the model writes deterministic JavaScript workflow scripts that spawn isolated subagents, run in parallel, and return structured results.

Automates Aster DEX perpetual futures with dual strategy engines, explicit risk gates, and persistent trade logs so you can dry-run a setup before risking live capital.

yt-dlp-tauri turns yt-dlp into a local Windows/macOS GUI with pinned toolchain checks, cookie support, progress telemetry, and release verification.

codebase-mcp turns a repo into a persistent local MCP index so agents can do code search, dependency-aware discovery, and repository documentation without shipping source to a hosted service.

NTK-Mirror adapts frozen causal LLMs with sparse signed log-gate controllers, so you can tune behavior without LoRA modules or permanent weight edits.

GSD Pi turns the terminal into a local-first coding agent that plans work, isolates implementation in Git worktrees, verifies changes, and tracks project state without forcing you into a hosted IDE.

Hyperliquid Grid Trading Bot turns a YAML-defined grid strategy into automated Hyperliquid order placement with testnet/mainnet switching, explicit position caps, and drawdown controls.

Polymarket Trading Bot automates Polymarket UP/DOWN entries and exits against live CLOB prices, so you can run deterministic strategy rules on real on-chain balances instead of guessing PnL in memory.

CrossLink collapses multi-provider LLM traffic into one OpenAI/Anthropic-compatible control plane with routing, failover, caching, RBAC, budgets, and MCP support.

clab turns GitLab merge request review into a local, deterministic Claude Code workflow that fetches diffs, runs rule checks, and posts inline comments without Node.js or third-party SaaS.

Zap strips shell noise at the source, shrinking AI-facing command output by 60–90% with Rust-based filtering, grouping, and deduplication.

ascii-agents turns invisible terminal agent activity into a live pixel-art office, so you can see who is typing, waiting, or idle without spelunking through logs.

Duckle turns local ETL into a typed, Git-friendly desktop workflow: visual pipelines compile to DuckDB SQL, run on your machine, and can be generated by an on-device LLM without sending data to a cloud API.

WeChat Radar turns noisy WeChat groups into a local-only SQLite intelligence board with daily briefs, topic clustering, and link deduplication.

tuie replaces ad hoc terminal widgets with a dirty-tracked Rust widget tree that handles layout, images, async events, and GUI fallback in one API.

PiD replaces the usual VAE/RAE image decoder with a conditional pixel-space diffusion module, so a latent can become a super-resolved image in one pass without a separate upsampler.

codeindex turns a polyglot repo into a local dependency graph plus symbol map, so you can measure blast radius and resolve definitions without scanning every file.

gepa-viz makes GEPA optimization inspectable in real time by turning candidate evolution, minibatch feedback, and pareto-frontier decisions into a live graph you can debug instead of guessing from logs.

Adobe Lightroom Classic is a local-first RAW editor with non-destructive catalog workflows, fast batch exports, and AI-assisted cleanup for photographers who need desktop-grade control on Windows.

Topaz Gigapixel AI Pro enlarges photos with local AI models, preserving faces, hair, and texture up to 16x on a Windows GPU instead of sending jobs to the cloud.

Adobe Substance 3D Painter is Adobe’s production PBR texturing app, and this GitHub page is an unauthorized mirror that advertises a pre-activated Windows build, so the real technical question is supply-chain trust, not features.

Lumion Pro turns CAD-heavy AEC scenes into interactive, ray-traced renders on Windows, but this repo’s pre-activated packaging introduces license, update, and supply-chain risk.

Nitro PDF Pro turns scanned PDFs into searchable, editable files, redacts sensitive content permanently, and exports cleanly to Office formats on Windows without pushing documents through a browser.

webchat2api turns GPT/ChatGPT Web and Grok/xAI Web sessions into an OpenAI-compatible, self-hosted API with account pooling, tier-aware routing, and a browser-managed control plane.

comimi embeds a standalone manga reader into any website with a single TypeScript API, no React dependency, and built-in page navigation, settings, events, persistence, and i18n.

DeepSeek GUI turns DeepSeek TUI into a permissioned desktop agent workspace with project-scoped file access, inline diffs, and Skill/MCP management.

Automates Polymarket UP/DOWN market trading with live CLOB pricing, on-chain balance checks, and FAK order execution from a single TypeScript runtime.

ai-usagebar turns opaque AI subscription quotas into live, vendor-aware telemetry in Waybar and a tabbed TUI, with drop-in claudebar compatibility, safe OAuth refresh, and multi-vendor support from one Rust binary.

winproc-tui gives Windows 11 developers a terminal-first view of per-process RAM, VRAM, handles, GUI resources, I/O, and open files, with time-series graphs, A/B deltas, and JSON Lines playback in one screen.

Wallpaper Engine turns a Windows desktop into an animated, interactive wallpaper runtime with 4K/8K scenes, Workshop content, and low idle CPU usage.

GOIP turns an MMDB-backed IP database into a low-latency local lookup service with batch queries, multilingual output, and zero license cost.

A lightweight Windows desktop shell for DeepSeek V4 Pro and Flash that gives you chat, reasoning, and coding assistance without forcing a browser workflow.

grok-cli turns xAI into a scriptable terminal interface with OAuth login, streaming defaults, and stable JSON envelopes for shell pipelines and agent runtimes.

psleep replaces dead-air terminal sleeps with native or inline progress feedback, so scripts stay visible without changing the sleep semantics.

flate replaces the usual kind plus kubectl plus helm plus kustomize stack with one static Go binary that renders, diffs, and tests Flux repos offline, and changed-only mode can collapse single-file reviews to tens of milliseconds.

XPlex turns multiple Xray tunnels into one SOCKS5 endpoint by duplicating each byte across N paths and keeping sessions alive through automatic failover.

Lossless Scaling turns borderless-windowed games into sharper, smoother output by combining integer scaling, configurable upscaling, and LSFG frame generation in a local Python app.

A Python + Playwright workflow that automates ChatGPT account registration, billing, OAuth token export, and browser-session extraction across Windows, macOS, and Linux.

FigMirror turns a screenshot of a reference figure into editable matplotlib code and a camera-ready PDF by iterating with an agentic Drawer-Reviewer loop that preserves visual style instead of forcing manual reformatting.

framedex turns raw video drives into sidecar-based, queryable knowledge by extracting metadata, transcripts, faces, and scene descriptions without touching the originals.

YellowKey BitLocker is a WinRE-and-USB BitLocker bypass proof of concept that targets physical-access attacks on TPM-only Windows 10 and 11 systems.

Pianke turns near-duplicate shoot folders into ranked winners and losers entirely on-device, so you can cull faster without sending client work to the cloud.

Polymarket Trading Bot is a TypeScript automation scaffold for rule-based Polymarket CLOB execution with authenticated order flow, retry controls, cooldowns, and operator-friendly logging.

A Windows-focused Tauri launcher that installs, switches, and starts Legacy Console Edition community builds, skins, and multiplayer setups without manual file surgery.

Cheat Engine 7.5 gives you direct control over live Windows process memory so you can scan, patch, debug, and script trainers without guessing.

Handsets turns Android UI automation into a low-latency shell protocol: one on-device jar, no root, label-based selectors, and millisecond-scale calls instead of ADB round-trips.

CodexPilot adds a non-destructive local control plane on top of Codex so you can route models, export sessions, and repair provider metadata without patching the app.

kiro-rs turns Claude-compatible requests into Kiro API calls with token refresh, multi-credential failover, and SSE streaming for self-hosted gateways.

pipa embeds an ES2023 runtime in Rust with bytecode compilation, built-in async I/O, and a tiny dependency-light footprint for fast in-process scripting.

A lightweight terminal agent that brings Gemini, slash commands, and MCP-backed workflows into a single CLI for developers who want AI coding help without leaving the shell.

ai-memory turns agent sessions into a persistent, git-backed project wiki so the next coding agent inherits decisions, open questions, and failed approaches without re-explaining the entire codebase.

Sword collapses Pacman, Flatpak, and AUR into one deduplicated desktop catalog, so Linux users can search, inspect, install, and remove software without hopping between separate frontends.

It converts Polymarket CLOB prices and on-chain balances into deterministic UP/DOWN execution with FAK orders, so you can automate entry, exit, and emergency flips without guessing portfolio state.

Leoflow replaces Airflow's Python control-plane bottlenecks with a Go scheduler, immutable DAG artifacts, and ephemeral pods per task, so orchestration stays fast while dependencies stay isolated.

Automates live Polymarket entry, exit, and swap decisions from on-chain balances and 1-second CLOB pricing so you trade actual settlement state instead of guessed PnL.

A live Polymarket execution bot that resolves market slugs, reads on-chain balances, and fires FAK orders on a 1-second loop with no paper-trading layer.

goLoL inventories LOLBAS binaries already on a Windows host, filters techniques by your current privilege level, and maps each match to MITRE ATT&CK with example commands.

codex-shim keeps Codex Desktop’s native agent loop intact while routing OpenAI Responses traffic to BYOK providers or ChatGPT Codex through a local proxy, so you can swap models without rebuilding the app.

nix-cache-beacon turns local Nix machines into a peer-discovered binary cache mesh, so nearby builders can substitute from LAN caches instead of hammering a single remote endpoint.

psign replaces signtool.exe with a Rust-first Authenticode CLI that signs, verifies, timestamps, and inspects PE, NuGet, MSIX, RDP, and ZIP artifacts with portable and Windows-backed execution paths.

pie turns a terminal into a repo-aware agent that edits files, runs commands, persists memory, and resumes sessions without forcing you out of the shell.

Kimi Code CLI turns a terminal into an agentic coding loop that can read files, edit code, run shell commands, and coordinate MCP tools without leaving the shell.

Web3 Developer Toolkit compresses web3 project scaffolding, contract generation, wallet ops, RPC checks, deployment, event monitoring, and Next.js wallet integration into one local Node.js CLI.

SmartNode models satellites, ground stations, relay links, and task scheduling in a local web app, so you can test data-backhaul workflows without a full mission operations stack.

Bumblebee turns messy on-disk developer metadata into read-only NDJSON inventory and exact exposure matches without executing package managers or touching source files.

devgrep turns shell history, logs, and markdown notes into a single local SQLite index you can query from the terminal without cloud sync, accounts, or telemetry.

VPN over SSH turns stock OpenSSH into an L3 VPN by preallocating TUN pairs and routing traffic over an encrypted SSH session, so you avoid running a separate VPN daemon.

expo-motion-tabs replaces Expo Router’s default tab bar with a typed Reanimated popup panel that keeps routing intact while giving each tab a custom animated surface.

DarkGPT is a self-hosted chat client that swaps policy-heavy hosted chat for configurable jailbreak presets, OpenAI-compatible backends, and local control over prompts, transport, and storage.

Hy-MT2 gives engineering teams a 33-language translation stack with 1.8B, 7B, and 30B-A3B variants, including a 440 MB 1.25-bit on-device build that still keeps instruction control intact.

Lucarne turns Telegram and WeChat into a no-touch control plane for local agent processes, so approvals, interruptions, resumes, and failure alerts happen on your phone without changing your repo or adding MCP hooks.

Mega-ASR is a foundation ASR model trained on real-world acoustic corruption so it stays accurate when clean-audio speech recognition fails under noise, reverberation, far-field capture, obstruction, and dropout.

Markov Hedge Fund Method converts raw price history into a discrete regime model, transition matrix, and walk-forward signal so you can filter trades by market state instead of guessing from momentum alone.

OpenAI Plus VXT turns OpenAI and PayPal signup flows into a locally persisted browser automation layer for session extraction, address staging, and form autofill without hand-copying data.

Polybot turns Polymarket into a paper-first terminal workflow with direct CLOB v2 execution, wallet mirroring, and non-bypassable risk controls.

slopless is a Node 22+ Markdown linter that catches AI and human slop with 50+ deterministic textlint rules and returns structured JSON, so teams can gate prose without paying an LLM tax.

Centaur turns Slack threads into durable, sandboxed agent jobs that can inspect repos, call approved tools, and return auditable results without exposing raw secrets.

Ursula turns append-only event timelines into a quorum-replicated HTTP and SSE service with sub-50 ms P99 appends and S3-backed cold storage.

HLOOL Mail gives you a self-hosted MX catch-all stack with API keys, webhooks, share links, and CLI access, so you control inbound mail data instead of pushing it through a third-party temp inbox.

infinite-canvas collapses canvas planning, image generation, reference editing, prompt reuse, and asset storage into one self-hosted interface, so teams can iterate on visual ideas without bouncing between disconnected tools.

DEEIX Chat unifies model routing, multimodal chat, RAG, MCP tools, billing, and identity behind a Go-backed control plane, so teams can ship one governed AI workspace instead of stitching together multiple services.

yapsnap turns any video URL or audio file into plaintext on CPU, with optional timestamps and speaker labels, without a GPU, cloud API, or PyTorch stack.

A Dockerized Claude Code host that turns one interactive session into a remote, structured, multi-protocol development surface with live events, hooks, and drop-in API compatibility.

Agent Orchestration gives enterprises a distributed control plane for AI agents, with lifecycle management, secure inter-agent communication, scheduling, and verifiable execution.

Papr keeps RSS reading local in SQLite, adds FreshRSS sync, and layers AI summaries, full-text extraction, and auto-tagged smart views onto a native desktop workflow.

tmux.expose turns tmux session selection into a live visual grid with ANSI-colored previews, so you can jump to the right workspace without memorizing names.

Meridian gives you a browser-based control plane for orchestrating Codex CLI across multiple machines without replacing the agent itself.

pdf2md turns PDFs into structured Markdown through local Docker-backed VLM pipelines, so you can keep documents on-prem while extracting layout-aware text with minimal host dependencies.

Refactoring Rust turns correct but awkward Rust into clean, idiomatic code through self-contained refactor drills that force you to practice ownership, pattern matching, and structural design under real compiler feedback.

BunnyMQ gives you Kafka-style topics, partitions, consumer groups, and `acks=all` replication in a Go broker built on Multi-Raft, so you can run a distributed event log without dragging in the full Kafka stack.

database_scan finds sensitive data in live databases and Redis by scanning schema names, field content, and row samples across multiple SQL protocols, then surfaces the evidence in terminal tables or Excel.

Encodes Shadowsocks payloads as real HTTP/2 HEADERS and DATA frames through SIP003, but the repo explicitly says it is an example project and not suitable for production use.

PaperSpine turns manuscript writing into an auditable, evidence-backed pipeline so Codex and Claude Code draft papers, reports, and reviews with rationale, source inventory, and revision history instead of ad hoc prose edits.

YellowKey BitLocker demonstrates how WinRE and Transactional NTFS edge cases can undermine the assumed physical-security boundary of default TPM-only BitLocker on unpatched Windows machines.

RMUX turns terminal sessions into detachable, scriptable state with a tmux-compatible CLI, typed Rust SDK, and inspectable snapshots.

leak-hunter scans local folders and GitHub repos for secrets with a Rust-native engine, redacts findings by default, and emits JSON, text, or Markdown for CI and terminal review.

Anamnesis turns fragmented agent memory into one local SQLite-backed index with provenance, hybrid search, and MCP access.

CloakBrowser swaps in a modified Chromium binary with 49 source-level fingerprint fixes so Playwright and Puppeteer traffic looks like a normal user browser instead of an automation session.

Glass replaces the slow, license-locked IDA-style workflow with a local Rust-native disassembler that renders at 120fps, analyzes many large binaries in 1–2 seconds, and exposes every action as CLI JSON and MCP tools.

Humanize-Text turns AI-generated prose into a reproducible multi-hop rewrite pipeline that preserves key facts while changing structure, rhythm, and detector fingerprints.

hsrs generates type-safe Haskell bindings from annotated Rust code, so you avoid hand-written FFI glue, manual memory management, and brittle serialization code.

A GPU-backed geometrized JSON generator that replaces full-image CPU passes with OpenCL ellipse evaluation, cutting per-ellipse time by multiples on real hardware.

An open-source Claude skill pack that turns German legal workflows into structured prompts, decision trees, and document templates for firms that need reproducible outputs under strict compliance rules.

AI-Humanizer rewrites AI drafts with translation chains, multi-turn LLM passes, and detector-guided feedback so you can measure which humanization method preserves meaning with the least detectable patterning.

audit turns Claude subscription access into an 8-stage, schema-validated vulnerability-discovery pipeline that uses narrow agents, adversarial validation, and reachability tracing to cut false positives before reporting.

OKX Agent Trade Kit gives MCP clients local, API-key-safe control over OKX with 145 tools for market data, trading, account, and bot workflows.

Monitors Hyperliquid's public order flow in real time and flags whale fills, whale walls, and bias shifts without API keys, rate limits, or paid feeds.

Phonto pushes video wallpaper rendering onto the GPU, using GStreamer/EGL on Wayland and AVFoundation/VideoToolbox on macOS so animated backgrounds stay low-overhead and native.

Codiff turns Git diffs into a local, keyboard-driven review workflow with inline comments, commit-level inspection, and optional Codex-assisted walkthroughs.

adbc-driver-quack turns remote DuckDB Quack sessions into Arrow-native reads and writes, returning real `RecordBatch` objects and streaming `Statement.BindStream` ingest without row-by-row cursor overhead.

Automates Polymarket 1-hour Up/Down spread trading with explicit risk exits, so hourly entry, fill management, and redemption are handled by code instead of manual clicks.

PromptOps removes hardcoded prompts by turning prompts, agents, and workflows into versioned runtime assets with hot reload, gray release, and audit trails.

HRM-Text turns small-budget Hopper clusters into a full foundation-model pretraining stack, with a hierarchical recurrent architecture, deterministic sampling, and exportable checkpoints.

Forge isolates each task in its own git worktree, then enforces CI and review gates so multiple coding agents can ship changes to the same repo without clobbering `main`.

Kuberik turns Kubernetes rollouts into in-cluster CRDs with Flux-aware promotion, health checks, and gates, so teams ship staged releases without a central CI/CD pipeline.

Lance is a 3B-parameter native multimodal model from ByteDance that handles image and video understanding, generation, and editing in one shared backbone.

Weft turns a bloated ~/.claude/skills directory into a local, searchable index so Claude Code users can pick the right slash command in seconds instead of hunting through 50+ files.

Bento packages goroutine-backed HTTP serving, low-dependency binaries, and config-driven output formats into a Go-first runtime for edge model serving.

UdioMusic gives Rust teams a memory-safe base for real-time audio processing, concurrent pipelines, and structured configuration without giving up cross-platform deployment.

pluck turns repo code retrieval into an AST-aware MCP service, cutting code-read tokens by 84-88% while preserving exact bytes through `--raw` fallbacks.

AI Gateway turns multiple AI providers into one OpenAI/Claude-compatible control plane with master-agent sync, quota enforcement, and region-aware routing.

ScoreBot-Go turns school score querying into a pluggable Go backend with CLI and QQ Bot adapters, so one command core can run locally, on SQLite, or behind FC without rewriting the business logic.

OVH 控制台 turns OVH inventory watching, automated purchasing, and server lifecycle operations into one SQLite-backed console with per-account isolation.

NanoTDB keeps time-series data local in plain files with WAL recovery and offline CLI inspection, so small edge systems can store metrics without a heavier observability stack.

It turns a JD into a ranked project shortlist, repo audit, interview pack, and runnable plan so low-experience candidates can ship something explainable instead of guessing.

NolanX extends short-form text, image, and video models into long-running filmmaking pipelines that keep story, character, and asset continuity intact across hour-scale runs.

Wallpaper Engine turns a Windows desktop into an animated, interactive surface with Steam Workshop content, while keeping the workflow local, simple to launch, and tuned for Windows 10/11.

DiskWatch turns low-level disk telemetry into one terminal view so you can spot capacity pressure, IO bottlenecks, SMART failures, and hot-file churn before they become an outage.

GrokSearch-rs turns MCP clients into search-capable agents with a Rust stdio server, cached citations, and fallback extraction across xAI, OpenAI-compatible relays, Tavily, and Firecrawl.

claude-pee turns Claude Code into a scriptable, session-safe CLI front-end that prints only the assistant reply and exits deterministically through Claude's own Stop hook.

rivers keeps orchestration planning in Rust while letting teams define assets in Python, which cuts control-plane overhead and keeps large dependency graphs deterministic.

ratscad turns OpenSCAD into a terminal-first IDE with live inline 3D preview, debounced background builds, and per-document caching so edits feel immediate without leaving the TUI.

Legado Flutter replaces Android-only Legado with a Flutter + Rust architecture that keeps book-source parsing, reader state, and SQLite storage portable across Android, iOS, Windows, macOS, and Linux.

Vibe Observer turns Claude Code hook noise into local SQLite evidence so you can pinpoint which session, model, and tool calls burned time and API-equivalent cost.

zerostack replaces heavyweight JS-based coding agents with a tiny Rust binary that delivers multi-provider chat, permission-gated tool use, and session-aware automation in the terminal.

a2text turns Linux speech dictation into a hotkey-driven, clipboard-safe daemon with local or cloud STT, making voice input usable on Wayland without giving up control.

cfsearch finds origin IPs hidden behind Cloudflare by spraying CIDR ranges with concurrent HTTP/HTTPS probes and validating responses with a forged Host header.

OpenFriendMC tunnels Java Edition Friends List joins over WebRTC into a real TCP Minecraft server, so admins can expose snapshot 26.2 friend-based entry without rewriting their stack.

Argus validates Go structs with zero third-party dependencies, a zero-reflection string fast path, 97+ built-in rules, and built-in i18n for teams that want fast, cacheable validation without supply-chain bloat.

PasteLocal moves your local clipboard, screenshots included, into remote SSH sessions so terminal-first developers can paste real context into agentic coding tools without opening new ports.

comview turns Git diffs into a keyboard-driven terminal review surface with comments, search, and watch mode, so you can inspect changes without leaving the shell.

CPA-Helper turns CLIProxyAPI into a self-hosted control plane for per-user keys, usage accounting, request tracing, pricing, and Codex auth-file maintenance without proxying model traffic.

Saboteur injects request-aware HTTP faults at the proxy layer so you can test resilience with URL, header, and body-sensitive rules instead of blunt TCP chaos.

FAROS turns research automation into a blueprint-bound runtime, so teams can swap providers, preserve workflow contracts, and ship repeatable LLM research pipelines without rewriting orchestration.

Orthrus keeps generation exact while moving decoding onto a shared-KV dual-view diffusion path, so you get up to 7.8× faster token generation without changing model outputs.

Elephant Agent turns chat history into an inspectable Personal Model so an AI agent can remember what matters, ask only when a missing answer changes the outcome, and stay correctable over time.

TradingAgents-Astock把多 Agent 投研框架改造成可直接跑 A 股的 Python 工作流：7 个分析师、A 股交易约束、免费直连数据源和双 LLM 决策链，一次分析就能产出可审计的中文投研报告。

C++-patched Firefox that keeps Playwright scripts intact while resisting fingerprint detectors better than JS-shimmed Chromium forks.

Codex Complexity Optimizer turns a Codex session into a repo-wide complexity audit that flags hotspots, ranks risk, and tells you exactly what to change before you touch production code.

VGGT-Ω turns multi-view RGB frames into camera poses, depth maps, and register tokens in a single PyTorch forward pass, replacing brittle SfM prepasses with one GPU inference path.

YellowKey-Bitlocker gives you a portable Windows GUI for unlocking and recovering BitLocker drives without digging through buried system dialogs or memorizing `manage-bde` syntax.

Stable Diffusion WebUI gives you local, browser-based control over Stable Diffusion models, extensions, and batch generation without depending on a hosted API.

RBXFPSUnlocker removes Roblox's 60 FPS cap on Windows so high-refresh monitors can render at 144Hz, 240Hz, or higher instead of wasting display headroom.

Hydra Launcher consolidates legally owned PC games from multiple platforms into a single Windows launcher with fast local startup, simple library management, and an MIT-licensed codebase.

Zelda: Twilight Princess PC removes the emulator layer and ships a native Windows build with higher resolutions, modern input, and a simpler launch flow for owners of the original game files.

UltraViewer Pro gives Windows support teams a direct ID-based remote-control flow with screen sharing, chat, and file transfer, so technicians can troubleshoot endpoints without exposing RDP or forcing users through VPN setup.

OSIRIS turns scattered public-intelligence feeds into one GPU-rendered map so you can monitor thousands of live entities at 60fps instead of juggling separate tabs and APIs.

clawpatch turns code review into a stateful, slice-by-slice workflow that persists findings and can generate one explicit patch attempt per issue.

Umbrella Spoofer resets Windows hardware fingerprints with kernel-driver-backed identity changes, cleaner routines, and serial edits so banned gaming rigs can present a different machine profile.

agent-html converts semantic `.agent.html` docs into portable HTML artifacts with strict schema validation, so agent output stays stable, reviewable, and easy to share.

An event-driven Polymarket CLOB V2 executor that turns live order-book and reference-price streams into rule-based entries with wallet-backed signing and low-latency timing control.

Mouzi keeps Windows folders tidy by watching them continuously, applying ordered extension and regex rules, and moving files locally with SQLite-backed history and one-click undo.

LocoAgent turns a real Chrome session into an autonomous social media operator that can browse, react, and publish with 32+ X.com operations instead of brittle API-only scripts.

K.I.R.O Register automates AWS Builder ID account creation, token refresh, subscription management, and health checks from a local Python GUI instead of brittle manual browser steps.

Centipede is a Go-based Linux worm that chains local privilege escalation, multi-vector propagation, and four-tier encrypted C2 into a self-sustaining botnet-style implant.

Beacon gives security and IT teams local-first telemetry on AI coding agents, normalizes endpoint events into JSONL, and forwards them to SIEMs without centralizing raw prompts on a third-party backend.

GOBBY turns a Mac Mini M4 into a single-user, always-on Codex host that keeps one identity across chat, voice, and web surfaces without pushing the control plane off-box.

Prodigy Hacks turns Prodigy's read-only parent API into a local CLI that surfaces weekly progress, skill mastery, and screen-time data without modifying the account.

Shannon turns the interactive Claude Code CLI into a scriptable session runner that streams JSON through a real tmux-backed terminal, so developers can automate Claude without bypassing its normal transcript flow.

Sven Family unifies AI workflow creation, community, publishing, admin, crawling, and analytics in one MIT-licensed monorepo so teams can ship an end-to-end product stack without stitching together separate services.

NGINX Rift turns a 2008-era NGINX rewrite-module heap overflow into a reproducible unauthenticated RCE chain, with enough implementation detail to study real heap grooming and cleanup-pointer corruption.

p-peg fuses SOL-backed minting with on-chain creature state so collateral risk has both financial and game-state consequences.

semble_rs turns local repos and noisy build logs into model-friendly context with hybrid semantic search, syntax-aware chunking, dependency graphs, and up to 99% token reduction.

verilog-ths mirrors Polymarket fills into your wallet with V2-ready order placement, deterministic sizing caps, and a polling loop you can audit line by line.

Track one Polymarket wallet, filter its fills, and turn whale activity into auditable alerts and paper trades without private exchange auth.

pi-llamacpp turns Pi into a self-managed local Qwen3.6 inference provider that pins compatible llama.cpp builds, downloads GGUF models on demand, and shuts the server down automatically.

It turns five Draco-compressed cell and molecule models into a browser-based lesson with real download progress, local decoding, and touch-friendly 3D inspection.

Claude Design Free gives React teams an opinionated, streaming-ready UI layer for Claude apps, with sanitized Markdown, LaTeX, and artifact-style rendering built for low-cognitive-load interfaces.

Tomodachi Share automates Tomodachi Life: Living The Dream Mii, island, and special-content transfers so players can export, import, and share saves without manual file surgery.

monogit replaces scattered `git` tab-switching with one terminal dashboard that scans many repos, tracks branch drift, and executes fetch, pull, push, stash, and commit actions from a single keyboard-driven view.

tmux-palette turns tmux into a searchable command palette with Bun-fast startup, JSON-backed customization, and popup actions that dispatch panes, sessions, themes, and shell tools without a forked config.

A ranked open-source directory of 109 algorithmic trading projects that uses automated quality signals to cut through GitHub noise.

ZenithDB cuts AI agent trace storage costs by using trace-local columnar segments, late materialization, and inline full-text indexing instead of forcing OLAP engines to decode every sparse JSON field.

Testo turns Go's `testing.T` into a suite-oriented framework with plugins, hooks, and cached state so large test suites stay composable without leaving the standard toolchain.

pgGraph turns ordinary PostgreSQL tables into a derived graph index, so you can run traversal and shortest-path queries without introducing a separate graph database.

Automates real-time Polymarket copy trading with wallet tracking, balance-aware sizing, and a confidence filter that cuts low-quality signals before they hit the order book.

MDXG standardizes how markdown is rendered and navigated across apps, turning a single .md file into a structured, searchable, theme-aware experience without changing the source syntax.

forkd turns a warmed Firecracker parent into hundreds of isolated child microVMs with copy-on-write startup, cutting fan-out spawn time to 101 ms for 100 sandboxes while keeping KVM-level isolation.

ELF implements continuous-time flow-matching text generation in JAX, keeping tokens in embedding space until the final decode step to make diffusion-style control practical on TPUs.

mochi keeps fingerprints, transport, and human input on one deterministic control plane so bot defenses see a coherent Chrome session instead of stitched-together spoofing.

sandboxed-lit runs an OpenAI-backed agent inside a microsandbox VM, so file inspection and bash automation stay boxed away from the host filesystem.

gograph turns a Go repo into a queryable structural graph so agents can pull exact code slices, call chains, and impact analysis without burning context on raw file reads.

Local, low-latency Claude Code status mirroring that maps hooks and MCP events to a transparent always-on-top pixel pet with no manual refresh.

SIRA turns plain BM25 into a multi-stage retrieval system by using LLM-generated corpus and query expansions plus reranking, so you get stronger BEIR-level retrieval without training a model.

telecrawl turns local Telegram Desktop data into a searchable SQLite archive and age-encrypted Git backups without making normal search traffic leave your machine.

Self-hosted GitHub-compatible control plane that keeps repos as bare Git and metadata in MySQL/TiDB while letting agents use familiar GitHub clients.

MedgeNet replaces Mirror's Edge's retired EA backend with a self-hosted Go server and Windows launcher so PC players can restore accounts, leaderboards, and ghosts without depending on dead infrastructure.

olcrtc-manager-panel turns multiple olcrtc servers into a quota-enforced, per-client isolated control plane with a browser UI, automatic accounting, and reloadable systemd-managed processes.

Pixal3D converts a single image into a high-fidelity GLB mesh by back-projecting pixel features into 3D, which preserves geometry-to-texture alignment better than attention-only image conditioning.

Automates ChatGPT Business promo-code discovery, geo-aware validation, and Stripe checkout generation with Python scripts, proxy switching, and batch result capture.

Mirrors a target Polymarket trader into your own wallet with polling, size multipliers, and per-order safety limits.

Event-driven Raydium CPMM sniping with pre-trade risk filters, multi-step exits, and Jito bundle tips for Solana mainnet operators.

WeatherBet turns forecast deltas into executable Polymarket trades with EV gating, fractional Kelly sizing, and paper-or-live CLOB execution.

Goblin Agent turns Hermes Agent into a stateful, SQLite-backed goblin persona with moods, hoarded memory, and code appraisal logic that makes agent output more opinionated without rewriting the core runtime.

A reference Rust bot for parsing Solana pools, detecting DEX types by account owner, and constructing on-chain arbitrage routes across 13 AMM families.

It automates the specific ChatGPT Plus + GoPay checkout chain with a split orchestrator/core architecture and OTP relays, finishing a prepared run in about 20 seconds.

cs2-external-overlay adds a transparent, click-through DirectX 11 overlay on top of CS2 without code injection or kernel drivers, so you get live HUD data with sub-1% GPU overhead on modern hardware.

byteview gives you color-coded hex, entropy analysis, string extraction, and magic-byte detection in a single Python terminal utility, so binary triage stays local and scriptable.

It continuously compares Kalshi YES and Polymarket UP prices, flags 10-cent spreads, and can auto-place Polymarket buys from a single TypeScript service.

Velotype replaces browser-shell editors with a Rust-native block model that keeps Markdown canonical, exports to HTML/PDF, and stays portable as a single binary.

K.I.R.O Register automates AWS Builder ID registration, token refresh, subscription handling, and health checks from a Python + Playwright workflow backed by SQLite.

Monitors Kalshi and Polymarket price gaps in real time, applies explicit spread rules, and can execute Polymarket buys with a configurable, code-first workflow.

cwc-workshops packages Anthropic's Code with Claude labs into reproducible agent-building exercises that teach Claude Code, MCP, Skills, and Managed Agents through real app workflows.

solana-staking packages an Anchor staking program and TypeScript CLI for FLOWERS so teams can launch tiered lockups, reward vault funding, and early-exit penalties without rebuilding Solana account plumbing.

Normalize S3, GCS, Azure Blob, Vercel Blob, and local files behind one typed API, then drop to the native client only when you need provider-specific behavior.

HentaiHunter turns a gallery URL into a parallelized, numbered image archive with site detection, metadata extraction, and generic DOM scraping in one terminal command.

Turns Codex Desktop into a Windows-friendly router for DeepSeek and OpenAI-compatible endpoints without rewriting Codex itself.

StackPrism fingerprints a site's stack from DOM, headers, runtime signals, and bundle comments so you can identify frontend and backend technologies without relying on brittle HTML-only heuristics.

tau is a minimal Rust harness that turns repo-local instructions, dotenv secrets, and a strict cargo validation loop into a predictable coding-agent workflow.

supacrawl turns a live Supabase/Postgres project into a local SQLite snapshot with FTS5 search, read-only SQL, and row-level metadata visibility, so engineers can inspect schemas and policies without dashboard spelunking.

Eat Better packages an ASP.NET Core API, a Vite + React TypeScript UI, and Dockerized SQLite persistence into one repo you can clone and run immediately.

GoblinOS turns Hermes Agent into a stateful goblin persona with persistent memory, mood-driven behavior, and a CLI/API layer for hoarding, appraising, and mutating code.

pkfire turns task orchestration into typed Pkl schemas with DAG-aware incremental caching, so monorepos stop duplicating shell snippets and rerun only changed work.

zalo-tg turns Zalo and Telegram into a bidirectionally synced message bus, preserving replies, reactions, polls, and media routing through a single Node.js process.

wbts collapses journald, dmesg, Docker, Kubernetes, package-manager, and auth evidence into one timestamped incident timeline so you can identify the first bad signal without manual log triage.

Pulse manages distributed edge nodes through a persistent mTLS gRPC control plane, pushing config changes in seconds while bundling quotas, billing, routing, and audit logs.

OpenSquilla collapses routing, memory, sandboxing, and provider abstraction into one local agent loop so teams can swap OpenAI, Anthropic, Ollama, or OpenRouter without rewriting their workflow.

AzuDl - GC2GD routes direct links, YouTube media, and torrents into Google Drive through aria2 and yt-dlp, with session persistence, duplicate torrent detection, and a tabbed Colab GUI.

HiDream-O1-Image collapses pixels, text, and editing controls into one shared token space, giving developers a single model for text-to-image, layout-aware editing, and subject personalization at 2,048×2,048.

Delta Executor is a Windows-first Python launcher for Roblox script execution that emphasizes a lightweight terminal workflow, but its advertised injection and bypass behavior makes it a high-risk choice outside isolated test environments.

A typed Node.js casino backend with provably fair Blackjack, wallet-ledger persistence, and Prisma-backed game state.

AIEden is a blueprint for persistent LLM agents that treat memory, action, and causality as a continuous life loop instead of isolated prompts.

An open-source React and Three.js biology gallery that renders cell specimens in 3D, falls back to procedural geometry when GLBs are missing, and verifies every viewport with Playwright screenshots.

Automates a Solana token launch end-to-end by minting SPL or Token-2022 assets, creating a Meteora DAMM v2 pool, and wiring an Alpha Vault FCFS from one TypeScript codebase.

btype gives Go services ordered collections with O(log n) writes, O(log n) random access, and O(1) copy-on-write snapshots, which is a strong fit when slices and hash maps stop being enough.

1xBTS is an Apache-2.0 Rust CDMA2000 1x stack that runs the full BTS-to-core path, including voice and packet data, for authorized lab interoperability testing on supported SDRs.

rlisp lets you write Rust semantics in Lisp syntax, then hands the generated `.rs` file to `rustc` so you keep type checking, borrow checking, and optimization without learning a new compiler pipeline.

ClickClackClaw ships a self-hosted, API-first chat stack as one Go binary with embedded SQLite, embedded UI assets, and durable realtime events.

rlisp translates Lisp s-expressions into real Rust source so you keep Rust’s type system, borrow checker, and optimizer while writing syntax that is far easier to macro-expand and structurally edit.

Google-Health-CLI turns Google Health API v4 into deterministic, script-friendly terminal commands with OAuth, rollups, webhook management, and machine-readable output.

nanowhale is a 110M-parameter DeepSeek-V4 reference build that lets ML engineers test MLA, MoE, hyper-connections, and SFT plumbing without a frontier-scale budget.

CodexSaver routes low-risk Codex tasks to cheaper worker models while keeping risky judgment in Codex, which cuts inference spend without sacrificing review quality.

Photo Agents turns a local Python runtime into a screen-aware agent loop with layered memory, multi-provider LLM routing, and real desktop/browser actuation.

Concord puts Discord browsing, messaging, reactions, threads, and image previews into a Rust TUI so you can stay in the terminal without losing core chat workflows.

Deptool turns small-cluster config deploys into a declarative, SSH-driven plan-and-apply workflow with millisecond planning and sub-second execution.

Whale turns DeepSeek into a terminal-native coding agent with prefix-cache-aware sessions, local file edits, shell execution, MCP tools, and Skills, so long tasks stay cheap and interactive.

NLA turns a hidden residual-stream vector into a natural-language explanation and reconstructs it back, so you can test whether the words preserve the activation direction instead of just sounding plausible.

Codex++ restores plugin access and adds session deletion to Codex App without modifying `app.asar`, using CDP injection plus a local helper service and SQLite backups.

deecodex turns Codex CLI Responses API traffic into DeepSeek-compatible Chat Completions while adding local file search, MCP execution, and vision routing in one Rust proxy.

It turns scattered AI agent material into a 7-stage, hands-on curriculum that gets you from LLM basics to multi-agent systems and MCP servers without guessing what to study next.

LUKSbox turns sensitive files into a tamper-evident, host-untrusted vault with per-chunk AEAD, detached headers, and optional FIDO2/TPM/post-quantum keyslots.

Clipify uses Claude Code, Whisper, and ffmpeg to turn long-form talking-head video into vertical, subtitle-burned social clips entirely offline.

solidity-cot-auditor turns terse Slither findings into role-separated LLM explanations, exploit sketches, minimal fixes, and a judge score for faster smart contract triage.

WAF Killer turns FOFA-driven target collection, WAF fingerprinting, rule validation, and clustering into a local Go desktop workflow instead of forcing you to stitch together separate scanners and spreadsheets.

ModelLink turns Claude Desktop into a local model router, letting one GUI switch between Kimi, DeepSeek, GLM, MiniMax, Baidu Qianfan, and other API providers without hand-editing config files.

steamer automates SteamGridDB artwork downloads for non-Steam games, saving you from manual icon and cover wrangling while preserving existing assets by default.

beava turns event streams into atomically updated per-entity features at sub-millisecond read latency without a separate broker, warehouse, or feature store.

Skeeper keeps specs in a sidecar Git repo, pins them with a lockfile, and fails closed on Git hooks so docs history stays auditable without bloating code PRs.

ProgramBench measures whether an agent can rebuild a working codebase from a compiled binary and documentation, which makes it a strict black-box test for program synthesis, reverse engineering, and behavioral fidelity.

agent-skills-eval proves whether a `SKILL.md` improves model output by running a baseline-vs-skill A/B eval, grading both with a judge model, and writing machine-readable artifacts for CI.

girl-agent turns a static prompt into a stateful Telegram persona with sleep, schedule, memory, reactions, and relationship logic.

DeepSeek TUI turns DeepSeek V4 into a terminal-native coding agent with approval-gated edits, 1M-token context handling, and local session control.

TRUST folds file editing, project browsing, and one-key Cargo run/check/test/build into a single retro terminal interface, so Rust work stays inside the editor instead of bouncing across shells.

MiniMind-O is a from-scratch PyTorch Omni stack that unifies text, vision, and streaming speech in one model, so you can study, train, and ship multimodal interaction without chaining ASR, LLM, and TTS services.

Karpov Gateway packages API routing, auth, quota enforcement, encrypted credential storage, and an admin console into one open-source stack so small teams can ship a gated backend without stitching together five separate services.

Pump.fun bundler CLI turns Pump.fun launches into a scripted Solana workflow: upload metadata, create mint, pre-simulate, build an ALT, and bundle buys through Jito from one TypeScript menu.

It compresses 109 open-source trading projects into a ranked, signal-driven shortlist so engineers can find active repos faster than manual GitHub searching.

Turns a locked Ethereum keystore v3 JSON file into a multithreaded password search problem using wordlists, prefixes, suffixes, and brute-force masks.

Mirage collapses dozens of remote services into one bash-native filesystem so agents can copy, grep, snapshot, and compose work across backends without juggling SDKs.

TokenSpeed is a preview-stage LLM inference engine that pairs local-SPMD compilation, typed request scheduling, and pluggable CUDA kernels to chase TensorRT-LLM throughput with vLLM-style ergonomics for agentic GPU serving.

sshoosh turns plain SSH into a self-hosted, token-gated workspace chat with persistent state, so terminal-first teams can collaborate in real time without adding a web stack.

Atlas Inference Engine is a pure Rust, hardware-specialized LLM server that targets NVIDIA, AMD, and Intel with plug-in kernels so teams can run local inference without dragging in a Python dependency pile.

It is a relay chain, not a VPN, so the visible endpoint can stay on `www.google.com` while the real destination is carried inside app-layer relay requests.

Skills turns agent workflows into small, editable `SKILL.md` modules so developers can standardize alignment, debugging, and TDD without locking into a monolithic process engine.

fsnotify gives Go code a thin, cross-platform event layer over native filesystem backends, with canonicalized paths, thread-safe APIs, and recursive watching on supported systems.

A versioned, copy-pasteable Chinese prompt repository that turns scattered prompt ideas into reproducible workflows for content, marketing, learning, and product work.

A Rust-backed Qt/QML launcher that unifies Wine/Proton runners, store imports, wrapper chains, and per-game TOML config for Linux game libraries.

RKN Block Checker classifies censorship at the DNS, TCP, TLS, and HTTP layers so you can tell poisoning from DPI instead of guessing from a dead browser tab.

A lightweight Go daemon that uses device-link auth to collect host and network metrics and ship them to WatchUp with very low CPU and RAM overhead.

Free-BAI documents how a wallet-gated AI service can be abused, which makes it useful for auditing auth flows and abuse controls rather than for production deployment.

A typed Hyperliquid client that wraps trading and market-data endpoints with minimal dependencies, runtime portability, and wallet-friendly integration.

gho is a pure Go parser, writer, and CLI for Norton Ghost GHO images that handles Ghost 11.x–12.x formats without CGo or external binaries.

A tiny Rust exploit PoC that isolates the CVE-2026-31431 trigger path for Linux kernel researchers who need a minimal, auditable reproduction of the authencesn + AF_ALG + splice() page-cache write chain.

cuocuo gives you a self-hosted encrypted relay with XChaCha20-Poly1305, multi-transport forwarding, and config-compatible migration from v4.x without a license gate.

Unica turns Codex into a 1C:Enterprise-aware assistant with pinned tools, MCP hookups, and repeatable install flows for real configuration work.

ChainReason benchmarks whether an LLM can reason over Ethereum mechanics, Solidity vulnerabilities, transaction intent, and AMM math instead of just generating code.

Cheat on Content turns every post into an auditable prediction loop so you can replace gut feel with account-specific scoring, T+3 feedback, and evolving rubrics.

book-to-skill turns a PDF or EPUB technical book into a Claude Code skill with chapter files, a glossary, and on-demand loading so you can query the source text without dumping 200K tokens into context.

SPECA turns natural-language specs into typed security properties and proof-attempt audits so teams can catch specification-level violations instead of only known bug patterns.

HelloGML turns chatglm.cn's private web API into a Cloudflare Worker gateway that speaks OpenAI, Claude, and Gemini while rotating refresh tokens, preserving streaming, and keeping tool calls and multimodal requests compatible.

Kalshi AI Trading Bot gives you a TypeScript CLI and signed Kalshi REST client so you can automate prediction-market workflows without building authentication, retries, and account plumbing from scratch.

It monitors Polymarket and Kalshi on a timed loop, waits for a configurable start window, and turns cross-market price gaps into buy signals or trades with TypeScript-level transparency.

B3OS standardizes blockchain workflows around TypeScript action classes, JSON Schema validation, and runtime credential injection, so teams can ship auditable automation without building a separate orchestration layer.

kata gives devs and coding agents a local-first issue ledger with JSON-first CLI commands, durable events, and a TUI backed by one SQLite database and one daemon.

MHR-CFW-Go turns the original Python proxy into a lean Go binary with HTTP/2, CORS, caching, and Range-request fixes for a faster local relay.

Automates Polymarket's 15-minute Up/Down dump-capture and hedge cycle in TypeScript, using the official CLOB client, Gamma discovery, and Polygon settlement to run the entire trade lifecycle hands-free.

Writer keeps markdown, docs, and personal wikis on disk, so teams get a local-first editor with multi-window editing, Git-aware folder watching, and native Mermaid/table rendering without cloud lock-in.

Craft Agents OSS centralizes Claude-class agents into a session-based desktop and headless workspace with MCP, OpenAPI, skills, and WebSocket remote control, so teams can run repeatable workflows instead of disposable chats.

LegalMarkdown turns plain-text legal templates into deterministic output by applying YAML or JSON front matter, mixins, and optional clauses through a Go-based parser and CLI.

Sprite-Pipeline turns rough AI animation into validated 256×256 sprite strips with frame extraction, matting, browser review, and approval gating.

VanGuard collapses triage, hunting, memory capture, disk collection, Velociraptor management, and chain-of-custody logging into one portable Go binary that works offline on Windows and Linux.

Zyrln routes Google traffic directly with fragmented TLS and sends everything else through Google Apps Script plus an exit relay, giving Iranian users a censorship-bypass path that does not look like a standard VPN.

Auto News Video turns a Vietnamese article URL into a validated, voice-synced 9:16 MP4 in minutes using a deterministic Node/TypeScript render pipeline.

deepsec runs model-backed, idempotent vulnerability hunts across entire monorepos, fanning work out to workers or Vercel Sandbox microVMs so security teams can catch long-lived defects without hand-slicing the codebase.

Deterministic off-chain Solana route discovery with venue decoders, graph search, and negative-cycle arbitrage scanning in a single Rust crate.

It mirrors a Polymarket trader into your wallet with poll-based execution, configurable size caps, and trades-only safety rails.

Petdex turns Codex-compatible animated pet packs into a browser-validated gallery with per-state previews and ZIP downloads.

club-3090 turns one or two RTX 3090s into a benchmarked local LLM backend with validated vLLM and llama.cpp recipes, OpenAI-compatible endpoints, and measured throughput up to 127 TPS on Qwen3.6-27B.

graf turns a local markdown tree into an interactive terminal knowledge graph with fast wiki-link navigation, themeable overlays, and editor handoff.

A low-latency Rust bot that quotes, arbitrages, and parity-trades HIP-4 outcome markets across Hyperliquid, Polymarket, and Kalshi with one shared book cache and one risk gate.

A Rust-built terminal editor that gives prose writers Vim motions, soft wrap, Hunspell spellcheck, persistent registers, and inline Claude Code without dragging in LSP or debugger overhead.

Mirrai turns chat logs into a stateful digital persona with multi-provider LLM routing, emotion-state switching, and WeChat auto-reply support.

lazar turns Claude into a sandboxed, file-backed agent runtime where skills, memory, and logs live on disk and the shell is the only action surface.

PixLab Desktop is a local-first desktop pipeline for turning raw images into clean sprites, spritesheets, and GIFs without browser friction.

picokubelet turns an ESP32-S3 into a real Kubernetes node that speaks TLS to k3s, renews its Lease every 10 seconds, and keeps the control plane convinced the board is a worker.

TradingAgents turns market research into a multi-agent decision pipeline with analyst debate, risk gating, and portfolio approval so you can test LLM-driven trade ideas without collapsing every role into one prompt.

Nano World Model packages diffusion-forcing research into a reproducible training stack for video rollouts, evaluation, and planning without hiding the model or the checkpoints.

GPT Image Canvas gives you a local-first image generation canvas with provider-aware routing, SQLite persistence, and OpenAI-compatible output handling without forcing a hosted SaaS workflow.

AI Trading Agent turns an LLM into a constrained crypto execution loop with PostgreSQL audit logs, so you can test trading prompts against real market data without hand-wiring the orchestration layer.

Composio SDK standardizes authenticated SaaS tool access for AI agents, so you stop hand-writing brittle REST clients and OAuth glue for every integration.

RunbookHermes turns Hermes Agent into an approval-gated AIOps incident runner that collects observability evidence, drives root-cause analysis, and converts successful remediations into reusable runbook skills.

Puzzle demonstrates how to abuse Windows minifilters to drop and hide payloads in ways that complicate static and runtime analysis during red-team operations.