本週從 GitHub Trending 前 15 名中，篩選出 14 個 AI/LLM 相關專案：

1. CloakHQ/CloakBrowser

→ GitHub 連結

CloakBrowser 是一款專為規避機器人偵測而設計的隱形 Chromium 瀏覽器，它透過 C++ 源碼層級的指紋修改，而非簡單的 JavaScript 注入或配置調整，來實現高度的隱匿性。這款專案能夠在 30 項機器人偵測測試中全部通過，讓自動化瀏覽器在 ReCAPTCHA v3 中獲得高達 0.9 的人為分數，並順利繞過 Cloudflare Turnstile。對 AI/LLM 領域而言，CloakBrowser 解決了 AI 智能體或自動化框架（如 LangChain、Playwright）在執行網頁抓取、互動或自動化任務時，因被偵測為機器人而受阻的痛點。其「humanize=True」功能更能模擬人類的滑鼠移動、鍵盤輸入和滾動模式，讓 AI 代理的行為更加自然、難以辨別，為 AI 驅動的網頁自動化提供了更穩定、更具成本效益的基礎設施，大幅提升了任務的成功率和可靠性，是開發網頁智能體不可或缺的利器。

2. yikart/AiToEarn

→ GitHub 連結

AiToEarn 是一個旨在幫助個人公司（OPC）、創作者、品牌和企業，透過 AI Agent 自動化來在全球主流平台上建立、分發和變現內容的一站式平台。它解決了內容創作和多平台發佈的巨大時間成本，支援抖音、小紅書、TikTok、YouTube 等十多個平台。在 AI/LLM 領域，AiToEarn 的價值在於展示了 AI Agent 如何整合多模態 AI 模型（如 Grok、Veo、Nano Banana），實現從內容構思、影片/圖片生成、翻譯、剪輯、到跨平台發佈，乃至互動營運（如 AI 智能回覆評論）的端到端自動化。這不僅極大地提高了內容生產和推廣的效率，也為 AI 在內容營銷和商業變現上的應用開闢了新的可能性，是 AI Agent 賦能創作者經濟的典範。

3. rohitg00/agentmemory

→ GitHub 連結

Agentmemory 為 AI 編碼智能體提供了一套強大的持久化記憶系統，旨在解決現有 AI 助手「健忘」的問題，讓開發者不再需要重複解釋專案架構、程式錯誤或偏好設定。它基於 iii engine，結合了傳統的 BM25 搜尋、向量嵌入和知識圖譜，實現了高達 95.2% 的檢索準確度，並顯著節省了代幣成本。對於 AI/LLM 領域而言，Agentmemory 是構建更「聰明」、更自主的 AI 智能體的關鍵基礎設施。它透過自動捕捉智能體的每次工具使用，壓縮成可搜尋的記憶，並在需要時注入相關上下文，大幅提升了編碼智能體的效率和連續性，使其能夠在長期複雜的軟體開發任務中表現出更接近人類的「學習」和「記憶」能力，是提升 AI 編碼助手的核心組件。

4. anthropics/financial-services

→ GitHub 連結

Anthropic 的 financial-services 專案提供了一套專為金融服務工作流程設計的 Claude 參考智能體、技能和數據連接器，涵蓋了投資銀行、股票研究、私募股權和財富管理等多個領域。它旨在透過 AI 代理自動化複雜且專業的金融任務，例如投標書製作、市場研究、總帳對賬和財報審閱。在 AI/LLM 領域，這份專案展示了大型語言模型如何在高度專業化和監管嚴格的行業中落地應用。其設計強調了「人類審核」的重要性，表明 AI 在高風險決策中扮演輔助角色，提供分析和草稿，最終仍需專業人士確認。這不僅體現了 AI 在特定垂直領域的強大潛力，也為企業如何在不犧牲合規性與精確度的前提下，安全地整合 LLM 提供了寶貴的參考架構和最佳實踐。

5. bytedance/UI-TARS-desktop

→ GitHub 連結

UI-TARS-desktop 是字節跳動推出的一個多模態 AI Agent 堆棧，特別是其桌面應用，實現了透過自然語言控制本地電腦和瀏覽器的能力。它利用最先進的視覺-語言模型（VLM）和 GUI 代理技術，讓 AI 能夠「看」懂並操作圖形用戶介面，執行複雜的桌面和網頁任務。對於 AI/LLM 領域，這個專案的亮點在於突破了傳統 AI Agents 主要透過文字互動的限制，賦予了 AI 更貼近人類的視覺感知和操作能力。無論是自動預訂航班、生成圖表，還是檢查 GitHub 上的專案議題，UI-TARS 都展示了多模態 AI 如何直接介入實際操作環境，極大地擴展了 AI 自動化的應用邊界，是實現通用 AI 智能體（General AI Agents）願景的重要一步。

6. decolua/9router

→ GitHub 連結

9Router 是一款創新的 AI 路由與代幣節省工具，旨在解決 AI 編碼者在使用多個大型語言模型（LLM）時面臨的高成本、配額限制和中斷問題。它能將 Claude Code、Codex、Cursor 等多種 AI 編碼工具連接到 40 多個 LLM 供應商和 100 多個模型，並透過智能三層級回溯機制（訂閱 -> 便宜 -> 免費）確保編碼不間斷。特別的是，其「RTK 代幣節省器」能自動壓縮工具輸出，節省 20-40% 的輸入代幣。在 AI/LLM 領域，9Router 是一個極具實用價值的工具。它不僅降低了 AI 開發的經濟門檻，提高了開發效率，也展示了如何透過智能路由和優化策略，有效管理多樣化的 LLM 資源，實現高效且可持續的 AI 應用開發。對於追求效率與成本效益的開發者來說，這無疑是一個福音。

7. Imbad0202/academic-research-skills

→ GitHub 連結

Academic Research Skills 是一個為 Claude Code 設計的學術研究技能套件，覆蓋從研究、寫作、審閱到修改和定稿的整個學術論文發表流程。它旨在讓 AI 成為研究者的「副駕駛」，自動處理繁瑣的文獻追蹤、引用格式化、數據驗證和邏輯一致性檢查等「苦力活」。在 AI/LLM 領域，這個專案展示了如何將 AI 智能體應用於高度專業化和知識密集型的學術工作，並特別強調了「人機協作」的重要性。專案不僅提供論文規劃、寫作輔助和同行評審代理，更深入探討了 AI 在學術寫作中可能出現的「幻覺」、「框架鎖定」和「逢迎」等結構性限制，並提出了對應的解決方案和誠信驗證機制，為開發負責任且高品質的 AI 學術工具樹立了新的標竿。

8. oven-sh/bun

→ GitHub 連結

Incredibly fast JavaScript runtime, bundler, test runner, and package manager – all in one
Bun

Documentation
  •  
Discord
  •  
Issues
  •  
Roadmap

Read the docs →
What is Bun?
Bun is an all-in-one toolkit for JavaScript and TypeScript apps. It ships as a single executable called bun .
At its core is the Bun runtime , a fast JavaScript runtime designed as a drop-in replacement for Node.js . It’s written in Zig and powered by JavaScriptCore under the hood, dramatically reducing startup times and memory usage.
bun run index.tsx # TS and JSX supported out-of-the-box

The bun command-line tool also implements a test runner, script runner, and Node.js-compatible package manager. Instead of 1,000 node_modules for development, you only need bun . Bun’s built-in tools are significantly faster than existing options and usable in existing Node.js projects with little to no changes.
bun test # run tests bun run start # run the start script in package.json bun install # install a package bunx cowsay ‘Hello, world!’ # execute a package

Install
Bun supports Linux (x64 & arm64), macOS (x64 & Apple Silicon), and Windows (x64 & arm64).

Linux users — Kernel version 5.6 or higher is strongly recommended, but the minimum is 5.1.

x64 users — if you see “illegal instruction” or similar errors, check our CPU requirements

with install script (recommended)

curl -fsSL https://bun.com/install | bash

on windows

powershell -c “irm bun.sh/install.ps1 | iex”

with npm

npm install -g bun

with Homebrew

brew tap oven-sh/bun brew install bun

with Docker

docker pull oven/bun docker run –rm –init –ulimit memlock=-1:-1 oven/bun

Upgrade
To upgrade to the latest version of Bun, run:
bun upgrade

Bun automatically releases a canary build on every commit to main . To upgrade to the latest canary build, run:
bun upgrade –canary

View canary build
Quick links

Intro  

What is Bun?  
Installation  
Quickstart  
TypeScript  
TypeScript 6  
  
Templating  

bun init  
bun create  
  
Runtime  

bun run  
File types (Loaders)  
JSX  
Environment variables  
Bun APIs  
Web APIs  
Node.js compatibility  
Plugins  
Watch mode / Hot Reloading  
Module resolution  
Auto-install  
bunfig.toml  
Debugger  
REPL  
$ Shell  
  
Package manager  

bun install  
bun add  
bun remove  
bun update  
bun link  
bun pm  
bun outdated  
bun publish  
bun patch  
bun why  
bun audit  
bun info  
Global cache  
Global store  
Isolated installs  
Workspaces  
Catalogs  
Lifecycle scripts  
Filter  
Lockfile  
Scopes and registries  
Overrides and resolutions  
Security scanner API  
.npmrc  
  
Bundler  

Bun.build  
Loaders  
Plugins  
Macros  
vs esbuild  
Single-file executable  
CSS  
HTML & static sites  
Hot Module Replacement (HMR)  
Full-stack with HTML imports  
Standalone HTML  
Bytecode caching  
Minifier  
  
Test runner  

bun test  
Writing tests  
Lifecycle hooks  
Mocks  
Snapshots  
Dates and times  
DOM testing  
Code coverage  
Configuration  
Discovery  
Reporters  
Runtime Behavior  
  
Package runner  

bunx  
  
API  

HTTP server ( Bun.serve )  
HTTP routing  
HTTP error handling  
HTTP metrics  
WebSockets  
Workers  
Binary data  
Streams  
File I/O ( Bun.file )  
Archive (tar)  
SQLite ( bun:sqlite )  
PostgreSQL ( Bun.sql )  
Redis ( Bun.redis )  
S3 Client ( Bun.s3 )  
FileSystemRouter  
TCP sockets  
UDP sockets  
Globals  
Child processes (spawn)  
Cron ( Bun.cron )  
WebView  
Transpiler ( Bun.Transpiler )  
Hashing  
Colors ( Bun.color )  
Console  
FFI ( bun:ffi )  
C Compiler ( bun:ffi  cc)  
HTMLRewriter  
Cookies ( Bun.Cookie )  
CSRF ( Bun.CSRF )  
Secrets ( Bun.secrets )  
YAML ( Bun.YAML )  
TOML ( Bun.TOML )  
JSON5  
JSONL  
Markdown  
Image processing  
Utils  
Node-API  
Glob ( Bun.Glob )  
Semver ( Bun.semver )  
DNS  
fetch API extensions  

Guides

Deployment  

Deploy to Vercel  
Deploy to Railway  
Deploy to Render  
Deploy to AWS Lambda  
Deploy to DigitalOcean  
Deploy to Google Cloud Run  
  
Binary  

Convert a Blob to a string  
Convert a Buffer to a blob  
Convert a Blob to a DataView  
Convert a Buffer to a string  
Convert a Blob to a ReadableStream  
Convert a Blob to a Uint8Array  
Convert a DataView to a string  
Convert a Uint8Array to a Blob  
Convert a Blob to an ArrayBuffer  
Convert an ArrayBuffer to a Blob  
Convert a Buffer to a Uint8Array  
Convert a Uint8Array to a Buffer  
Convert a Uint8Array to a string  
Convert a Buffer to an ArrayBuffer  
Convert an ArrayBuffer to a Buffer  
Convert an ArrayBuffer to a string  
Convert a Uint8Array to a DataView  
Convert a Buffer to a ReadableStream  
Convert a Uint8Array to an ArrayBuffer  
Convert an ArrayBuffer to a Uint8Array  
Convert an ArrayBuffer to an array of numbers  
Convert a Uint8Array to a ReadableStream  
  
Ecosystem  

Use React and JSX  
Use Gel with Bun  
Use Prisma with Bun  
Use Prisma Postgres with Bun  
Add Sentry to a Bun app  
Create a Discord bot  
Run Bun as a daemon with PM2  
Use Drizzle ORM with Bun  
Use Upstash Redis with Bun  
Build an app with Nuxt and Bun  
Build an app with Qwik and Bun  
Build an app with Astro and Bun  
Build an app with Remix and Bun  
Build a frontend using Vite and Bun  
Build an app with Next.js and Bun  
Run Bun as a daemon with systemd  
Build an HTTP server using Hono and Bun  
Build an app with SvelteKit and Bun  
Build an app with SolidStart and Bun  
Build an app with TanStack Start and Bun  
Build an HTTP server using Elysia and Bun  
Build an HTTP server using StricJS and Bun  
Containerize a Bun application with Docker  
Build an HTTP server using Express and Bun  
Use Neon Postgres through Drizzle ORM  
Server-side render (SSR) a React component  
Read and write data to MongoDB using Mongoose and Bun  
Use Neon's Serverless Postgres with Bun  
  
HTMLRewriter  

Extract links from a webpage using HTMLRewriter  
Extract social share images and Open Graph tags  
  
HTTP  

Hot reload an HTTP server  
Common HTTP server usage  
Write a simple HTTP server  
Configure TLS on an HTTP server  
Send an HTTP request using fetch  
Proxy HTTP requests using fetch()  
Start a cluster of HTTP servers  
Stream a file as an HTTP Response  
fetch with unix domain sockets in Bun  
Upload files via HTTP using FormData  
Streaming HTTP Server with Async Iterators  
Streaming HTTP Server with Node.js Streams  
Server-Sent Events (SSE) with Bun  
  
Install  

Add a dependency  
Add a Git dependency  
Add a peer dependency  
Add a trusted dependency  
Add a development dependency  
Add a tarball dependency  
Add an optional dependency  
Generate a yarn-compatible lockfile  
Configuring a monorepo using workspaces  
Install a package under a different name  
Install dependencies with Bun in GitHub Actions  
Using bun install with Artifactory  
Configure git to diff Bun's lockb lockfile  
Override the default npm registry for bun install  
Using bun install with an Azure Artifacts npm registry  
Migrate from npm install to bun install  
Configure a private registry for an organization scope with bun install  
  
Process  

Read from stdin  
Listen for CTRL+C  
Spawn a child process  
Listen to OS signals  
Parse command-line arguments  
Read stderr from a child process  
Read stdout from a child process  
Get the process uptime in nanoseconds  
Spawn a child process and communicate using IPC  
  
Read file  

Read a JSON file  
Check if a file exists  
Read a file as a string  
Read a file to a Buffer  
Get the MIME type of a file  
Watch a directory for changes  
Read a file as a ReadableStream  
Read a file to a Uint8Array  
Read a file to an ArrayBuffer  
  
Runtime  

Delete files  
Run a Shell Command  
Import a JSON file  
Import a TOML file  
Import a YAML file  
Import a JSON5 file  
Set a time zone in Bun  
Set environment variables  
Re-map import paths  
Delete directories  
Read environment variables  
Import a HTML file as text  
Install and run Bun in GitHub Actions  
Debugging Bun with the web debugger  
Install TypeScript declarations for Bun  
Debugging Bun with the VS Code extension  
Inspect memory usage using V8 heap snapshots  
Define and replace static globals & constants  
Build-time constants with --define  
Codesign a single-file JavaScript executable on macOS  
  
Streams  

Convert a ReadableStream to JSON  
Convert a ReadableStream to a Blob  
Convert a ReadableStream to a Buffer  
Convert a ReadableStream to a string  
Convert a ReadableStream to a Uint8Array  
Convert a ReadableStream to an array of chunks  
Convert a Node.js Readable to JSON  
Convert a ReadableStream to an ArrayBuffer  
Convert a Node.js Readable to a Blob  
Convert a Node.js Readable to a string  
Convert a Node.js Readable to an Uint8Array  
Convert a Node.js Readable to an ArrayBuffer  
  
Test  

Spy on methods in  bun test  
Bail early with the Bun test runner  
Mock functions in  bun test  
Run tests in watch mode with Bun  
Use snapshot testing in  bun test  
Skip tests with the Bun test runner  
Using Testing Library with Bun  
Update snapshots in  bun test  
Run your tests with the Bun test runner  
Set the system time in Bun's test runner  
Set a per-test timeout with the Bun test runner  
Migrate from Jest to Bun's test runner  
Write browser DOM tests with Bun and happy-dom  
Mark a test as a "todo" with the Bun test runner  
Re-run tests multiple times with the Bun test runner  
Generate code coverage reports with the Bun test runner  
import, require, and test Svelte components with bun test  
Set a code coverage threshold with the Bun test runner  
Selectively run tests concurrently with glob patterns  
  
Util  

Generate a UUID  
Hash a password  
Escape an HTML string  
Get the current Bun version  
Upgrade Bun to the latest version  
Encode and decode base64 strings  
Compress and decompress data with gzip  
Sleep for a fixed number of milliseconds  
Detect when code is executed with Bun  
Check if two objects are deeply equal  
Compress and decompress data with DEFLATE  
Get the absolute path to the current entrypoint  
Get the directory of the current file  
Check if the current file is the entrypoint  
Get the file name of the current file  
Convert a file URL to an absolute path  
Convert an absolute path to a file URL  
Get the absolute path of the current file  
Get the path to an executable bin file  
  
WebSocket  

Build a publish-subscribe WebSocket server  
Build a simple WebSocket server  
Enable compression for WebSocket messages  
Set per-socket contextual data on a WebSocket  
  
Write file  

Delete a file  
Write to stdout  
Write a file to stdout  
Write a Blob to a file  
Write a string to a file  
Append content to a file  
Write a file incrementally  
Write a Response to a file  
Copy a file to another location  
Write a ReadableStream to a file  

Contributing
Refer to the Project > Contributing guide to start contributing to Bun.
License
Refer to the Project > License page for information about Bun’s licensing.

9. mattpocock/skills

→ GitHub 連結

Skills for Real Engineers. Straight from my .claude directory.

Skills For Real Engineers

My agent skills that I use every day to do real engineering - not vibe coding.
Developing real applications is hard. Approaches like GSD, BMAD, and Spec-Kit try to help by owning the process. But while doing so, they take away your control and make bugs in the process hard to resolve.
These skills are designed to be small, easy to adapt, and composable. They work with any model. They’re based on decades of engineering experience. Hack around with them. Make them your own. Enjoy.
If you want to keep up with changes to these skills, and any new ones I create, you can join ~60,000 other devs on my newsletter:
Sign Up To The Newsletter
Quickstart (30-second setup)

Run the skills.sh installer:

npx skills@latest add mattpocock/skills

Pick the skills you want, and which coding agents you want to install them on.  Make sure you select  /setup-matt-pocock-skills .    
Run  /setup-matt-pocock-skills  in your agent. It will:  

Ask you which issue tracker you want to use (GitHub, Linear, or local files)  
Ask you what labels you apply to ticks when you triage them ( /triage  uses labels)  
Ask you where you want to save any docs we create  
  
Bam - you're ready to go.    

Why These Skills Exist
I built these skills as a way to fix common failure modes I see with Claude Code, Codex, and other coding agents.
#1: The Agent Didn’t Do What I Want

“No-one knows exactly what they want”
David Thomas & Andrew Hunt, The Pragmatic Programmer

The Problem . The most common failure mode in software development is misalignment. You think the dev knows what you want. Then you see what they’ve built - and you realize it didn’t understand you at all.
This is just the same in the AI age. There is a communication gap between you and the agent. The fix for this is a grilling session - getting the agent to ask you detailed questions about what you’re building.
The Fix is to use:

/grill-me - for non-code uses
/grill-with-docs - same as /grill-me , but adds more goodies (see below)

These are my most popular skills. They help you align with the agent before you get started, and think deeply about the change you’re making. Use them every time you want to make a change.
#2: The Agent Is Way Too Verbose

With a ubiquitous language, conversations among developers and expressions of the code are all derived from the same domain model.
Eric Evans, Domain-Driven-Design

The Problem : At the start of a project, devs and the people they’re building the software for (the domain experts) are usually speaking different languages.
I felt the same tension with my agents. Agents are usually dropped into a project and asked to figure out the jargon as they go. So they use 20 words where 1 will do.
The Fix for this is a shared language. It’s a document that helps agents decode the jargon used in the project.

Example
Here’s an example CONTEXT.md , from my course-video-manager repo. Which one is easier to read?

BEFORE : “There’s a problem when a lesson inside a section of a course is made ‘real’ (i.e. given a spot in the file system)”
AFTER : “There’s a problem with the materialization cascade”

This concision pays off session after session.

This is built into /grill-with-docs . It’s a grilling session, but that helps you build a shared language with the AI, and document hard-to-explain decisions in ADR’s.
It’s hard to explain how powerful this is. It might be the single coolest technique in this repo. Try it, and see.

Tip A shared language has many other benefits than reducing verbosity:

Variables, functions and files are named consistently , using the shared language
As a result, the codebase is easier to navigate for the agent
The agent also spends fewer tokens on thinking , because it has access to a more concise language

#3: The Code Doesn’t Work

“Always take small, deliberate steps. The rate of feedback is your speed limit. Never take on a task that’s too big.”
David Thomas & Andrew Hunt, The Pragmatic Programmer

The Problem : Let’s say that you and the agent are aligned on what to build. What happens when the agent still produces crap?
It’s time to look at your feedback loops. Without feedback on how the code it produces actually runs, the agent will be flying blind.
The Fix : You need the usual tranche of feedback loops: static types, browser access, and automated tests.
For automated tests, a red-green-refactor loop is critical. This is where the agent writes a failing test first, then fixes the test. This helps give the agent a consistent level of feedback that results in far better code.
I’ve built a /tdd skill you can slot into any project. It encourages red-green-refactor and gives the agent plenty of guidance on what makes good and bad tests.
For debugging, I’ve also built a /diagnose skill that wraps best debugging practices into a simple loop.
#4: We Built A Ball Of Mud

“Invest in the design of the system every day .”
Kent Beck, Extreme Programming Explained

“The best modules are deep. They allow a lot of functionality to be accessed through a simple interface.”
John Ousterhout, A Philosophy Of Software Design

The Problem : Most apps built with agents are complex and hard to change. Because agents can radically speed up coding, they also accelerate software entropy. Codebases get more complex at an unprecedented rate.
The Fix for this is a radical new approach to AI-powered development: caring about the design of the code.
This is built in to every layer of these skills:

/to-prd quizzes you about which modules you’re touching before creating a PRD
/zoom-out tells the agent to explain code in the context of the whole system

And crucially, /improve-codebase-architecture helps you rescue a codebase that has become a ball of mud. I recommend running it on your codebase once every few days.
Summary
Software engineering fundamentals matter more than ever. These skills are my best effort at condensing these fundamentals into repeatable practices, to help you ship the best apps of your career. Enjoy.
Reference
Engineering
Skills I use daily for code work.

diagnose — Disciplined diagnosis loop for hard bugs and performance regressions: reproduce → minimise → hypothesise → instrument → fix → regression-test.
grill-with-docs — Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates CONTEXT.md and ADRs inline.
triage — Triage issues through a state machine of triage roles.
improve-codebase-architecture — Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/ .
setup-matt-pocock-skills — Scaffold the per-repo config (issue tracker, triage label vocabulary, domain doc layout) that the other engineering skills consume. Run once per repo before using to-issues , to-prd , triage , diagnose , tdd , improve-codebase-architecture , or zoom-out .
tdd — Test-driven development with a red-green-refactor loop. Builds features or fixes bugs one vertical slice at a time.
to-issues — Break any plan, spec, or PRD into independently-grabbable GitHub issues using vertical slices.
to-prd — Turn the current conversation context into a PRD and submit it as a GitHub issue. No interview — just synthesizes what you’ve already discussed.
zoom-out — Tell the agent to zoom out and give broader context or a higher-level perspective on an unfamiliar section of code.
prototype — Build a throwaway prototype to flesh out a design — either a runnable terminal app for state/business-logic questions, or several radically different UI variations toggleable from one route.

Productivity
General workflow tools, not code-specific.

caveman — Ultra-compressed communication mode. Cuts token usage ~75% by dropping filler while keeping full technical accuracy.
grill-me — Get relentlessly interviewed about a plan or design until every branch of the decision tree is resolved.
handoff — Compact the current conversation into a handoff document so another agent can continue the work.
write-a-skill — Create new skills with proper structure, progressive disclosure, and bundled resources.

Misc
Tools I keep around but rarely use.

git-guardrails-claude-code — Set up Claude Code hooks to block dangerous git commands (push, reset –hard, clean, etc.) before they execute.
migrate-to-shoehorn — Migrate test files from as type assertions to @total-typescript/shoehorn.
scaffold-exercises — Create exercise directory structures with sections, problems, solutions, and explainers.
setup-pre-commit — Set up Husky pre-commit hooks with lint-staged, Prettier, type checking, and tests.

10. Hmbown/DeepSeek-TUI

→ GitHub 連結

DeepSeek-TUI 是一款運行於終端機的 DeepSeek 模型編碼智能體，它以 TUI（文字使用者介面）形式提供互動式編碼體驗，並支援 DeepSeek V4 Pro/Flash 等模型。該專案的亮點在於其「思考模式串流」功能，能即時展示模型的工作流程，以及多種工具套件（文件操作、Shell 執行、Git、網路搜尋）和子智能體協同工作。對 AI/LLM 領域的開發者而言，DeepSeek-TUI 提供了一個透明且高效的 AI 編碼介面，讓使用者可以更精確地控制 AI 的行為，例如透過「Auto 模式」自動選擇模型和思考層級，或透過「工作區回溯」功能確保編輯安全。這不僅提升了 AI 輔助編碼的實用性，也為開發者深入理解和調校大型模型在真實世界中的應用提供了絕佳的平台。

11. HKUDS/AI-Trader

→ GitHub 連結

AI-Trader 是一個「智能體原生」的全自動交易平台，讓 AI 智能體能夠在金融市場中交流交易策略、學習並執行交易。它支援股票、加密貨幣、外匯、期權和期貨等主要市場，並提供即時市場數據、信號發布、集體智慧交易和一鍵跟單等功能。在 AI/LLM 領域，AI-Trader 的推出具有劃時代意義。它不僅是 AI Agent 在高風險、高回報金融領域的直接應用，更透過「集體智慧交易」模式，讓多個 AI 代理協同工作，共同探索最佳策略。這項專案展示了 AI 如何實現高度自主化營運，並將複雜的金融決策流程轉化為智能體可理解和執行的任務，為未來的智能金融和自動化投資提供了前瞻性的技術基礎，也為人類交易者提供了一個了解和利用 AI 交易能力的嶄新途徑。

12. ruvnet/RuView

→ GitHub 連結

π RuView turns commodity WiFi signals into real-time spatial intelligence, vital sign monitoring, and presence detection — all without a single pixel of video. π RuView

Beta Software — Under active development. APIs and firmware may change. Known limitations:

ESP32-C3 and original ESP32 are not supported (single-core, insufficient for CSI DSP)
Single ESP32 deployments have limited spatial resolution — use 2+ nodes or add a Cognitum Seed for best results
Camera-free pose accuracy is limited (PCK@20 ≈ 2.5% with proxy labels) — camera ground-truth training targets 35%+ PCK@20 ; the pipeline is implemented, but the data-collection and evaluation phases (ADR-079 P7–P9) are still pending, so no measured camera-supervised PCK@20 has been published yet

Contributions and bug reports welcome at Issues .

See through walls with WiFi
Turn ordinary WiFi into a spatial intelligence / sensing system. Detect people, measure breathing and heart rate, track movement, and monitor rooms — through walls, in the dark, with no cameras or wearables. Just physics.
π RuView is a WiFi sensing platform that turns radio signals into spatial intelligence.
Every WiFi router already fills your space with radio waves. When people move, breathe, or even sit still, they disturb those waves in measurable ways. RuView captures these disturbances using Channel State Information (CSI) from low-cost ESP32 sensors and turns them into actionable data: who’s there, what they’re doing, and whether they’re okay.
What it senses:

Presence and occupancy — detect people through walls, count them, track entries and exits
Vital signs — breathing rate and heart rate, contactless, while sleeping or sitting
Activity recognition — walking, sitting, gestures, falls — from temporal CSI patterns
Environment mapping — RF fingerprinting identifies rooms, detects moved furniture, spots new objects
Sleep quality — overnight monitoring with sleep stage classification and apnea screening

Built on RuVector and Cognitum Seed , RuView runs entirely on edge hardware — an ESP32 mesh (as low as $9 per node) paired with a Cognitum Seed for persistent memory, cryptographic attestation, and AI integration. No cloud, no cameras, no internet required.
The system learns each environment locally using spiking neural networks that adapt in under 30 seconds, with multi-frequency mesh scanning across 6 WiFi channels that uses your neighbors’ routers as free radar illuminators. Every measurement is cryptographically attested via an Ed25519 witness chain.
RuView also supports pose estimation (17 COCO keypoints via the WiFlow architecture), trained entirely without cameras using 10 sensor signals — a technique pioneered from the original DensePose From WiFi research at Carnegie Mellon University.
Built for low-power edge applications
Edge modules are small programs that run directly on the ESP32 sensor — no internet needed, no cloud fees, instant response.

 What  
 How  
 Speed  
 


 
 🦴  Pose estimation  
 CSI subcarrier amplitude/phase → 17 COCO keypoints  
 171K emb/s (M4 Pro)  
 
 
 🫁  Breathing detection  
 Bandpass 0.1-0.5 Hz → zero-crossing BPM  
 6-30 BPM  
 
 
 💓  Heart rate  
 Bandpass 0.8-2.0 Hz → zero-crossing BPM  
 40-120 BPM  
 
 
 👤  Presence sensing  
 Trained model + PIR fusion — 100% accuracy  
 0.012 ms latency  
 
 
 🧱  Through-wall  
 Fresnel zone geometry + multipath modeling  
 Up to 5m depth  
 
 
 🧠  Edge intelligence  
 8-dim feature vectors + RVF store on Cognitum Seed  
 $140 total BOM  
 
 
 🎯  Camera-free training  
 10 sensor signals, no labels needed  
 84s on M4 Pro  
 
 
 📷  Camera-supervised training  
 MediaPipe + ESP32 CSI →  35%+ PCK@20 target  (ADR-079; eval phases pending)  
 ~19 min on laptop (pipeline)  
 
 
 📡  Multi-frequency mesh  
 Channel hopping across 6 bands, neighbor APs as illuminators  
 3x sensing bandwidth  
 
 
 🌐  3D point cloud   (optional fusion)  
 Camera depth (MiDaS) + WiFi CSI + mmWave radar → unified spatial model  
 22 ms pipeline · 19K+ points/frame  

Option 1: Docker (simulated data, no hardware needed)

docker pull ruvnet/wifi-densepose:latest docker run -p 3000:3000 ruvnet/wifi-densepose:latest

Open http://localhost:3000

Option 2: Live sensing with ESP32-S3 hardware ($9)

Flash firmware, provision WiFi, and start sensing:

python -m esptool –chip esp32s3 –port COM9 –baud 460800
write_flash 0x0 bootloader.bin 0x8000 partition-table.bin
0xf000 ota_data_initial.bin 0x20000 esp32-csi-node.bin python firmware/esp32-csi-node/provision.py –port COM9
–ssid “YourWiFi” –password “secret” –target-ip 192.168.1.20

Option 3: Full system with Cognitum Seed ($140)

ESP32 streams CSI → bridge forwards to Seed for persistent storage + kNN + witness chain

node scripts/rf-scan.js –port 5006 # Live RF room scan node scripts/snn-csi-processor.js –port 5006 # SNN real-time learning node scripts/mincut-person-counter.js –port 5006 # Correct person counting

Note CSI-capable hardware recommended. Presence, vital signs, through-wall sensing, and all advanced capabilities require Channel State Information (CSI) from an ESP32-S3 ($9) or research NIC. The Docker image runs with simulated data for evaluation. Consumer WiFi laptops provide RSSI-only presence detection.

Hardware options for live CSI capture:

 Option  
 Hardware  
 Cost  
 Full CSI  
 Capabilities  
 


 
 ESP32 + Cognitum Seed  (recommended)  
 ESP32-S3 +  Cognitum Seed  
 ~$140  
 Yes  
 Pose, breathing, heartbeat, motion, presence + persistent vector store, kNN search, witness chain, MCP proxy  
 
 
 ESP32 Mesh  
 3-6x ESP32-S3 + WiFi router  
 ~$54  
 Yes  
 Pose, breathing, heartbeat, motion, presence  
 
 
 Research NIC  
 Intel 5300 / Atheros AR9580  
 ~$50-100  
 Yes  
 Full CSI with 3x3 MIMO  
 
 
 Any WiFi  
 Windows, macOS, or Linux laptop  
 $0  
 No  
 RSSI-only: coarse presence and motion  

No hardware? Verify the signal processing pipeline with the deterministic reference signal: python archive/v1/data/proof/verify.py

Real-time pose skeleton from WiFi CSI signals — no cameras, no wearables

▶ Live Observatory Demo  |  ▶ Dual-Modal Pose Fusion Demo  |  ▶ Live 3D Point Cloud

The server is optional for visualization and aggregation — the ESP32 runs independently for presence detection, vital signs, and fall alerts.
Live ESP32 pipeline : Connect an ESP32-S3 node → run the sensing server → open the pose fusion demo for real-time dual-modal pose estimation (webcam + WiFi CSI). See ADR-059 .

🔬 How It Works
WiFi routers flood every room with radio waves. When a person moves — or even breathes — those waves scatter differently. WiFi DensePose reads that scattering pattern and reconstructs what happened:
WiFi Router → radio waves pass through room → hit human body → scatter ↓ ESP32 mesh (4-6 nodes) captures CSI on channels 1/6/11 via TDM protocol ↓ Multi-Band Fusion: 3 channels × 56 subcarriers = 168 virtual subcarriers per link ↓ Multistatic Fusion: N×(N-1) links → attention-weighted cross-viewpoint embedding ↓ Coherence Gate: accept/reject measurements → stable for days without tuning ↓ Signal Processing: Hampel, SpotFi, Fresnel, BVP, spectrogram → clean features ↓ AI Backbone (RuVector): attention, graph algorithms, compression, field model ↓ Signal-Line Protocol (CRV): 6-stage gestalt → sensory → topology → coherence → search → model ↓ Neural Network: processed signals → 17 body keypoints + vital signs + room model ↓ Output: real-time pose, breathing, heart rate, room fingerprint, drift alerts

No training cameras required — the Self-Learning system (ADR-024) bootstraps from raw WiFi data alone. MERIDIAN (ADR-027) ensures the model works in any room, not just the one it trained in.

🏢 Use Cases & Applications
WiFi sensing works anywhere WiFi exists. No new hardware in most cases — just software on existing access points or a $8 ESP32 add-on. Because there are no cameras, deployments avoid privacy regulations (GDPR video, HIPAA imaging) by design.
Scaling: Each AP distinguishes ~3-5 people (56 subcarriers). Multi-AP multiplies linearly — a 4-AP retail mesh covers ~15-20 occupants. No hard software limit; the practical ceiling is signal physics.

Why WiFi sensing wins  
Traditional alternative  




🔒  
No video, no GDPR/HIPAA imaging rules  
Cameras require consent, signage, data retention policies  


🧱  
Works through walls, shelving, debris  
Cameras need line-of-sight per room  


🌙  
Works in total darkness  
Cameras need IR or visible light  


💰  
$0-$8 per zone  (existing WiFi or ESP32)  
Camera systems: $200-$2,000 per zone  


🔌  
WiFi already deployed everywhere  
PIR/radar sensors require new wiring per room  

🏥 Everyday — Healthcare, retail, office, hospitality (commodity WiFi)

 Use Case  
 What It Does  
 Hardware  
 Key Metric  
 Edge Module  
 


 
 Elderly care / assisted living  
 Fall detection, nighttime activity monitoring, breathing rate during sleep — no wearable compliance needed  
 1 ESP32-S3 per room ($8)  
 Fall alert <2s  
 Sleep Apnea ,  Gait Analysis  
 
 
 Hospital patient monitoring  
 Continuous breathing + heart rate for non-critical beds without wired sensors; nurse alert on anomaly  
 1-2 APs per ward  
 Breathing: 6-30 BPM  
 Respiratory Distress ,  Cardiac Arrhythmia  
 
 
 Emergency room triage  
 Automated occupancy count + wait-time estimation; detect patient distress (abnormal breathing) in waiting areas  
 Existing hospital WiFi  
 Occupancy accuracy >95%  
 Queue Length ,  Panic Motion  
 
 
 Retail occupancy & flow  
 Real-time foot traffic, dwell time by zone, queue length — no cameras, no opt-in, GDPR-friendly  
 Existing store WiFi + 1 ESP32  
 Dwell resolution ~1m  
 Customer Flow ,  Dwell Heatmap  
 
 
 Office space utilization  
 Which desks/rooms are actually occupied, meeting room no-shows, HVAC optimization based on real presence  
 Existing enterprise WiFi  
 Presence latency <1s  
 Meeting Room ,  HVAC Presence  
 
 
 Hotel & hospitality  
 Room occupancy without door sensors, minibar/bathroom usage patterns, energy savings on empty rooms  
 Existing hotel WiFi  
 15-30% HVAC savings  
 Energy Audit ,  Lighting Zones  
 
 
 Restaurants & food service  
 Table turnover tracking, kitchen staff presence, restroom occupancy displays — no cameras in dining areas  
 Existing WiFi  
 Queue wait ±30s  
 Table Turnover ,  Queue Length  
 
 
 Parking garages  
 Pedestrian presence in stairwells and elevators where cameras have blind spots; security alert if someone lingers  
 Existing WiFi  
 Through-concrete walls  
 Loitering ,  Elevator Count  

🏟️ Specialized — Events, fitness, education, civic (CSI-capable hardware)

 Use Case  
 What It Does  
 Hardware  
 Key Metric  
 Edge Module  
 


 
 Smart home automation  
 Room-level presence triggers (lights, HVAC, music) that work through walls — no dead zones, no motion-sensor timeouts  
 2-3 ESP32-S3 nodes ($24)  
 Through-wall range ~5m  
 HVAC Presence ,  Lighting Zones  
 
 
 Fitness & sports  
 Rep counting, posture correction, breathing cadence during exercise — no wearable, no camera in locker rooms  
 3+ ESP32-S3 mesh  
 Pose: 17 keypoints  
 Breathing Sync ,  Gait Analysis  
 
 
 Childcare & schools  
 Naptime breathing monitoring, playground headcount, restricted-area alerts — privacy-safe for minors  
 2-4 ESP32-S3 per zone  
 Breathing: ±1 BPM  
 Sleep Apnea ,  Perimeter Breach  
 
 
 Event venues & concerts  
 Crowd density mapping, crush-risk detection via breathing compression, emergency evacuation flow tracking  
 Multi-AP mesh (4-8 APs)  
 Density per m²  
 Customer Flow ,  Panic Motion  
 
 
 Stadiums & arenas  
 Section-level occupancy for dynamic pricing, concession staffing, emergency egress flow modeling  
 Enterprise AP grid  
 15-20 per AP mesh  
 Dwell Heatmap ,  Queue Length  
 
 
 Houses of worship  
 Attendance counting without facial recognition — privacy-sensitive congregations, multi-room campus tracking  
 Existing WiFi  
 Zone-level accuracy  
 Elevator Count ,  Energy Audit  
 
 
 Warehouse & logistics  
 Worker safety zones, forklift proximity alerts, occupancy in hazardous areas — works through shelving and pallets  
 Industrial AP mesh  
 Alert latency <500ms  
 Forklift Proximity ,  Confined Space  
 
 
 Civic infrastructure  
 Public restroom occupancy (no cameras possible), subway platform crowding, shelter headcount during emergencies  
 Municipal WiFi + ESP32  
 Real-time headcount  
 Customer Flow ,  Loitering  
 
 
 Museums & galleries  
 Visitor flow heatmaps, exhibit dwell time, crowd bottleneck alerts — no cameras near artwork (flash/theft risk)  
 Existing WiFi  
 Zone dwell ±5s  
 Dwell Heatmap ,  Shelf Engagement  

🤖 Robotics & Industrial — Autonomous systems, manufacturing, android spatial awareness WiFi sensing gives robots and autonomous systems a spatial awareness layer that works where LIDAR and cameras fail — through dust, smoke, fog, and around corners. The CSI signal field acts as a “sixth sense” for detecting humans in the environment without requiring line-of-sight.

 Use Case  
 What It Does  
 Hardware  
 Key Metric  
 Edge Module  
 


 
 Cobot safety zones  
 Detect human presence near collaborative robots — auto-slow or stop before contact, even behind obstructions  
 2-3 ESP32-S3 per cell  
 Presence latency <100ms  
 Forklift Proximity ,  Perimeter Breach  
 
 
 Warehouse AMR navigation  
 Autonomous mobile robots sense humans around blind corners, through shelving racks — no LIDAR occlusion  
 ESP32 mesh along aisles  
 Through-shelf detection  
 Forklift Proximity ,  Loitering  
 
 
 Android / humanoid spatial awareness  
 Ambient human pose sensing for social robots — detect gestures, approach direction, and personal space without cameras always on  
 Onboard ESP32-S3 module  
 17-keypoint pose  
 Gesture Language ,  Emotion Detection  
 
 
 Manufacturing line monitoring  
 Worker presence at each station, ergonomic posture alerts, headcount for shift compliance — works through equipment  
 Industrial AP per zone  
 Pose + breathing  
 Confined Space ,  Gait Analysis  
 
 
 Construction site safety  
 Exclusion zone enforcement around heavy machinery, fall detection from scaffolding, personnel headcount  
 Ruggedized ESP32 mesh  
 Alert <2s, through-dust  
 Panic Motion ,  Structural Vibration  
 
 
 Agricultural robotics  
 Detect farm workers near autonomous harvesters in dusty/foggy field conditions where cameras are unreliable  
 Weatherproof ESP32 nodes  
 Range ~10m open field  
 Forklift Proximity ,  Rain Detection  
 
 
 Drone landing zones  
 Verify landing area is clear of humans — WiFi sensing works in rain, dust, and low light where downward cameras fail  
 Ground ESP32 nodes  
 Presence: >95% accuracy  
 Perimeter Breach ,  Tailgating  
 
 
 Clean room monitoring  
 Personnel tracking without cameras (particle contamination risk from camera fans) — gown compliance via pose  
 Existing cleanroom WiFi  
 No particulate emission  
 Clean Room ,  Livestock Monitor  

🔥 Extreme — Through-wall, disaster, defense, underground These scenarios exploit WiFi’s ability to penetrate solid materials — concrete, rubble, earth — where no optical or infrared sensor can reach. The WiFi-Mat disaster module (ADR-001) is specifically designed for this tier.

 Use Case  
 What It Does  
 Hardware  
 Key Metric  
 Edge Module  
 


 
 Search & rescue (WiFi-Mat)  
 Detect survivors through rubble/debris via breathing signature, START triage color classification, 3D localization  
 Portable ESP32 mesh + laptop  
 Through 30cm concrete  
 Respiratory Distress ,  Seizure Detection  
 
 
 Firefighting  
 Locate occupants through smoke and walls before entry; breathing detection confirms life signs remotely  
 Portable mesh on truck  
 Works in zero visibility  
 Sleep Apnea ,  Panic Motion  
 
 
 Prison & secure facilities  
 Cell occupancy verification, distress detection (abnormal vitals), perimeter sensing — no camera blind spots  
 Dedicated AP infrastructure  
 24/7 vital signs  
 Cardiac Arrhythmia ,  Loitering  
 
 
 Military / tactical  
 Through-wall personnel detection, room clearing confirmation, hostage vital signs at standoff distance  
 Directional WiFi + custom FW  
 Range: 5m through wall  
 Perimeter Breach ,  Weapon Detection  
 
 
 Border & perimeter security  
 Detect human presence in tunnels, behind fences, in vehicles — passive sensing, no active illumination to reveal position  
 Concealed ESP32 mesh  
 Passive / covert  
 Perimeter Breach ,  Tailgating  
 
 
 Mining & underground  
 Worker presence in tunnels where GPS/cameras fail, breathing detection after collapse, headcount at safety points  
 Ruggedized ESP32 mesh  
 Through rock/earth  
 Confined Space ,  Respiratory Distress  
 
 
 Maritime & naval  
 Below-deck personnel tracking through steel bulkheads (limited range, requires tuning), man-overboard detection  
 Ship WiFi + ESP32  
 Through 1-2 bulkheads  
 Structural Vibration ,  Panic Motion  
 
 
 Wildlife research  
 Non-invasive animal activity monitoring in enclosures or dens — no light pollution, no visual disturbance  
 Weatherproof ESP32 nodes  
 Zero light emission  
 Livestock Monitor ,  Dream Stage  

🧩 Edge Intelligence ( ADR-041 ) — 60 WASM modules across 13 categories, all implemented (609 tests) Small programs that run directly on the ESP32 sensor — no internet needed, no cloud fees, instant response. Each module is a tiny WASM file (5-30 KB) that you upload to the device over-the-air. It reads WiFi signal data and makes decisions locally in under 10 ms. ADR-041 defines 60 modules across 13 categories — all 60 are implemented with 609 tests passing.

 Category  
 Examples  
 


 
 🏥  
 Medical & Health  
 Sleep apnea detection, cardiac arrhythmia, gait analysis, seizure detection  
 
 
 🔐  
 Security & Safety  
 Intrusion detection, perimeter breach, loitering, panic motion  
 
 
 🏢  
 Smart Building  
 Zone occupancy, HVAC control, elevator counting, meeting room tracking  
 
 
 🛒  
 Retail & Hospitality  
 Queue length, dwell heatmaps, customer flow, table turnover  
 
 
 🏭  
 Industrial  
 Forklift proximity, confined space monitoring, structural vibration  
 
 
 🔮  
 Exotic & Research  
 Sleep staging, emotion detection, sign language, breathing sync  
 
 
 📡  
 Signal Intelligence  
 Cleans and sharpens raw WiFi signals — focuses on important regions, filters noise, fills in missing data, and tracks which person is which  
 
 
 🧠  
 Adaptive Learning  
 The sensor learns new gestures and patterns on its own over time — no cloud needed, remembers what it learned even after updates  
 
 
 🗺️  
 Spatial Reasoning  
 Figures out where people are in a room, which zones matter most, and tracks movement across areas using graph-based spatial logic  
 
 
 ⏱️  
 Temporal Analysis  
 Learns daily routines, detects when patterns break (someone didn't get up), and verifies safety rules are being followed over time  
 
 
 🛡️  
 AI Security  
 Detects signal replay attacks, WiFi jamming, injection attempts, and flags abnormal behavior that could indicate tampering  
 
 
 ⚛️  
 Quantum-Inspired  
 Uses quantum-inspired math to map room-wide signal coherence and search for optimal sensor configurations  
 
 
 🤖  
 Autonomous & Exotic  
 Self-managing sensor mesh — auto-heals dropped nodes, plans its own actions, and explores experimental signal representations  

All implemented modules are no_std Rust, share a common utility library , and talk to the host through a 12-function API. Full documentation: Edge Modules Guide . See the complete implemented module list below.

🧩 Edge Intelligence — All 65 Modules Implemented (ADR-041 complete) All 60 modules are implemented, tested (609 tests passing), and ready to deploy. They compile to wasm32-unknown-unknown , run on ESP32-S3 via WASM3, and share a common utility library . Source: crates/wifi-densepose-wasm-edge/src/
Core modules (ADR-040 flagship + early implementations):

 Module  
 File  
 What It Does  
 


 
 Gesture Classifier  
 gesture.rs  
 DTW template matching for hand gestures  
 
 
 Coherence Filter  
 coherence.rs  
 Phase coherence gating for signal quality  
 
 
 Adversarial Detector  
 adversarial.rs  
 Detects physically impossible signal patterns  
 
 
 Intrusion Detector  
 intrusion.rs  
 Human vs non-human motion classification  
 
 
 Occupancy Counter  
 occupancy.rs  
 Zone-level person counting  
 
 
 Vital Trend  
 vital_trend.rs  
 Long-term breathing and heart rate trending  
 
 
 RVF Parser  
 rvf.rs  
 RVF container format parsing  

Vendor-integrated modules (24 modules, ADR-041 Category 7):
📡 Signal Intelligence — Real-time CSI analysis and feature extraction

 Module  
 File  
 What It Does  
 Budget  
 


 
 Flash Attention  
 sig_flash_attention.rs  
 Tiled attention over 8 subcarrier groups — finds spatial focus regions and entropy  
 S (<5ms)  
 
 
 Coherence Gate  
 sig_coherence_gate.rs  
 Z-score phasor gating with hysteresis: Accept / PredictOnly / Reject / Recalibrate  
 L (<2ms)  
 
 
 Temporal Compress  
 sig_temporal_compress.rs  
 3-tier adaptive quantization (8-bit hot / 5-bit warm / 3-bit cold)  
 L (<2ms)  
 
 
 Sparse Recovery  
 sig_sparse_recovery.rs  
 ISTA L1 reconstruction for dropped subcarriers  
 H (<10ms)  
 
 
 Person Match  
 sig_mincut_person_match.rs  
 Hungarian-lite bipartite assignment for multi-person tracking  
 S (<5ms)  
 
 
 Optimal Transport  
 sig_optimal_transport.rs  
 Sliced Wasserstein-1 distance with 4 projections  
 L (<2ms)  

🧠 Adaptive Learning — On-device learning without cloud connectivity

 Module  
 File  
 What It Does  
 Budget  
 


 
 DTW Gesture Learn  
 lrn_dtw_gesture_learn.rs  
 User-teachable gesture recognition — 3-rehearsal protocol, 16 templates  
 S (<5ms)  
 
 
 Anomaly Attractor  
 lrn_anomaly_attractor.rs  
 4D dynamical system attractor classification with Lyapunov exponents  
 H (<10ms)  
 
 
 Meta Adapt  
 lrn_meta_adapt.rs  
 Hill-climbing self-optimization with safety rollback  
 L (<2ms)  
 
 
 EWC Lifelong  
 lrn_ewc_lifelong.rs  
 Elastic Weight Consolidation — remembers past tasks while learning new ones  
 S (<5ms)  

🗺️ Spatial Reasoning — Location, proximity, and influence mapping

 Module  
 File  
 What It Does  
 Budget  
 


 
 PageRank Influence  
 spt_pagerank_influence.rs  
 4x4 cross-correlation graph with power iteration PageRank  
 L (<2ms)  
 
 
 Micro HNSW  
 spt_micro_hnsw.rs  
 64-vector navigable small-world graph for nearest-neighbor search  
 S (<5ms)  
 
 
 Spiking Tracker  
 spt_spiking_tracker.rs  
 32 LIF neurons + 4 output zone neurons with STDP learning  
 S (<5ms)  

⏱️ Temporal Analysis — Activity patterns, logic verification, autonomous planning

 Module  
 File  
 What It Does  
 Budget  
 


 
 Pattern Sequence  
 tmp_pattern_sequence.rs  
 Activity routine detection and deviation alerts  
 S (<5ms)  
 
 
 Temporal Logic Guard  
 tmp_temporal_logic_guard.rs  
 LTL formula verification on CSI event streams  
 S (<5ms)  
 
 
 GOAP Autonomy  
 tmp_goap_autonomy.rs  
 Goal-Oriented Action Planning for autonomous module management  
 S (<5ms)  

🛡️ AI Security — Tamper detection and behavioral anomaly profiling

 Module  
 File  
 What It Does  
 Budget  
 


 
 Prompt Shield  
 ais_prompt_shield.rs  
 FNV-1a replay detection, injection detection (10x amplitude), jamming (SNR)  
 L (<2ms)  
 
 
 Behavioral Profiler  
 ais_behavioral_profiler.rs  
 6D behavioral profile with Mahalanobis anomaly scoring  
 S (<5ms)  

⚛️ Quantum-Inspired — Quantum computing metaphors applied to CSI analysis

 Module  
 File  
 What It Does  
 Budget  
 


 
 Quantum Coherence  
 qnt_quantum_coherence.rs  
 Bloch sphere mapping, Von Neumann entropy, decoherence detection  
 S (<5ms)  
 
 
 Interference Search  
 qnt_interference_search.rs  
 16 room-state hypotheses with Grover-inspired oracle + diffusion  
 S (<5ms)  

🤖 Autonomous Systems — Self-governing and self-healing behaviors

 Module  
 File  
 What It Does  
 Budget  
 


 
 Psycho-Symbolic  
 aut_psycho_symbolic.rs  
 16-rule forward-chaining knowledge base with contradiction detection  
 S (<5ms)  
 
 
 Self-Healing Mesh  
 aut_self_healing_mesh.rs  
 8-node mesh with health tracking, degradation/recovery, coverage healing  
 S (<5ms)  

🔮 Exotic (Vendor) — Novel mathematical models for CSI interpretation

 Module  
 File  
 What It Does  
 Budget  
 


 
 Time Crystal  
 exo_time_crystal.rs  
 Autocorrelation subharmonic detection in 256-frame history  
 S (<5ms)  
 
 
 Hyperbolic Space  
 exo_hyperbolic_space.rs  
 Poincare ball embedding with 32 reference locations, hyperbolic distance  
 S (<5ms)  

🏥 Medical & Health (Category 1) — Contactless health monitoring

 Module  
 File  
 What It Does  
 Budget  
 


 
 Sleep Apnea  
 med_sleep_apnea.rs  
 Detects breathing pauses during sleep  
 S (<5ms)  
 
 
 Cardiac Arrhythmia  
 med_cardiac_arrhythmia.rs  
 Monitors heart rate for irregular rhythms  
 S (<5ms)  
 
 
 Respiratory Distress  
 med_respiratory_distress.rs  
 Alerts on abnormal breathing patterns  
 S (<5ms)  
 
 
 Gait Analysis  
 med_gait_analysis.rs  
 Tracks walking patterns and detects changes  
 S (<5ms)  
 
 
 Seizure Detection  
 med_seizure_detect.rs  
 6-state machine for tonic-clonic seizure recognition  
 S (<5ms)  

🔐 Security & Safety (Category 2) — Perimeter and threat detection

 Module  
 File  
 What It Does  
 Budget  
 


 
 Perimeter Breach  
 sec_perimeter_breach.rs  
 Detects boundary crossings with approach/departure  
 S (<5ms)  
 
 
 Weapon Detection  
 sec_weapon_detect.rs  
 Metal anomaly detection via CSI amplitude shifts  
 S (<5ms)  
 
 
 Tailgating  
 sec_tailgating.rs  
 Detects unauthorized follow-through at access points  
 S (<5ms)  
 
 
 Loitering  
 sec_loitering.rs  
 Alerts when someone lingers too long in a zone  
 S (<5ms)  
 
 
 Panic Motion  
 sec_panic_motion.rs  
 Detects fleeing, struggling, or panic movement  
 S (<5ms)  

🏢 Smart Building (Category 3) — Automation and energy efficiency

 Module  
 File  
 What It Does  
 Budget  
 


 
 HVAC Presence  
 bld_hvac_presence.rs  
 Occupancy-driven HVAC control with departure countdown  
 S (<5ms)  
 
 
 Lighting Zones  
 bld_lighting_zones.rs  
 Auto-dim/off lighting based on zone activity  
 S (<5ms)  
 
 
 Elevator Count  
 bld_elevator_count.rs  
 Counts people entering/leaving with overload warning  
 S (<5ms)  
 
 
 Meeting Room  
 bld_meeting_room.rs  
 Tracks meeting lifecycle: start, headcount, end, availability  
 S (<5ms)  
 
 
 Energy Audit  
 bld_energy_audit.rs  
 Tracks after-hours usage and room utilization rates  
 S (<5ms)  

🛒 Retail & Hospitality (Category 4) — Customer insights without cameras

 Module  
 File  
 What It Does  
 Budget  
 


 
 Queue Length  
 ret_queue_length.rs  
 Estimates queue size and wait times  
 S (<5ms)  
 
 
 Dwell Heatmap  
 ret_dwell_heatmap.rs  
 Shows where people spend time (hot/cold zones)  
 S (<5ms)  
 
 
 Customer Flow  
 ret_customer_flow.rs  
 Counts ins/outs and tracks net occupancy  
 S (<5ms)  
 
 
 Table Turnover  
 ret_table_turnover.rs  
 Restaurant table lifecycle: seated, dining, vacated  
 S (<5ms)  
 
 
 Shelf Engagement  
 ret_shelf_engagement.rs  
 Detects browsing, considering, and reaching for products  
 S (<5ms)  

🏭 Industrial & Specialized (Category 5) — Safety and compliance

 Module  
 File  
 What It Does  
 Budget  
 


 
 Forklift Proximity  
 ind_forklift_proximity.rs  
 Warns when people get too close to vehicles  
 S (<5ms)  
 
 
 Confined Space  
 ind_confined_space.rs  
 OSHA-compliant worker monitoring with extraction alerts  
 S (<5ms)  
 
 
 Clean Room  
 ind_clean_room.rs  
 Occupancy limits and turbulent motion detection  
 S (<5ms)  
 
 
 Livestock Monitor  
 ind_livestock_monitor.rs  
 Animal presence, stillness, and escape alerts  
 S (<5ms)  
 
 
 Structural Vibration  
 ind_structural_vibration.rs  
 Seismic events, mechanical resonance, structural drift  
 S (<5ms)  

🔮 Exotic & Research (Category 6) — Experimental sensing applications

 Module  
 File  
 What It Does  
 Budget  
 


 
 Dream Stage  
 exo_dream_stage.rs  
 Contactless sleep stage classification (wake/light/deep/REM)  
 S (<5ms)  
 
 
 Emotion Detection  
 exo_emotion_detect.rs  
 Arousal, stress, and calm detection from micro-movements  
 S (<5ms)  
 
 
 Gesture Language  
 exo_gesture_language.rs  
 Sign language letter recognition via WiFi  
 S (<5ms)  
 
 
 Music Conductor  
 exo_music_conductor.rs  
 Tempo and dynamic tracking from conducting gestures  
 S (<5ms)  
 
 
 Plant Growth  
 exo_plant_growth.rs  
 Monitors plant growth, circadian rhythms, wilt detection  
 S (<5ms)  
 
 
 Ghost Hunter  
 exo_ghost_hunter.rs  
 Environmental anomaly classification (draft/insect/wind/unknown)  
 S (<5ms)  
 
 
 Rain Detection  
 exo_rain_detect.rs  
 Detects rain onset, intensity, and cessation via signal scatter  
 S (<5ms)  
 
 
 Breathing Sync  
 exo_breathing_sync.rs  
 Detects synchronized breathing between multiple people  
 S (<5ms)  

🧠 Self-Learning WiFi AI (ADR-024) — Adaptive recognition, self-optimization, and intelligent anomaly detection Every WiFi signal that passes through a room creates a unique fingerprint of that space. WiFi-DensePose already reads these fingerprints to track people, but until now it threw away the internal “understanding” after each reading. The Self-Learning WiFi AI captures and preserves that understanding as compact, reusable vectors — and continuously optimizes itself for each new environment.
What it does in plain terms:

Turns any WiFi signal into a 128-number “fingerprint” that uniquely describes what’s happening in a room
Learns entirely on its own from raw WiFi data — no cameras, no labeling, no human supervision needed
Recognizes rooms, detects intruders, identifies people, and classifies activities using only WiFi
Runs on an $8 ESP32 chip (the entire model fits in 55 KB of memory)
Produces both body pose tracking AND environment fingerprints in a single computation

Key Capabilities

 What  
 How it works  
 Why it matters  
 


 
 Self-supervised learning  
 The model watches WiFi signals and teaches itself what "similar" and "different" look like, without any human-labeled data  
 Deploy anywhere — just plug in a WiFi sensor and wait 10 minutes  
 
 
 Room identification  
 Each room produces a distinct WiFi fingerprint pattern  
 Know which room someone is in without GPS or beacons  
 
 
 Anomaly detection  
 An unexpected person or event creates a fingerprint that doesn't match anything seen before  
 Automatic intrusion and fall detection as a free byproduct  
 
 
 Person re-identification  
 Each person disturbs WiFi in a slightly different way, creating a personal signature  
 Track individuals across sessions without cameras  
 
 
 Environment adaptation  
 MicroLoRA adapters (1,792 parameters per room) fine-tune the model for each new space  
 Adapts to a new room with minimal data — 93% less than retraining from scratch  
 
 
 Memory preservation  
 EWC++ regularization remembers what was learned during pretraining  
 Switching to a new task doesn't erase prior knowledge  
 
 
 Hard-negative mining  
 Training focuses on the most confusing examples to learn faster  
 Better accuracy with the same amount of training data  

Architecture
WiFi Signal [56 channels] → Transformer + Graph Neural Network ├→ 128-dim environment fingerprint (for search + identification) └→ 17-joint body pose (for human tracking)

Quick Start

Step 1: Learn from raw WiFi data (no labels needed)

cargo run -p wifi-densepose-sensing-server – –pretrain –dataset data/csi/ –pretrain-epochs 50

Step 2: Fine-tune with pose labels for full capability

cargo run -p wifi-densepose-sensing-server – –train –dataset data/mmfi/ –epochs 100 –save-rvf model.rvf

Step 3: Use the model — extract fingerprints from live WiFi

cargo run -p wifi-densepose-sensing-server – –model model.rvf –embed

Step 4: Search — find similar environments or detect anomalies

cargo run -p wifi-densepose-sensing-server – –model model.rvf –build-index env

Training Modes

 Mode  
 What you need  
 What you get  
 


 
 Self-Supervised  
 Just raw WiFi data  
 A model that understands WiFi signal structure  
 
 
 Supervised  
 WiFi data + body pose labels  
 Full pose tracking + environment fingerprints  
 
 
 Cross-Modal  
 WiFi data + camera footage  
 Fingerprints aligned with visual understanding  

Fingerprint Index Types

 Index  
 What it stores  
 Real-world use  
 


 
 env_fingerprint  
 Average room fingerprint  
 "Is this the kitchen or the bedroom?"  
 
 
 activity_pattern  
 Activity boundaries  
 "Is someone cooking, sleeping, or exercising?"  
 
 
 temporal_baseline  
 Normal conditions  
 "Something unusual just happened in this room"  
 
 
 person_track  
 Individual movement signatures  
 "Person A just entered the living room"  

Model Size

 Component  
 Parameters  
 Memory (on ESP32)  
 


 
 Transformer backbone  
 ~28,000  
 28 KB  
 
 
 Embedding projection head  
 ~25,000  
 25 KB  
 
 
 Per-room MicroLoRA adapter  
 ~1,800  
 2 KB  
 
 
 Total  
 ~55,000  
 55 KB  (of 520 KB available)  

The self-learning system builds on the AI Backbone (RuVector) signal-processing layer — attention, graph algorithms, and compression — adding contrastive learning on top.
See docs/adr/ADR-024-contrastive-csi-embedding-model.md for full architectural details.

🧩 Claude Code & Codex Plugin
RuView ships a Claude Code plugin (and Codex prompt mirror) that wraps the whole workflow — onboarding, ESP32 setup, configuration, sensing apps, model training, advanced multistatic sensing, CLI/API/WASM, mmWave radar, and witness verification — as 9 skills, 7 /ruview-* commands, and 3 agents. It lives in plugins/ruview/ ; the marketplace manifest is .claude-plugin/marketplace.json at the repo root.

In Claude Code — add this repo as a plugin marketplace, then install:

/plugin marketplace add ruvnet/RuView /plugin install ruview@ruview

Or try it for one session without installing (from a local clone of the repo):

claude –plugin-dir ./plugins/ruview

Then, in Claude Code:

/ruview-start → onboarding (Docker demo / repo build / live ESP32)

/ruview-flash → build + flash ESP32 firmware

/ruview-provision → provision WiFi creds, sink IP, channel/MAC, mesh slots

/ruview-app → run a sensing application (presence / vitals / pose / sleep / MAT / point cloud)

/ruview-train → train / evaluate / publish a model (incl. GPU on GCloud)

/ruview-advanced → multistatic / tomography / cross-viewpoint / mesh-security

/ruview-verify → tests + deterministic proof + witness bundle

Codex (OpenAI CLI): cp plugins/ruview/codex/prompts/.md ~/.codex/prompts/ — the seven /ruview- commands are mirrored as Codex prompts; plugins/ruview/codex/AGENTS.md carries the project rules. See plugins/ruview/codex/README.md .
Verify the plugin structure: bash plugins/ruview/scripts/smoke.sh . Full details: plugins/ruview/README.md .

📖 Documentation

Document  
Description  




User Guide  
Step-by-step guide: installation, first run, API usage, hardware setup, training  


Build Guide  
Building from source (Rust and Python)  


Claude Code / Codex Plugin  
The  ruview  plugin + marketplace — skills,  /ruview-*  commands, agents, and the Codex prompt mirror  


Architecture Decisions  
96 ADRs — why each technical choice was made, organized by domain (hardware, signal processing, ML, platform, infrastructure)  


Domain Models  
8 DDD models (RuvSense, Signal Processing, Training Pipeline, Hardware Platform, Sensing Server, WiFi-Mat, CHCI, rvCSI) — bounded contexts, aggregates, domain events, and ubiquitous language  


rvCSI — edge RF sensing runtime  
Rust-first / TypeScript-accessible / hardware-abstracted CSI runtime: multi-source ingestion (incl. real nexmon_csi  .pcap  from a  Raspberry Pi 5  / Pi 4 / Pi 3B+ — CYW43455 / BCM43455c0) → validation → DSP → typed events → RuVector RF memory ( ADR-095 ,  ADR-096 ,  domain model ). Now its own repo —  ruvnet/rvcsi  — vendored here under  vendor/rvcsi ; 9  rvcsi-*  crates on  crates.io ,  @ruv/rvcsi  on npm, plus a Claude Code plugin.  


Desktop App  
WIP  — Tauri v2 desktop app for node management, OTA updates, WASM deployment, and mesh visualization  


Medical Examples  
Contactless blood pressure, heart rate, breathing rate via 60 GHz mmWave radar — $15 hardware, no wearable  


Extended Documentation  
Latest additions, key features, installation, quick start, signal processing, training, CLI, testing, deployment, and changelog  

📄 License
MIT License — see LICENSE for details.
📞 Support
GitHub Issues | Discussions | PyPI

WiFi DensePose — Privacy-preserving human pose estimation through WiFi signals.

13. millionco/react-doctor

→ GitHub 連結

Your agent writes bad React. This catches it

Your agent writes bad React, this catches it.
One command scans your codebase and outputs a 0 to 100 health score with actionable diagnostics.
Works with Next.js, Vite, and React Native.
See it in action →
Install
Run this at your project root:
npx -y react-doctor@latest .

You’ll get a score (75+ Great, 50 to 74 Needs work, under 50 Critical) and a list of issues across state & effects, performance, architecture, security, accessibility, and dead code. Rules toggle automatically based on your framework and React version.
https://github.com/user-attachments/assets/07cc88d9-9589-44c3-aa73-5d603cb1c570
Install for your coding agent
Teach your coding agent React best practices so it stops writing the bad code in the first place.
npx -y react-doctor@latest install

You’ll be prompted to pick which detected agents to install for. Pass –yes to skip prompts.
Works with Claude Code, Cursor, Codex, OpenCode, and 50+ other agents.
GitHub Actions
A composite action ships with this repository. Drop it into .github/workflows/react-doctor.yml :
name: React Doctor

on: pull_request: push: branches: [main]

permissions: contents: read pull-requests: write # required to post PR comments

jobs: react-doctor: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 with: fetch-depth: 0 # required for diff - uses: millionco/react-doctor@main with: diff: main github-token: ${{ secrets.GITHUB_TOKEN }}

When github-token is set on pull_request events, findings are posted (and updated) as a PR comment. The action also exposes a score output (0–100) you can use in subsequent steps.
Inputs: directory , verbose , project , diff , github-token , fail-on ( error / warning / none ), offline , node-version . See action.yml for full descriptions.
Prefer not to add a marketplace action? The bare npx form works too:

• run: npx -y react-doctor@latest –fail-on warning

Configuration
Create a react-doctor.config.json in your project root:
{ “ignore”: { “rules”: [“react/no-danger”, “jsx-a11y/no-autofocus”], “files”: [“src/generated/”], “overrides”: [ { “files”: [“components/modules/diff/”], “rules”: [“react-doctor/no-array-index-as-key”, “react-doctor/no-render-in-render”] }, { “files”: [“components/search/HighlightedSnippet.tsx”], “rules”: [“react/no-danger”] } ] } }

Three nested keys, three layers of granularity — pick the narrowest one that fits:

ignore.rules silences a rule across the whole codebase.
ignore.files silences every rule on the matched files (use sparingly — it loses coverage for unrelated rules).
ignore.overrides silences only the listed rules on the matched files, leaving every other rule active. This is what you want when a single file (or glob) legitimately needs an exemption from one or two rules but should still be scanned for everything else.

You can also use the “reactDoctor” key in package.json . CLI flags always override config values.
React Doctor respects .gitignore , .eslintignore , .oxlintignore , .prettierignore , and linguist-vendored / linguist-generated annotations in .gitattributes . Inline // eslint-disable* and // oxlint-disable* comments are honored too.
If you have a JSON oxlint or eslint config ( .oxlintrc.json or .eslintrc.json ), its rules get merged into the scan automatically and count toward the score. Set adoptExistingLintConfig: false to opt out.
Surface controls (CLI, PR comments, score, CI failure)
Diagnostics flow through four independent surfaces — cli , prComment , score , and ciFailure — and each one can be tuned per tag, category, or rule id. By default the design tag (Tailwind shorthand cleanup like w-5 h-5 → size-5 , pure-black backgrounds, gradient text, …) stays visible on the local CLI but is excluded from the PR comment, the score, and the –fail-on gate so style cleanup can’t dilute meaningful React findings:
{ “surfaces”: { “prComment”: { “includeTags”: [“design”], “excludeCategories”: [“Performance”] }, “score”: { “includeRules”: [“react-doctor/design-no-redundant-size-axes”] }, “ciFailure”: { “excludeTags”: [“test-noise”] } } }

Each surface accepts includeTags , excludeTags , includeCategories , excludeCategories , includeRules , and excludeRules . Include wins over exclude when both match. Run the CLI with –pr-comment (the GitHub Action passes it automatically when github-token is set) to apply the prComment surface to the printed output destined for sticky PR comments.
Optional companion plugins
When the following ESLint plugins are installed in the scanned project (or hoisted in your monorepo), React Doctor folds their rules into the same scan. Both are listed as optional peer dependencies — install only what you want.

Plugin  
Adds  
Namespace  




eslint-plugin-react-hooks  (v6 or v7)  
The React Compiler frontend's correctness rules — fired when a React Compiler is detected in the project.  
react-hooks-js/*  


eslint-plugin-react-you-might-not-need-an-effect  (v0.10+)  
Complementary effects-as-anti-pattern rules ( no-derived-state ,  no-chain-state-updates ,  no-event-handler ,  no-pass-data-to-parent , …) that run alongside React Doctor's native State & Effects rules.  
effect/*  

Inline suppressions
// react-doctor-disable-next-line react-doctor/no-cascading-set-state useEffect(() => { setA(value); setB(value); }, [value]);

When two rules fire on the same line, you have two equivalent options. Comma-separate the rule ids on a single comment:
// react-doctor-disable-next-line react-doctor/rerender-state-only-in-handlers, react-doctor/no-derived-useState const [localSearch, setLocalSearch] = useState(searchQuery);

Or stack one comment per rule directly above the diagnostic. Stacked comments are honored as long as nothing but other react-doctor-disable-next-line comments sits between them and the target line:
// react-doctor-disable-next-line react-doctor/rerender-state-only-in-handlers // react-doctor-disable-next-line react-doctor/no-derived-useState const [localSearch, setLocalSearch] = useState(searchQuery);

A code line between stacked comments breaks the chain: only the comment immediately above the diagnostic (and any contiguous react-doctor-disable-next-line comments stacked on top of it) is honored. If a comment looks adjacent but the rule still fires, run react-doctor –explain file:line — it reports whether a nearby suppression was found, what rules it covers, and why it didn’t apply.
Block comments work inside JSX:

{/* react-doctor-disable-next-line react/no-danger */}

Key  
Type  
Default  




ignore.rules  
string[]  
[]  


ignore.files  
string[]  
[]  


ignore.overrides  
{ files, rules? }[]  
[]  


lint  
boolean  
true  


verbose  
boolean  
false  


diff  
boolean | string  
 


failOn  
"error" | "warning" | "none"  
"none"  


customRulesOnly  
boolean  
false  


share  
boolean  
true  


offline  
boolean  
false  


textComponents  
string[]  
[]  


rawTextWrapperComponents  
string[]  
[]  


serverAuthFunctionNames  
string[]  
[]  


respectInlineDisables  
boolean  
true  


adoptExistingLintConfig  
boolean  
true  


ignore.tags  
string[]  
[]  

#  
Repo  
Score  




1  
executor  
94  


2  
nodejs.org  
86  


3  
tldraw  
70  


4  
t3code  
68  


5  
better-auth  
64  


6  
excalidraw  
63  


7  
mastra  
63  


8  
payload  
60  


9  
typebot  
57  


10  
plane  
56  

Clone the repository:   git clone https://github.com/playcanvas/supersplat.git

Install dependencies:   npm install

Build SuperSplat and start a local web server:   npm run develop

Open a web browser tab and make sure network caching is disabled on the network tab and the other application caches are clear:  

On Safari you can use  Cmd+Option+e  or Develop->Empty Caches.  
On Chrome ensure the options "Update on reload" and "Bypass for network" are enabled in the Application->Service workers tab:  
    
Navigate to  http://localhost:3000    

Add a new  <locale>.json  file in the  static/locales  directory.    
Add the locale to the list here:   https://github.com/playcanvas/supersplat/blob/main/src/ui/localization.ts    

Run the development server:   npm run develop

Open your browser and navigate to:   http://localhost:3000/?lng=<locale>