WonderPhi Compute for organizations — perpetual single-organization commercial license

Everything below is identical to the retail product. What's different: your license covers the entire buying organization (unlimited machines, VMs, containers, cloud instances) with no seat count, no annual renewal, no telemetry, no activation. Redistribution / SaaS / hosted-service exposure require a separate OEM arrangement.

Easy Setup — No Package Manager, No Account, No Cloud

One PowerShell line, no admin needed. No Python required on the target machine.

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\install.ps1

Copies the binary to %USERPROFILE%\bin, creates the inbox and outbox folders, and registers three scheduled tasks that auto-start on login. Done in about fifteen seconds.

WonderPhi Compute — put every one of your CPU cores to work at the same time

Almost every program you use only runs on one processor core — even if your machine has 8, 16, 40, or 80 of them. WonderPhi Compute is a tiny, permanent runtime that reads a plain text list of things you want done, then does them across every core at the same time. Work that took hours finishes in minutes. Nothing to install from the internet at run time, nothing to log in to, nothing that phones home. Ever.

What it is, in plain English

Picture a store with 16 checkout lanes but only one open. Everyone waits in a single line. Your computer is like that — it has many “lanes” (CPU cores), but most programs use just one. WonderPhi Compute opens every lane at once.

You give it a plain text file. Each line is a thing to do — the exact same command you'd normally type by hand. It reads the list, dispatches every line to a different core simultaneously, waits for the barrier ("blank line" = "wait for everything above to finish"), then moves on to the next batch. When the run ends, it reports honestly which finished, which failed, and how long each one took. No black box, no silent retries, no "helpful" mutations.

How you use it — three steps

1. Write a plan file. A plain text file with one shell command per line. Blank lines are barriers — nothing below runs until everything above finishes.
2. Hand it to Compute. Drop the file into the inbox folder that install.ps1 created, or run wpc myplan.wpc.txt from any terminal.
3. Read the log. Compute writes a run folder with wpc.log (the truth) and watcher-run.log (the audit trail). Every exit code, every elapsed time, no editorializing.

Worked examples — copy these into a text file, save with .wpc.txt, and drop in the inbox

Example A — convert 200 Word documents to PDF

This runs 40 files at a time on a 40-core box. What used to take an afternoon finishes over lunch.

# WPC v1
# One shell command per line. Blank lines separate parallel stages.

soffice --headless --convert-to pdf reports/report001.docx --outdir out/
soffice --headless --convert-to pdf reports/report002.docx --outdir out/
soffice --headless --convert-to pdf reports/report003.docx --outdir out/
... (up to report200.docx)

Example B — encode 60 4K videos then delete the source files

# Stage 1: parallel-encode every source
ffmpeg -i src01.mov -c:v hevc_nvenc -crf 22 out/out01.mp4
ffmpeg -i src02.mov -c:v hevc_nvenc -crf 22 out/out02.mp4
ffmpeg -i src03.mov -c:v hevc_nvenc -crf 22 out/out03.mp4

# --- barrier: wait for every ffmpeg to finish before deleting ---

# Stage 2: delete originals (only runs after stage 1 completes successfully)
del src01.mov
del src02.mov
del src03.mov

The blank line is a synchronization barrier. Nothing in Stage 2 starts until every command in Stage 1 finishes.

Example C — check the health of 500 web servers, in parallel

curl -sI https://server01.example.com/health
curl -sI https://server02.example.com/health
curl -sI https://server03.example.com/health
... (up to server500)

500 HTTP checks on a 40-core box finish in about the same wall-clock time as one check — the cores are almost idle waiting on the network, so they can each hold dozens of connections open at once.

Under the hood — the honest technical picture

Compute is a single frozen executable (wpc.exe) written in Python, then packaged with PyInstaller. It uses Python's subprocess module to spawn one child process per plan-line, distributes those children across cores with the OS's default scheduler, and enforces a per-task memory cap of 4 GB and a per-run wall-clock cap of 24 hours. The concurrency ceiling is hardcoded at 64 to prevent thrash on hyperthreaded 128-thread machines.

Its constitution — the ten immutable rules baked into every binary and verified at startup via SHA-256 checksum — guarantees that WPC will never silently do anything unexpected. Concretely:

• Log-only writes are append. A crash never destroys prior history. Your paper trail is safe.
• Malformed plan files are rejected up-front. If the file has a typo that would corrupt parsing, WPC refuses to start rather than half-run and half-crash.
• Commands dispatch verbatim. No mutation, no shell-escape mangling, no "smart" retry. What you wrote is what runs.
• Exit codes are reported truthfully. If a task exits with a nonzero code, that fact is in the log and in the summary. No exit-code laundering.
• Sabbath rule. Idle worker slots sleep — WPC never busy-waits, never spins the CPU at 100% waiting for nothing.
• Zero dependencies. No pip install anything. No network. No telemetry. No auto-update. Version 1.0.0 is the only version that will ever exist.

Run wpc --about to see the full constitution and verify the SHA-256 checksum of the binary you're running matches the one on your download.

How it compares to other parallel runners

What you need

• Windows 10 / 11 (native .exe). macOS and Linux users can run the Python source directly — Python 3.8+ standard library only.
• A few gigabytes of free disk for logs. Compute never fills your disk — logs rotate at 100 MB per run.
• Whatever tool the plan-line invokes (ffmpeg, curl, soffice, your own script, etc.). Compute doesn't ship those; it only orchestrates them.
• No account. No cloud. No internet at runtime.

What's in the download

• wpc.exe — the runtime (Windows, standalone, no Python required)
• wpc-watcher.exe, wpc-autoplan.exe, wpc-observer.exe — three always-on helpers for drop-a-file-and-it-runs mode
• install.ps1 — one-line PowerShell installer (no admin required)
• wpc.py — runtime source (Python, stdlib only) for macOS/Linux
• commandments.py — the constitution (verified at startup)
• example.plan.wpc.txt, healthcheck.plan.wpc.txt — ready-to-run demos
• BENCHMARKS.md — full methodology + per-test parameters for every performance claim above
• README.md — concise reference for humans
• README-DANGER.md — edge cases and their fixes
• LICENSE.txt — perpetual single-user license, personalized with your name and order number at delivery

Common questions

License & support — Industrial variant

Perpetual, non-exclusive, non-transferable Industrial license. Covers all machines, VMs, containers, and cloud instances operated by a single organization (the legal entity named on the purchase receipt plus wholly-owned subsidiaries). No seat count, no machine limit, no renewals, no activation, no telemetry.

Employees, contractors, and consultants under the organization's direction may operate the software solely for the licensed organization's benefit. Rights end when their engagement ends.

Not permitted without a separate arrangement: redistributing the software; hosting it publicly; embedding it in a product/SaaS/PaaS you sell to third parties; sublicensing.

Support: email chris@cri-one.com.

Every download's LICENSE.txt is personalized at checkout with your organization name, order number, and issue date. USA sales.