AIGC Detector Toolkit

Free local AI-written ratio detection - dorm PCs can run it, your paper never leaves your computer, and the results stay in your hands.

⛔ Commercial use prohibited The source code is public, but all commercial use is prohibited — free for personal study, research and noncommercial organizations, under the PolyForm Noncommercial License 1.0.0. For commercial use, contact the author for written permission first. See License.

中文 | English

📖 Start Here

• 👉 REPO_FILES.md — what every file in this repo is for, which ones must not be deleted, and how to run from source（中文）
• 📝 Changelog CHANGELOG.md — what changed in each version, with a "visible to users" note per release (中文: 更新日志.md)
• ❓ Something not covered? See Bug Reports at the end, just send an email

If you just want to install and use it, you need exactly one file — the one for your OS. Ignore everything else.

📦 Download & Install

Builds for all three platforms live under Assets on the Releases page. Pick the one matching your OS:

On first launch a setup window downloads the runtime components (~0.2 GB, fast CN mirrors, no VPN needed): if you have an NVIDIA GPU it asks whether you want the CUDA or the CPU build; otherwise the CPU build is used. After that it runs fully offline.

Windows: just double-click the desktop icon afterwards. Linux / macOS: components go into your user directory (Linux ~/.local/share/AIGC_Toolkit, macOS ~/Library/Application Support/AIGC_Toolkit) — nothing is written to system directories. To uninstall, delete the app plus that directory.

xattr -dr com.apple.quarantine /Applications/AIGC_Toolkit.app

💡 You can also run straight from source (python app/main.py) — see REPO_FILES.md (中文).

✨ Features

Introduction

A fully local AIGC detection desktop tool: drag in a paper (PDF / DOCX / TXT), choose a detection engine, and get the overall AI-written ratio plus a paragraph-level report.

• Fully offline inference: the detection model is downloaded once; your paper is never uploaded to any platform
• Custom model storage path: keep models on any drive (e.g. D:) so they don't eat C: space; reinstalling the app never deletes downloaded models
• 8 detection engines: SimpleAI Chinese (default), AIGC Chinese v3, GLTR perplexity, Chinese perplexity (GPT2-Chinese), Fast-DetectGPT, DetectGPT, Binoculars, PAN ModernBERT (English) — plus any custom HuggingFace model
• Models downloaded on demand: nothing is bundled; grab what you need and stay offline afterwards
• Benchmarks: RAID / MGTBench built in, so you can audit your own detection results (accuracy, false-positive rate, per-generator breakdown)
• Highly customizable: threshold, paragraph splitting, worker count and more; presets can be saved, exported and imported
• Multi-device compute pooling: automatic multi-GPU parallelism on one machine; add roommates' PCs, Pads and phones over LAN
• Detect → Diagnose → Treat: after detecting the AI ratio, a fully local rule engine diagnoses AI traces (paragraph-level JSON report), then applies deterministic rewriting that keeps the academic register
• Bilingual UI: the app and installer support one-click switching between 中文 / English
• Free for personal use: a paid API is reserved, but personal noncommercial use stays free forever; any commercial use is prohibited

Detect → Diagnose → Treat (new in v1.1)

Detection is only the first step. This project merges the methodology of two MIT open-source projects into a complete loop - everything runs locally, with no external AI calls:

Diagnosis (local rule engine)

Scans three groups of signals and outputs a paragraph-level structured JSON report (exportable):

Each paragraph gets: risk level, matched patterns with evidence snippets, sentence-level markers, and suggested actions.

Treatment (three-round protocol, deterministic rewriting)

1. Round 1 (subtraction): protect spans first (citations, figure/formula numbers, data/percentages/P-values, technical terms, quotations - never touched), then word-level replacements (Chinese AI high-frequency words, rotating variants), sentence restructuring, and breaking parallels/numbering;
2. Round 2 (addition): rhythm engineering - deterministic long-sentence splitting (target CV ≈ 0.45); never fabricates facts, data or references;
3. Round 3 (self-check): Anti-AI audit + register guard - any colloquial/online slang must be restored to formal academic language, at most one em-dash per paragraph, register comes before change ratio.

Four iron rules apply throughout: no full AI rewrite, >40% change only through structural rewriting and template removal, deterministic replacements, and a hard academic-register floor.

After detection, if the overall AI ratio exceeds the threshold you set (default 30%, adjustable), the app suggests entering the rewrite flow; you can also click "Rewrite" at any time.

Inspiration

This project was inspired by my college-student friend.

His graduation thesis had to be re-checked for AI-written ratio again and again - once per revision - while the official school service is limited and expensive. Hearing his complaints, it hit me: there is always someone gaming in a dorm, and gaming PCs basically all have dedicated GPUs that can easily run local AI detection; if one GPU is not enough, link roommates' computers with an Ethernet cable / LAN, or even add Pads and phones to the compute pool.

So this project was born: bringing thesis detection back to local, free and controllable.

The 12 integrated methods (all implemented, not just cited)

This project does not invent its own algorithms - it implements the following peer-reviewed methods as runnable engines or benchmark modules, grouped into Detectors / Rewriters / Benchmarks. No model is bundled; download what you use.

Detectors (8) - is this text AI-written?

Rewriters (2) - diagnose & reduce, built-in rules, no model download

Benchmarks (2) - audit a detector

Both benchmarks can import a subset of the official datasets (CSV / JSONL) for real evaluation, and export a Markdown report. The 15 built-in samples are a hand-written smoke test by the author - they are not an official score.

Separately, the "deep AI patterns" list originates from Wikipedia's "Signs of AI writing" (WikiProject AI Cleanup), localized by aigc-reduce.

Disclaimer: results depend on the model and text type. They are for self-checking only and are not the verdict of any authority - the official judgement of your school / journal always wins.

Extending: swap models / add engines (no rebuild needed)

1. Swap a model: create engines_catalog.json in the install directory and override just the field you want - e.g. move Binoculars to the Falcon pair:

   [{"id": "binoculars", "models": [{"repo": "tiiuae/falcon-7b"}, {"repo": "tiiuae/falcon-7b-instruct"}]}]
   

2. Add an algorithm: drop a .py into engines_plugins/, declare it with @register("my_impl") and implement predict_paragraphs() - it is discovered at startup.
3. Remote list: Engine manager → "Check for updates" → paste the URL of an engines_manifest.json; new engines / models arrive without upgrading the app.

Special Thanks (Compute Pooling)

The "multi-device parallel detection" feature borrows ideas from these two open-source projects:

• exo (exo-explore/exo, ~46k stars on GitHub): turns everyday devices (phones, Pads, laptops, gaming PCs) into a P2P distributed AI cluster with auto-discovery and dynamic model splitting, running large models on ordinary home hardware.
• llama.cpp (ggml-org/llama.cpp): one of the most popular local LLM inference frameworks; its RPC distributed inference splits model layers across heterogeneous devices (e.g. Mac Metal + NVIDIA CUDA), serving as the reference for our cross-device perplexity engines.

Thanks to those projects and their communities for making "dorm compute pooling" possible.

Special Thanks (Diagnosis & Treatment)

The "Detect → Diagnose → Treat" loop directly merges the methodology of two MIT open-source projects:

• aigc-reduce (xiaofenggan01/aigc-reduce): three-round protocol, replacement tables, Chinese AI high-frequency word lists, colloquial blacklist and 9-dimension scanning methodology. Our rewrite engine follows its rules exactly, insisting "de-AI-ing ≠ colloquializing", with the formal academic register as a hard floor.
• cnki-aigc---skill (qingshanliuci/cnki-aigc---skill): a real-world method based on CNKI's "5 language patterns" (measured 20.6% -> 10.1%). Our diagnosis engine follows its patterns.

Thanks to both authors and their communities for making the full detect → diagnose → treat flow possible.

Support

This project is completely free for personal use. If it helped you, you are welcome to simply share it with someone who needs it / give it a ⭐ Star, which helps just as much.

⚠️ Commercial use of this project is prohibited. Personal study, research and exchange are free; for commercial use, please contact the author for written permission first.

💬 Feedback / suggestions / collaboration are all welcome - contact: [email protected]

Tech Stack

• UI: Python + PySide6 (custom modern-tool UI)
• Detection: transformers - 8 switchable engines (classifier / perplexity / probability curvature / dual model); models downloaded on demand, inference always local
• Diagnosis: local rule engine (9-dimension scan + CNKI 5 language patterns + 11 deep AI patterns, paragraph-level JSON)
• Treatment: three-round protocol (deterministic rewriting + protected spans + register guard, fully offline)
• Benchmarks: RAID / MGTBench metrics (accuracy / FPR / FNR / F1, per generator)
• Extension: engine plugin folder (engines_plugins/*.py) + a remotely updatable engine list
• Multi-device: multi-GPU parallelism + LAN master/worker (UDP auto-discovery + TCP task dispatch)
• Logs: local run logs only (exportable; never contains paper content); no telemetry is uploaded
• Packing: small installer; the runtime downloads on demand (checks first, installs what's missing, with a progress bar)

Bug Reports

Click "Export Logs" in the app and send the package to: [email protected].

Feedback, suggestions and collaboration are all welcome.

License

The source code of this project is public, but commercial use is prohibited. Licensed under the PolyForm Noncommercial License 1.0.0.

✅ Permitted

• Personal study, research, experiment, and testing
• Personal hobby projects and private entertainment
• Use inside noncommercial organizations (schools, nonprofits, government bodies)
• Reading the source, filing issues, suggesting improvements
• Redistribution and sharing, provided the license and attribution are kept

❌ Prohibited

• Any commercial use (including internal company use, client work, SaaS hosting, etc.)
• Reselling the software or modified versions
• Removing or altering the author's attribution or copyright notices
• Using this project's code / models to train commercial products

Commercial licensing

Please email [email protected] with the intended use and scope.

This license restricts third-party commercial use only. It does not prevent the author from charging for the project or offering commercial licenses.