626aa48442222bafe028ca0d769a5fe2402164d028debc1a541445637b528c7f
WonderPhi Compute — Constitutional Parallel Runner
Publicly online since 2010 · U.S. patent applications since 2012 · inventions offered since 2014. The work of Christopher Gabriel Brown, independently documented.
WonderPhi Compute v1.0.0 — The Constitutional Parallel Runner
Modern operating systems have quietly stolen your compute. Background telemetry, throttled schedulers, GPU cores that sit dark unless you know the incantation, opaque service processes running against your consent, forced updates that reset every setting you cared about. Your machine has 80 cores and it feels slower than the 4-core laptop you had in 2014. Something is deeply wrong.
WonderPhi Compute is the antidote. One frozen executable. Zero external dependencies. Reads a plain-text plan of shell commands, executes them across every CPU core you own, honestly reports what it did, and rests when the work is done. Born once. Never updated. No subscription. No telemetry. No surprise.
Proven on Real Work
Before shipping, WonderPhi Compute was pointed at a real audit workload: 541 corporate-domain health checks, one HTTP HEAD request per domain, each with a 5-second timeout ceiling. The kind of thing every operations team runs.
| Approach | Wall Time |
|---|---|
Sequential for loop (typical shell script) |
1,628 seconds (~27 minutes) |
| WonderPhi Compute | 36.6 seconds |
| Effective speedup | 44.5× |
Twenty-seven minutes compressed to thirty-seven seconds. That is the difference between an operations task you can do while you finish a sip of coffee and one that eats an afternoon. Multiply that difference across every parallelizable job in your week and the picture becomes clear.
Live on the Inventor's Workstation — 2026-07-18
A second benchmark ran on Christopher Gabriel Brown's own machine at install time. A different workload — SHA-256 hashing every PDF in a directory tree — on the actual disk of the actual inventor of this software. These are not marketing numbers. They are the log:
| Workload | SHA-256 hash 160 real PDFs |
| Machine | 80 cores, GPU present (Windows) |
| Sum of task time (serial baseline) | 88.27 s |
| Wall clock with WonderPhi Compute | 3.40 s |
| Speedup | 26.0× |
| Constitutional checksum at startup | 0xb — VERIFIED |
| Failed tasks | 0 |
Two benchmarks on two different workloads on two different machines — 44.5× on URL health checks, 26× on file hashing. The exact speedup a buyer will observe depends on their own workload's serial time and their core count, but the mechanism is the same, and the log is honest.
How It Works
You write a plan file — a plain-text document, one shell command per line, blank lines separating stages. WonderPhi Compute reads it, allocates one worker per CPU core, and dispatches commands in parallel until the stage is complete. Then the next stage runs. Then the next.
# WPC v1 # Stage 1 — convert 200 videos in parallel ffmpeg -i clip001.mov -c:v libx264 out001.mp4 ffmpeg -i clip002.mov -c:v libx264 out002.mp4 ... (198 more) # --- barrier above — all conversions must finish before merge --- # Stage 2 — single aggregating step python merge_manifest.py out*.mp4 > final.txt # --- barrier above --- # Stage 3 — cleanup, in parallel rm out*.mov rm out*.log rm /tmp/wpc_scratch/*
That is the entire language. No YAML. No DSL. No dependency graphs to maintain. If you can write shell, you can write a WonderPhi plan.
The 10 Commandments — The Constitution
Every WonderPhi Compute binary carries the same ten immutable laws, compiled in, verified via an XOR checksum at every startup. Any binary that fails the constitutional checksum refuses to run. This is the guarantee that no build server, no supply-chain compromise, no future maintainer can silently weaken the promises the software makes to you.
| I | I am the Lord thy God. WonderPhi Compute is the sole orchestrator of the plan file. No competing scheduler, no ambient supervisor, no background daemon can override its decisions mid-run. |
| II | Thou shalt have no other gods before me. Exactly one WonderPhi Compute instance per working directory. The lock is enforced via a file that carries the process ID; any second attempt is rejected immediately with the offending PID reported. |
| III | Thou shalt not take the name of the Lord in vain. Every task line is validated before dispatch. Malformed input is rejected with the exact line number, not silently mangled into whatever the shell happens to accept. |
| IV | Remember the Sabbath day, to keep it holy. Idle workers sleep. WonderPhi Compute never busy-waits, never spins on an empty queue. When there is nothing to do, the machine rests. |
| V | Honour thy father and thy mother. The plan.wpc.txt v1 file format is frozen forever. A plan you write today shall run on every WonderPhi Compute binary that will ever be released. |
| VI | Thou shalt not kill. The audit log appends only. It is never truncated, never rotated in-place, never rewritten. A crash mid-run leaves the entire prior history intact for forensic examination. Nothing you learned from the machine is ever taken from you. |
| VII | Thou shalt not commit adultery. Commands are dispatched to the platform shell verbatim. No silent retry. No auto-mutation. No hidden environment shims. What you wrote is what runs. |
| VIII | Thou shalt not steal. Hardcoded resource ceilings: at most 64 concurrent tasks, at most 4 GB memory per task, at most 24 hours runtime per task, at most 512 MB log file before rotation. WonderPhi Compute shall never consume more resources than these limits. |
| IX | Thou shalt not bear false witness. Exit codes are reported truthfully. Elapsed times are measured, not estimated. A failed task appears as failed. A timeout appears as a timeout. There is no marketing lipstick on the numbers. |
| X | Thou shalt not covet. Zero external Python packages. No network calls. No telemetry endpoints. No auto-check-for-updates. The frozen binary is fully self-contained. It desires nothing from the outside world. |
Run wpc --about at any time to see the constitution and verify the checksum on your copy. Verified is verified.
Always-On Mode — The Three Watchers, included in v1.0.0
The bundle installs three cooperating watchers that turn WonderPhi Compute into a drop-a-file-and-it-runs service. Each is a thin, separable wrapper around wpc.exe. None of them modify wpc.exe. The 10 Commandments and the version 1.0.0 permanence guarantee remain absolutely intact.
| Watcher | Behavior |
|---|---|
wpc-watcher |
Polls wpc-inbox\ for plan files, runs wpc.exe on each. Injects live GPU environment variables (WPC_GPGPU, WPC_GPU_VRAM_FREE_MB, WPC_GPU_UTIL_PCT) into every task so plans can branch on GPU availability. |
wpc-autoplan |
Auto-mode #1. Watches wpc-auto\ for bulk drops (5+ files of the same type). Auto-generates a matching plan — PDF hash, image identify, log grep, text count, or universal SHA-256 — and dispatches it. You drop files, not plans. |
wpc-observer |
Auto-mode #2 (hypothesis). Samples the running process list once a minute. When it sees the same tool launched 5+ times in a 10-minute window, writes a hypothesis .md to wpc-hypotheses\ suggesting a parallel plan. Observes and suggests — never executes on its own. You review, you decide. |
One line install (no admin required, registers all three at logon):
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass .\install.ps1
Uninstall anytime with .\uninstall.ps1. The three watchers can be enabled independently — disable any single Scheduled Task from Windows Task Scheduler without affecting the others.
What is in the Box
| File | Purpose |
|---|---|
wpc.exe |
9.4 MB standalone Windows runtime. No Python required. This is the binary the constitution protects. |
wpc-watcher.exe |
8.3 MB always-on watcher. Polls wpc-inbox\, runs wpc.exe on each plan file, injects live GPU env vars into tasks. |
wpc-autoplan.exe |
8.3 MB bulk-drop auto-planner. Watches wpc-auto\ for 5+ files of the same type, generates the right plan automatically. |
wpc-observer.exe |
8.3 MB process observer. Samples running processes, emits parallel-execution hypotheses to wpc-hypotheses\. Never executes on its own. |
install.ps1 |
One-line PowerShell installer. Creates all folders, copies binaries, registers three Scheduled Tasks. No admin required. |
uninstall.ps1 |
Symmetric uninstaller. Removes the three scheduled tasks; leaves binaries in place for you to delete. |
wpc.py |
Full runner source, ~500 lines of Python (standard library only). Read, audit, modify for your own build. |
wpc-watcher.py, wpc-autoplan.py, wpc-observer.py |
Sources for the three watchers. Auditable, forkable. |
commandments.py |
The constitution as Python constants. XOR checksum computed at import; a mismatch prevents startup. |
README.md |
Full documentation — constitution, plan-file syntax, CLI reference, installation, usage. |
example.plan.wpc.txt |
Ready-to-run demonstration — three stages, ten tasks, exercises the parallelism and barrier semantics. |
Makefile |
Rebuild the executables from source (make build), repackage as a release zip (make zip). |
LICENSE, CONTACT_INFO.txt |
Proprietary perpetual license. US-only, email & postal contact only. |
Auto-Mode in Practice
The three watchers exist to eliminate the two frictions that keep parallel tools underused: writing plan files and remembering to run them. Here is how they compose in real work:
- Bulk drop, zero writing. You export 300 receipts as PDFs into
wpc-auto\. Within 15 seconds,wpc-autoplannotices the drop is stable, moves the files towpc-auto-processed\, generates a SHA-256 audit plan, and hands it towpc-watcher. Sixty seconds later you have a full cryptographic manifest of 300 files. - Nightly plan on a schedule. Use Windows Task Scheduler to copy a fixed plan file (backup rotate, cache sweep, log rollup) into
wpc-inbox\at 3 AM.wpc-watcherpicks it up within 15 seconds and runs it. No cron, no service, no daemon written from scratch. - Hypothesis-caught pattern. You launch
ffmpegserially five times in ten minutes converting some MP4s.wpc-observernotices the pattern and dropshypothesis-...ffmpeg.mdintowpc-hypotheses\with a suggested parallel plan. You review, adjust the file list, drop it intowpc-inbox\, and the next 50 conversions run at 40× the speed of the first five. - GPU-aware branching. Every plan task sees
WPC_GPGPU=1or0plus live VRAM stats. Your Python or shell command reads$env:WPC_GPU_VRAM_FREE_MBand decides whether to dispatch that inference batch to the GPU or fall back to CPU. WPC does not attempt magic auto-offload — it makes the information available; you decide. - Composition is the point. Each watcher does one thing.
autoplanfeedswatcher;observerfeeds you (neverwatcher);watcherfeedswpc.exe. Each can be disabled independently from Task Scheduler without breaking the others. Constitutional integrity flows only one direction: outward fromwpc.exe.
Real Workloads WonderPhi Compute Was Built For
The benchmark above — 541 URL checks — is one example. The plan-file model is intentionally generic. Any bag of independent shell commands is a candidate. Some real cases:
- Batch PDF processing. Point at a directory of 1,000 PDFs; extract text, images, or tables from all of them across every core.
- Media transcoding. Feed a queue of MP4 to H.264 or WAV to FLAC conversions; the CPU-bound work scales linearly with core count.
- Bulk image manipulation. Resize, watermark, convert, or optimize thousands of images with
ffmpeg,ImageMagick, orcwebpin one plan. - Regression testing. Run your test suite in parallel — one test file per line — and get honest per-test timing in the log.
- Cryptographic audits. SHA-256 every file in a filesystem tree; the log becomes the audit record.
- URL and API health checks. The workload from the benchmark above — catch dead links and broken endpoints in minutes instead of hours.
- Compile fan-outs.
gccorcargo buildacross a matrix of targets, using barriers to sequence generate-then-link steps. - Deploy pipelines. Parallel
rsyncorscpto fleets of machines, with barriers between deploy phases.
What Sets It Apart
The Unix tradition is rich with parallel-runner tools. GNU parallel is powerful and cryptic. make -j is elegant but tangled with build-system semantics. xargs -P is fast and inscrutable. Each of them grew organically over decades, accumulating flags and edge-cases and unwritten conventions.
WonderPhi Compute took a different vow at inception: 10 immutable rules, published up front, verified at every startup. There is no configuration to memorize. There is no flag matrix to explore. There is one file format, one command, one guarantee. If future improvements are ever needed, they will ship as a new product with a new SKU — not as an update that quietly changes the semantics under a customer who bought certainty.
Purchase Terms
$149.99 — one time. That is the entire price. Ever.
- Perpetual license. Runs on your equipment for the lifetime of that equipment.
- No subscription. No renewal. No trial that expires. No feature paywall.
- No forced update. Version 1.0.0 is the version you buy, and the version you keep. If a future WonderPhi Compute is released, it will be a separate SKU at its own price. This SKU stays as shipped — that is the constitutional guarantee.
- Full source included. The proprietary license restricts redistribution, but you receive the source code for your own audit, verification, and rebuild.
- Available exclusively to buyers in the United States. USD only. Email and postal contact only. No phone, no brokers, no intermediaries.
A Companion to the WonderPhi Universal Permanent Driver
If you already own the WonderPhi Universal Permanent Driver ($99.99, for the 142 AutoPhi IC designs) you already know the constitutional model. WonderPhi Compute is the same doctrine translated from silicon to software — the 10 Commandments carried over into a general-purpose parallel runtime for regular computers. If the Driver is new to you, WonderPhi Compute is a fitting first meeting with WonderPhi promise: write it once, honor it forever.
Christopher Gabriel Brown • Inventor, Author, Visionary • CRI-ONE • WonderPhi
License: Proprietary. Patent pending.