install any CLI tool via the unified homebrew tap (33 formulas: arb, awkrs, elisprs, grcrs, groovyrs, htoprs, iftoprs, javars, kotlinrs, lsofrs, nmaprs, node-js, phplang, powerliners, pythonrs, rlang, rubylang, scalars, storageshower, stryke, tclrs, temprs, vimlrs, zcolorizer, zdbview, zmax, zpwrchrome-host, zshrs, zshrs-all, zshrs-daemon, ztmux, zvcs, zwire-host)

September 6, 2026 · View on GitHub

 ███╗   ███╗███████╗████████╗ █████╗
 ████╗ ████║██╔════╝╚══██╔══╝██╔══██╗
 ██╔████╔██║█████╗     ██║   ███████║
 ██║╚██╔╝██║██╔══╝     ██║   ██╔══██║
 ██║ ╚═╝ ██║███████╗   ██║   ██║  ██║
 ╚═╝     ╚═╝╚══════╝   ╚═╝   ╚═╝  ╚═╝

`[META REPO // 190 SUBMODULES // ONE COMMAND, EVERY MENKETECHNOLOGIES PROJECT]`

"One repo to rule them all, one repo to fetch them, one repo to bring them all, and on every host bind them."

MenkeTechnologiesMeta is a single umbrella repo that vendors every active MenkeTechnologies project as a git submodule. Clone once with --recurse-submodules and a fresh host has the entire stack: strykelang (the language), zshrs (the shell), fusevm (the bytecode VM), vimlrs (the standalone VimL interpreter on fusevm), elisprs (the standalone Emacs Lisp interpreter, running on fusevm), rubylang (the compiled Ruby runtime on fusevm), rlang (the compiled R runtime on fusevm), javars / kotlinrs / scalars / groovyrs / go-rs / tclrs (the Java / Kotlin / Scala / Groovy / Go / Tcl frontends on fusevm), arb (the pipeline-visualization TUI language on fusevm), texrs (a TeX engine — Knuth's mouth and expander, plus a stomach that hyphenates, breaks paragraphs by total demerits, and writes DVI and PDF), lsofrs / awkrs / temprs / nmaprs / powerliners / grcrs (the Rust CLI tools), iftoprs / storageshower / zdbview (TUIs — the last one a CRUD editor for the stack's rkyv archives and SQLite databases), zpwr-jobs (the job-application pipeline CLI), Audio-Haxor / traderview (Tauri v2 desktop GUI apps), ztranslator (the real-time MIDI/OSC/DMX event-translation desktop app + embeddable routing engine), zcite / zreq / ztunnel / zgo / zftp / zcontainer / zstation / ztorrent (the ported Tauri v2 desktop apps — Zotero / Postman / Tunnelblick / Alfred / Cyberduck / Docker Desktop + Lens / Station / Transmission reimagined in Rust, each with its embeddable *-core engine), zterminal (the GPU-accelerated terminal emulator) zmax (the Rust Emacs port — a Vim-style modal core built out toward Spacemacs), zpwr-synth / zpwr-fx / zpwr-midi-fx / zpwr-daw (the four JUCE patch-graph audio plugins — three perform plugins plus the FL-style DAW, every track a patch graph of blocks) + zpwr-patch-core (their shared signal-agnostic patch graph) + zpwr-crate (the shared Rust sample-library crate browser behind Audio-Haxor and zpwr-daw) + zpwr-embed-terminal (the shared PTY terminal vendored into the desktop apps) + zpwr-file-browser (the shared multi-pane file browser — JS front end + Rust fs crate) + zpwr-hooks-editor (their shared stryke Hooks code editor) + zpwr-modal-editor (the shared Vim/Emacs modal-editing surface) + zpwr-i18n (the shared portable i18n runtime) + zpwr-clip-engine (the shared JS arranger/sequencer frontend extracted from zpwr-daw) + zpwr-algo-production (the algorithmic music-production engine behind zpwr-daw's one-click track generation) + app-store (the storefront) + MenkeTechnologiesPublications (the private paid books / reference manuals / zpwr encyclopedia + their build pipeline), zpwr (the terminal OS), the 33-repo stryke ecosystem (stryke-aws, stryke-azure, stryke-clickhouse, stryke-scylla, stryke-search, stryke-gcp, stryke-k8s, stryke-kafka, stryke-zmq, stryke-gui, stryke-polars, stryke-utils, ...), the 28-repo zsh plugin family (zsh-more-completions, zsh-expand, zsh-cargo-completion, fzf-tab, revolver, zunit, ...), editor / multiplexer plugins (VimColorSchemes, vim-stryke, vscode-stryke, emacs-stryke, vim-zsh, vscode-zsh, emacs-zsh, vscode-awk, vim-awk, emacs-awk, vscode-viml, vim-viml, emacs-viml, tmux-fzf-url), the 9-repo znative plugin family (zshrs-forgit, zshrs-git-fuzzy, zshrs-git-repos, zshrs-revolver, zshrs-kubectl-completion, zshrs-zsh-z, zshrs-fasd, zshrs-reveal, zshrs-zwire — classic zsh utilities ported to native compiled cdylib zshrs plugins installed via znative), the cyberpunk editor theme (zpwr-theme — VS Code + JetBrains), the Chrome extension (zpwrchrome) and zwire (a Chromium superset — that extension + a cyberpunk theme preloaded on an unbranded Chromium snapshot), the public website (MenkeTechnologies.github.io), the web-API services api-rest-generator and LearningCollectionAPI, and the commercial back end zpwr-license / zpwr-account (offline license crypto + the accounts / subscriptions / device-activation service behind the paid catalog).

`MenkeTechnologies on GitHub` · `strykelang` · `zshrs` · `zpwr`

[0x00] Quick Start
[0x01] Submodule Map
[0x02] CI Status Board
[0x03] Common Operations
[0x04] Helper Scripts
[0x05] Updating Submodule Pointers
[0x06] Per-Host Setup
[0x07] Working Inside a Submodule
[0x08] Disk Footprint
[0x09] Code Volume
[0xFF] License

[0x00] QUICK START

Fresh host — clone everything and put every submodule on main, one copy-paste:

git clone --recurse-submodules -j 8 https://github.com/MenkeTechnologies/MenkeTechnologiesMeta.git && cd MenkeTechnologiesMeta && git submodule foreach --recursive 'git checkout main 2>/dev/null || true'

--recurse-submodules fetches all 190 submodules in parallel (-j 8 = 8 at a time), then the foreach switches each one from its detached-HEAD pinned SHA onto its main branch.

Already cloned without --recurse-submodules? Add them after the fact:

git submodule update --init --recursive

Faster initial clone (parallel jobs):

git clone --recurse-submodules -j 8 https://github.com/MenkeTechnologies/MenkeTechnologiesMeta.git

-j 8 clones up to 8 submodules concurrently. Bump higher on fast networks. Re-run the git submodule foreach ... git checkout main step after any git submodule update that re-detaches HEAD.

[0x01] SUBMODULE MAP

All 190 submodules sit flat at the repository root. URLs are HTTPS for fresh-host portability (no SSH key needed for clone --recurse).

Tier 1 — Core (75)

The set of MenkeTechnologies projects that share the unified strykelang-authored documentation template (README header, ToC convention [0xNN], docs/index.html chrome, docs/report.html engineering report, man/man1/<name>.1 + <name>all.1 man pages).

The eighteen `fusevm` language frontends — toolchain parity

Eighteen languages share one self-authored execution engine — the fusevm bytecode VM with its 3-tier Cranelift JIT — each lowering its own frontend (lex → parse → AST → fusevm bytecode) onto the same VM rather than carrying a bespoke runtime. All eighteen are at full toolchain parity (every row below is green; texrs, the newest, closed its last two gaps — inline rust {} FFI and --dump-ast): a standalone CLI binary, an LSP server (--lsp) and DAP debug adapter (--dap) on stdio for editors, a zsh completion in completions/, man/man1/<name>.1 + <name>all.1 man pages, an HTML docs/report site, a generated reference.html, inline Rust FFI — rust { pub extern "C" fn … } blocks that compile to a cached cdylib on first run (via the shared fusevm FFI runtime) and become callable by name — --dump-tokens / --dump-ast / --disasm introspection, and --tiers, which runs a program and then reports which fusevm JIT tier each of its compiled chunks actually reached. The newest is TeX (texrs), the eighteenth frontend — Knuth's mouth and expander lowered onto fusevm, with a stomach that stops short of tex's — --pdf breaks paragraphs by total demerits and hyphenates, --dvi is still first-fit, and neither breaks pages by penalties. Before it, Tcl (tclrs), the seventeenth frontend, now green across the matrix: the parser covers all twelve syntax rules of Tcl(n), the compiler lowers commands, procedures, coroutines, the string / array / dict ensembles and the list commands to fusevm bytecode, the whole expr(n) operator set compiles straight from a braced word with no runtime parse, a hot loop inside a proc reaches a compiled trace, and --aot links a native binary carrying no Tcl interpreter at all. tclsh 9.0.4 is the specification: every program in the suite is run by both engines and compared byte for byte. Tcl's grammar is what makes ahead-of-time lowering pay: braces suppress substitution, so a braced body is fully known at parse time and compiles once instead of being re-parsed per evaluation. tclsh 9.0.4 is the specification — 27 word-splitting cases and 69 whole programs are executed by both implementations and diffed byte for byte, so no expected output in the repo is hand-written — and everything outside the implemented surface (proc, arrays, lists, {*}, math functions, bignum) is refused at compile time rather than approximated. CLI, LSP, DAP, completions, man pages, and the JIT features are phases 4–7. Before it, Go (go-rs) — a standalone go binary that lexes Go (with automatic semicolon insertion), parses, and lowers to fusevm bytecode; it reached full toolchain parity (CLI / LSP / DAP / _go completion / man pages / HTML docs / reference.html / inline rust {} FFI / introspection) in its second build-out, and a broad language surface (single-file package main, top-level func + methods, slices, maps, structs with value-copy semantics, interfaces with dynamic dispatch, for … range, strings/strconv) across its third and fourth, plus goroutines, channels, and select (go / chan / <- / close / select, buffered + unbuffered) in its fifth — which required adding a cooperative green-thread scheduler to the shared fusevm VM itself (v0.14.14–0.14.15, fusevm::sched) — and closures + a broad standard library (strings/strconv/math/sort) in its sixth. Before it, R (rlang) — full CLI / LSP / DAP / completion / docs / reference.html / introspection, with inline-Rust FFI surfaced R-idiomatically as .rust() / .Call() (R has no rust {} block syntax); only the <name>all.1 companion man page remains. Before it, four JVM frontends — Java (javars), Kotlin (kotlinrs), Scala (scalars), Groovy (groovyrs) — reached full production parity in the latest build-out, and are still widening their language coverage from there (single-main/object programs, arithmetic, control flow, printing, and inline rust {} FFI today; broader syntax and standard library in the next waves).

Frontend	CLI	LSP `--lsp`	DAP `--dap`	zsh completion	man pages	HTML docs	`reference.html`	`rust {}` FFI	`--dump-tokens`	`--dump-ast`	`--disasm`	`--tiers`
`strykelang`	`stryke`	✅	✅	✅ `_stryke`	✅	✅	✅	✅	✅	✅	✅	✅
`zshrs`	`zshrs`	✅	✅	✅ `_zshrs`	✅	✅	✅	✅	✅	✅	✅	✅
`awkrs`	`awkrs` / `aw`	✅	✅	✅ `_awkrs`	✅	✅	✅	✅	✅	✅	✅	✅
`vimlrs`	`viml`	✅	✅	✅ `_viml`	✅	✅	✅	✅	✅	✅	✅	✅
`elisprs`	`elisp`	✅	✅	✅ `_elisp`	✅	✅	✅	✅	✅	✅	✅	✅
`arb`	`arb`	✅	✅	✅ `_arb`	✅	✅	✅	✅	✅	✅	✅	✅
`pythonrs`	`python`	✅	✅	✅ `_python`	✅	✅	✅	✅	✅	✅	✅	✅
`rubylang`	`ruby`	✅	✅	✅ `_ruby`	✅	✅	✅	✅	✅	✅	✅	✅
`phplang`	`php`	✅	✅	✅ `_php`	✅	✅	✅	✅	✅	✅	✅	✅
`node-js`	`node`	✅	✅	✅ `_node`	✅	✅	✅	✅	✅	✅	✅	✅
`javars`	`java`	✅	✅	✅ `_java`	✅	✅	✅	✅	✅	✅	✅	✅
`kotlinrs`	`kotlin`	✅	✅	✅ `_kotlin`	✅	✅	✅	✅	✅	✅	✅	✅
`scalars`	`scala`	✅	✅	✅ `_scala`	✅	✅	✅	✅	✅	✅	✅	✅
`groovyrs`	`groovy`	✅	✅	✅ `_groovy`	✅	✅	✅	✅	✅	✅	✅	✅
`rlang`	`Rscript`	✅	✅	✅ `_Rscript`	✅	✅	✅	✅	✅	✅	✅	✅
`go-rs`	`go`	✅	✅	✅ `_go`	✅	✅	✅	✅	✅	✅	✅	✅
`tclrs`	`tclrs`	✅	✅	✅ `_tclrs`	✅	✅	✅	✅	✅	✅	✅	✅
`texrs`	`texrs`	✅	✅	✅ `_texrs`	✅	✅	✅	✅	✅	✅	✅	✅

_{All eighteen rows are ✅ full parity across the core toolchain dimensions. texrs, the eighteenth and newest frontend, was the last to fill its row: it ships the CLI, an --lsp server, a --dap stepping debugger, _texrs, man/man1/texrs.1 + texrsall.1, an HTML docs site, a generated reference.html, --dump-tokens / --dump-ast / --disasm / --tiers, and inline rust {} FFI — \rust{ … } blocks compiled to a cached cdylib and called back as \rustcall, which is a NUMBER wherever TeX reads one. tclrs closed the last of its gaps in the latest build-out (binary + reedline REPL, --lsp, --dap, _tclrs, man/man1/tclrs.1 + tclrsall.1, generated reference.html, inline rust {} FFI, --dump-tokens / --dump-ast / --disasm / --tiers, and --aot). The four JVM frontends (javars / kotlinrs / scalars / groovyrs) and go-rs reached full parity in the latest build-out, and are widening their language surface from there. reference.html is generated from the LSP itself — the language server already knows every symbol, signature, and doc string, so the reference is emitted from that source of truth rather than hand-written. rust {} FFI compiles inline rust { pub extern "C" fn … } blocks to a cached cdylib (shared fusevm FFI runtime) callable by name. The introspection flags dump the lexer token stream (--dump-tokens), the parsed AST (--dump-ast), and a fusevm bytecode disassembly (--disasm) for the given script; --tiers goes one step further and runs it, then asks fusevm's own eligibility and cache predicates which tier took each compiled chunk — block-JIT compiled, trace compiled, blacklisted, or refused, with a histogram of the JIT-ineligible ops when a tier declined — except in tclrs, where Tcl has no lexer to dump (a word's substitutions are decided while it is read), so --dump-tokens prints the parts of each word in read order under the shape (bare / braced / quoted / expand) that decides whether they are substituted at all.}

Project	What it is
`strykelang`	The fastest dynamic language for parallel ops. Perl 5 compatible interpreter in Rust on the `fusevm` bytecode VM + Cranelift JIT, 10,488 builtins. · _{docs · report · reference}
`zshrs`	The first compiled Unix shell. 1:1 zsh C-port + extensions on the `fusevm` bytecode VM + Cranelift JIT, persistent worker pool, AOP intercept, rkyv bytecode cache. · _{docs · report · reference}
`fusevm`	Language-agnostic bytecode VM with fused superinstructions and 3-tier Cranelift JIT. The execution engine behind eighteen language frontends — zshrs, strykelang, awkrs, vimlrs, elisprs, rubylang, arb, pythonrs, phplang, node-js (all at full toolchain parity) plus javars, kotlinrs, scalars, groovyrs, rlang (R), go-rs (Go), tclrs (Tcl), and the newest, texrs (TeX). Also ships a cooperative green-thread scheduler + channels + `select` (`fusevm::sched`, v0.14.14–0.14.15) that hosts go-rs's goroutines. · _{docs · report}
`lsofrs`	Rust rewrite of `lsof` — 5–21× faster, 7-tab TUI (ratatui), 31 cyberpunk themes. · _{docs · report}
`temprs`	Temporary file stack manager. Atomic `flock`-protected master record, dual indexing (position or `@name`). · _{docs · report}
`awkrs`	AWK in Rust. The `fusevm` bytecode VM + Cranelift JIT + persistent rkyv bytecode cache + parallel records. LSP + DAP servers (`awkrs --lsp` / `--dap`); editor plugins `vscode-awk` / `vim-awk` / `emacs-awk`. · _{docs · report}
`vimlrs`	VimL (Vimscript) in Rust — the first compiled standalone VimL interpreter, run outside Vim. A faithful port of Neovim's C eval engine (lex/parse → AST → `fusevm` bytecode → Cranelift JIT), the same VM behind `strykelang` / `zshrs` / `awkrs` / `elisprs`. Standalone binary, with a DAP debugger (`vimlrs --dap`), LSP (`vimlrs --lsp`), AOT native compiler, and rkyv bytecode cache; editor plugins `vscode-viml` / `vim-viml` / `emacs-viml`. Free / OSS (MIT). · _{docs · report}
`elisprs`	Emacs Lisp in Rust — run `.el` outside Emacs. A Lisp-2 obarray (separate value/function cells) with dynamic binding and an elisp-correct reader on the `rust_lisp` (MIT) value model, running on the `fusevm` bytecode VM (the engine behind `zshrs` / `strykelang` / `awkrs` / `vimlrs`) — a pure frontend that lowers each form to a `fusevm::Chunk`, no bespoke VM or JIT. Standalone `elisp` binary + REPL; ships `--lsp` / `--dap` servers, a JetBrains plugin, native-object / standalone-executable `--aot`, and lexical + dynamic binding; `vscode` / `vim` / `emacs` editor plugins planned. Free / OSS (MIT). · _{docs · report}
`rubylang`	Ruby in Rust — a compiled Ruby runtime that runs `.rb` outside MRI. Lexes and parses Ruby to an AST, lowers it to `fusevm` bytecode, and runs on the shared 3-tier Cranelift JIT (the engine behind `strykelang` / `zshrs` / `awkrs` / `vimlrs` / `elisprs`); method dispatch, blocks, and object construction run on a thread-local `RubyHost` heap. Classes / `super` / modules + `include` / exceptions / splat params / `&:sym` block-pass, checked against reference `ruby` by a 35-snippet differential parity harness; standalone `ruby` binary + REPL, `--lsp` / `--dap`, rkyv bytecode cache, AOP intercepts. Free / OSS (MIT). · _{docs · report · reference}
`rlang`	R in Rust — a compiled R runtime that runs `.R` outside GNU R. Lexes and parses R to an AST, lowers it to `fusevm` bytecode, and runs on the shared 3-tier Cranelift JIT; every value is a vector with attributes on an `RHost` heap, so recycling, `NA` propagation, three-valued logic, and copy-on-modify assignment are the runtime's own semantics. All four index forms + `[[`/`$`/`m[i, j]`, closures and `<<-`, replacement functions, S3 `UseMethod`, 131 primitives, R's printing rules — checked against reference `Rscript` by a 48-snippet differential parity harness plus 8 examples, byte-identical to GNU R 4.6.1; standalone `Rscript` binary + REPL, `--lsp` / `--dap`, inline-Rust FFI (`.rust` / `.Call`), rkyv bytecode cache, AOP intercepts. Free / OSS (MIT). · _{docs · report · reference}
`arb`	Visualize and modify Unix pipelines — pipe a stream in and arb spawns a dynamic ratatui TUI (served `zgui` web target later) from a declarative, Tcl/Tk-flavored spec. An original language (not a port) in stryke's class: a `jq` / `xpath` / `css` / `yq` superset query engine, an interactive megafilter/map over the live passthrough, and a compute core (`calc` / expressions) that lowers to a `fusevm::Chunk` and runs on the Cranelift JIT. Widgets (`text` / `tail` / `list` / `gauge` / `bars` / `histo`) arranged by `grid`; source query pipeline (`match` / `reject` / `field` / `count` / `rate` / `tally` over line + JSON). Free / OSS (MIT). · _{docs · report}
`pythonrs`	Python in Rust — Python as a `fusevm` frontend (lex/parse → AST → `fusevm` bytecode) on a `PythonHost` object heap, no bespoke VM or JIT; the first compiled standalone Python runtime, on the shared bytecode VM + 3-tier Cranelift JIT behind the rest of the fleet. Standalone `python` binary with `--lsp` / `--dap`, an AOT native compiler, and a transparent rkyv bytecode cache. Free / OSS (MIT).
`phplang`	PHP in Rust — PHP as a `fusevm` frontend (lex/parse → AST → `fusevm` bytecode) on a `PhpHost` object heap, no bespoke VM or JIT; the first compiled standalone PHP runtime, on the shared bytecode VM + Cranelift JIT behind `strykelang` / `zshrs` / `awkrs` / `vimlrs` / `elisprs` / `rubylang` / `arb` / `pythonrs`. Standalone `php` binary with `--lsp` / `--dap`. Free / OSS (MIT).
`node-js`	JavaScript in Rust — JS as a `fusevm` frontend on the shared bytecode VM + 3-tier Cranelift JIT; a compiled standalone JavaScript runtime. Standalone `node` binary with `--lsp` / `--dap`. Free / OSS (MIT).
`javars`	Java in Rust — Java as a `fusevm` frontend (lex/parse → AST → `fusevm` bytecode) on the shared 3-tier Cranelift JIT; Java source compiled to bytecode with no bespoke VM and no JVM — no `.class` files, no `libjvm`. Newest frontend; the language surface today: single-class `main` with locals, arithmetic, `if`/`while`/`for`/`break`/`continue`, `&&`/`\|\|` short-circuit, `System.out.print[ln]`, and Java `+` string concatenation, verified byte-for-byte against OpenJDK. User methods, objects, arrays, and the standard library are the next waves, but the toolchain is at full production parity: standalone `java` binary with `--lsp` / `--dap` servers, `man/man1/java.1` + `javaall.1`, an HTML docs/report site, a generated `reference.html`, inline `rust {}` FFI, and `--dump-tokens` / `--dump-ast` / `--disasm` introspection + a `_java` zsh completion. Free / OSS (MIT).
`kotlinrs`	Kotlin in Rust — Kotlin as a `fusevm` frontend (lex/parse → AST → `fusevm` bytecode) on a `KtHost` object heap and the shared 3-tier Cranelift JIT; the first compiled standalone Kotlin runtime with no JVM — no `.class` files, no `libjvm`. The language surface today is arithmetic lowered to native ops, control flow, and printing; the toolchain is at full production parity: standalone `kotlin` binary with `--lsp` / `--dap` servers, `man/man1/kotlin.1` + `kotlinall.1`, an HTML docs/report site, a generated `reference.html`, inline `rust {}` FFI, and `--dump-tokens` / `--dump-ast` / `--disasm` introspection + a `_kotlin` zsh completion. Free / OSS (MIT).
`scalars`	Scala in Rust — Scala as a `fusevm` frontend (lex/parse → AST → `fusevm` bytecode) on the shared 3-tier Cranelift JIT, no bespoke VM and no JVM. The language surface today: `object` + `def main` / `extends App`, `val`/`var`, arithmetic (an `SDIV` builtin restores Scala integer-`/` semantics over the VM's float `Div`), `if`/`while`/`for` over ranges, newline-inferred statements, `println`; byte-diffed against reference `scala`. The language surface is still widening; the toolchain is at full production parity: standalone `scala` binary with `--lsp` / `--dap` servers, `man/man1/scala.1` + `scalaall.1`, an HTML docs/report site, a generated `reference.html`, inline `rust {}` FFI, and `--dump-tokens` / `--dump-ast` / `--disasm` introspection + a `_scala` zsh completion. Free / OSS (MIT).
`groovyrs`	Groovy in Rust — Groovy as a `fusevm` frontend (lex/parse → AST → `fusevm` bytecode) on the shared 3-tier Cranelift JIT, no bespoke VM and no JVM. The language surface today: script model, newline-terminated statements, `GDIV` Groovy division, `for`-in desugaring, arithmetic and printing; checked against reference `groovy` by a differential parity + fuzz harness. The language surface is still widening; the toolchain is at full production parity: standalone `groovy` binary with `--lsp` / `--dap` servers, `man/man1/groovy.1` + `groovyall.1`, an HTML docs/report site, a generated `reference.html`, inline `rust {}` FFI, and `--dump-tokens` / `--dump-ast` / `--disasm` introspection + a `_groovy` zsh completion. Free / OSS (MIT).
`go-rs`	Go in Rust — Go as a `fusevm` frontend (lex/parse → AST → `fusevm` bytecode) on the shared 3-tier Cranelift JIT, no bespoke VM, no goroutine runtime, no gc, and no `go` toolchain. Newest frontend: single-file `package main`, top-level `func` + methods (`func (r T) m()`), `:=` / `var`, lvalue assignment (ident / `x[i]` / `x.f`), `if`/`else`/`for` (three-clause / condition / infinite) / `for … range` / `break` / `continue`, `&&`/`\|\|` short-circuit, Go automatic semicolon insertion, static `int`/`float` typing (so `int / int` truncates), slices and maps (`[]T{…}` / `map[K]V{…}` / `make` / index / `len`/`cap`/`append`/`delete`) on a host heap, structs with value-copy semantics, interfaces with dynamic method dispatch (runtime type-switch), closures (function literals with capture-by-value, IIFE, `go func(){}()`), goroutines / channels / `select` (`go` / `make(chan T)` / `<-` / `close` / `select`, buffered + unbuffered, on a cooperative scheduler added to the shared `fusevm` VM in v0.14.14–0.14.15), a broad standard library (`fmt`/`strings`/`strconv`/`math`/`sort`/`os` + `min`/`max`), and `+` string concatenation — checked byte-for-byte against reference `go` by integration tests that run the built binary. The toolchain is at full production parity: standalone `go` binary with `--lsp` / `--dap` servers, `man/man1/go.1` + `goall.1`, an HTML docs/report site, a generated `reference.html`, inline `rust {}` FFI, and `--dump-tokens` / `--dump-ast` / `--disasm` introspection + a `_go` zsh completion. Function-typed parameters, `defer`, and generics are the next waves. Free / OSS (MIT).
`tclrs`	Tcl in Rust — Tcl as a `fusevm` frontend (parse → `fusevm` bytecode), no bespoke VM, no interpreter loop, and no code generator in the crate. The seventeenth frontend, at full toolchain parity. The parser covers all twelve syntax rules of `Tcl(n)` — word splitting, quotes, brace nesting, command and variable substitution, the full backslash table, first-word comments, single-pass order — and the compiler lowers commands, procedures, coroutines, the `string` / `array` / `dict` ensembles and the list commands to bytecode, with the whole `expr(n)` operator set compiled straight from a braced word at `expr(n)` precedence and no runtime parse; Tcl's floored `/` and `%`, integral `*`, numeric-preferring comparison with string fallback, and Tcl double formatting ride two hooks (a numeric hook for operands the VM can't compute on natively, extension ops for the operators whose Tcl meaning differs from the VM's). Values need no object heap — strings, ints and floats map onto `fusevm::Value` directly. tclsh 9.0.4 is the specification: 17 test binaries diff whole programs against it byte for byte, with a differential fuzzer holding the floor, and everything unimplemented (`{}` expansion, math functions, bignum) is refused by name at compile time rather than approximated. A hot loop inside a `proc` reaches a compiled trace (`--tiers` measures it), `--aot` links a native binary carrying no Tcl interpreter, and the toolchain is complete: reedline REPL, `--lsp` / `--dap`, `_tclrs`, `man/man1/tclrs.1` + `tclrsall.1`, generated `reference.html`, inline `rust {}` FFI, `--dump-tokens` / `--dump-ast` / `--disasm`. Free / OSS (MIT). · _{docs · report · reference}
`texrs`	A TeX engine in Rust — Knuth's mouth and expander, built to be lowered onto a bytecode VM. TeX is two machines: the mouth turns bytes into tokens under a mutable category-code table, and the expander turns tokens into other tokens (`\def`, `\csname`, `\the`, the conditionals). texrs implements those two — the half a macro-heavy document spends its time in. The stomach goes as far as a page you can open. `--pdf` breaks a paragraph the way `tex.web` §813-§891 does — every feasible set of breakpoints priced, the cheapest taken, Liang hyphenation widening where a line may end — and embeds the font the document asked for; `--dvi` still takes the first break that fits, because a DVI driver cannot set a run to a width. Neither breaks pages by penalties, sets maths, or nests boxes, so a paragraph set here and the same paragraph set by `tex` will not agree line for line. Free / OSS (MIT).
`zvcs`	A git superset for high-velocity, automated version-control workflows over deep submodule trees — concurrent, lock-free operations that eliminate the `.git/index.lock` contention git hits under many parallel writers. Built for fleets of automated agents committing across a nested submodule meta-repo. Free / OSS (MIT).
`iftoprs`	Real-time bandwidth monitor. TUI built on ratatui, 31 themes, process attribution, NDJSON streaming. · _{docs · report}
`htoprs`	A Rust port of htop — the interactive process viewer (process tree, per-core CPU/memory meters, sort/filter/search, signal sending, renice), ported from the upstream htop C sources rather than wrapping them — the bulk of the htop 3.5.1 C surface faithfully ported function-for-function, each `fn` citing its `<File>.c:<line>` origin. MIT. · _{docs · report}
`zcolorizer`	Real-time log file colorizer. CLI 32 themes · _{docs · report}
`grcrs`	Rust port of `grc` (Generic Colouriser 1.13) — the two-binary suite `grc` (the wrapper: parses options, matches the command line against `grc.conf` regexps, runs the command and pipes its stdout/stderr through `grcat`, with `--pty` mode) + `grcat` (the colouriser filter driving the per-command config rules), ported from the upstream grc sources. MIT. · _{docs · report}
`zdbview`	Terminal inspector and CRUD editor for the two stores the stack writes. SQLite databases get full generic CRUD — browse tables, edit any cell, insert/delete rows by `rowid`, run raw SQL, whole-table SQL-backed search, schema view — because SQLite is self-describing. rkyv archives are not, so a format registry carries a byte-compatible copy of each producer's archive type and decodes eight of them to real key/value records (zshrs script + autoload, strykelang, awkrs, vimlrs, elisprs, pythonrs, rubylang/arb), validated through `check_archived_root`, and edits them with full CRUD — create, update-value, rename, delete — re-serialized byte-identically to the producing host and written back atomically; anything unrecognized falls back to info / embedded strings with offsets / hex dump. The backend is chosen by the file's header magic, never its name, so an rkyv shard written under a `.db` name opens correctly. TUI on ratatui + crossterm: vim motions, detail view with auto/hex/text/disasm rendering (optional `disasm` feature decodes a `chunk_blob` as a bincode `fusevm::Chunk` using the real fusevm types), OSC 52 clipboard, CSV/JSON export (interactive and via `--export`, which never starts the TUI), recent-files picker. MIT. · _{docs · report}
`ztranslator`	Real-time event-translation desktop app in pure Rust — also embeddable as the routing engine inside other apps. Watches MIDI input ports (`midir`), OSC, DMX, and the file system for triggers, matches each event against per-translator rules on a signed-32-bit integer VM (faithful BOME rules: arithmetic + bitwise, `IF/THEN`, `Goto`/`Skip`, 10 locals + globals, wrap-on-overflow), and fires an outgoing action — MIDI / OSC / DMX out, keystroke / mouse / AppleScript (macOS `CGEvent`), timer, or host-defined custom command. Built-in auto-update. Imports and exports BOME MIDI Translator Pro `.bmtp` projects (lossless, unsigned export round-trips through import) and stores native projects as JSON. Ships its own GUI; the same engine drops into a host GUI/CLI app. Paid product — docs vendored locally. · _{docs · report}
`Audio-Haxor`	Tauri v2 desktop GUI app + JUCE engine. VST2/VST3/AU/CLAP scanner, sample vault, DAW project index, KVR version checker. Paid product — docs vendored locally. · _{docs · report}
`traderview`	Tauri v2 desktop GUI app (sibling to Audio-Haxor) — TraderVue-style trading journal with embedded Postgres, vanilla JS + uPlot frontend. The same Rust workspace crates also ship a multi-user axum web service. Paid product — docs vendored locally. · _{docs · report}
`zpwr-daw`	DAW arranger + the 4th patch-graph plugin (standalone app, VST3/AU/CLAP, and embeddable library) — one generalized grid engine over notes / arrangement / automation / trigger domains, with Arrangement & Session views, a swung step clock, MIDI/JSON export, and a JUCE-free C++ core exposing a C ABI + Rust bindings. Every track is a patch graph of `zpwr-patch-core` blocks (178 note-stream modules + the shared audio pack). Powers the CLIP tab in the JUCE plugins and the timelines in `ztranslator` / `Audio-Haxor`. Private — docs vendored to meta. · _{docs · report}
`zmusic`	Play-along instrument trainer for keys, pads and drums (Rust + Tauri v2 desktop app over a C++20 / JUCE 8 audio sidecar) — a Melodics superset that grades you against your own MIDI and audio instead of a closed subscription library: drop in a `.mid`, attach any backing track, and the notes fall toward a judgment line while every hit is scored. Charts are `zpwr-clip-engine` ClipSeq patterns — the same grid and sequencer engine as `zpwr-daw`, not a second note format — and the JUCE sidecar owns the scoring clock so MIDI input and playhead share one process. Ships a bundled `.mid` lesson library whose backing tracks are rendered from the same charts at the same tempo, so audio and grading targets align by construction. Consumes `zmusic-core`. Paid product — in the app-store.
`zmusic-core`	Embeddable play-along trainer engine (pure Rust, no GUI deps) behind `zmusic` — SMF import into a `Chart` that serializes to the same `[{s,l,n,len,v}]` pattern shape `zpwr-clip-engine` already schedules, controller-surface description, and the lesson-library / take-history store. Grading is deliberately excluded: it belongs to the process owning the audio device and MIDI input, so the JUCE sidecar decides every verdict off one clock and this crate holds only the shared vocabulary (`HitWindows` down, `Hit` / `TakeSummary` back up). Imports report what they had to approximate rather than absorbing it silently. Builds `rlib` + `staticlib` + `cdylib` so the same trainer embeds across the GUI stack. Private.
`zpwr-crate`	Shared sample-library "crate" browser (Rust) — one source of truth for the audio stack's filesystem + SQLite/FTS5 sample scanner and faceted crate-query layer (category/pack/manufacturer/BPM/key filters, regex search, facets, incremental rescans). Scanner + schema + query code lifted verbatim from the Audio-Haxor backend with the Tauri glue stripped. Builds `rlib` + `staticlib` + `cdylib`: consumed natively by `Audio-Haxor` and over a C ABI by `zpwr-daw`, so both run identical indexing/browsing against the same schema. Private — internal shared library, not published to crates.io. · _{docs · report}
`zpwr-embed-terminal`	Shared embedded PTY terminal (Rust) — one PTY-backed login-shell terminal (`portable-pty` core + xterm.js front end) extracted from Audio-Haxor so a single source of truth backs every desktop app. Builds `rlib` + `staticlib` + `cdylib`: `Audio-Haxor` / `traderview` / `ztranslator` use it natively (forwarding `on_output`/`on_exit` to `app.emit`), `zpwr-daw` drives it over the C ABI (`include/zpwr_embed_terminal.h`) from JUCE/C++. Private — internal shared library, not published to crates.io. · _{docs · report}
`zwire-host`	Chrome native-messaging host for `zwire` (Rust) — one self-contained ~500 KB binary (no Python/`psutil`) that the `hud-internal` extension talks to over a single length-prefixed-JSON stdio pipe. Bridges the shared color scheme + visual-effect prefs to/from `~/.zwire`, streams live system stats (`sysinfo`: cpu / mem / net / disk / temp / battery / …) for the HUD statusbar, and runs a PTY login shell (`portable-pty`) behind the embedded terminal. Cross-platform (macOS / Linux / Windows). Private — internal shared binary, not published to crates.io. · _{docs · report}
`zpwr-file-browser`	Shared multi-pane file browser (JS front end + Rust `fs` crate) — one source of truth for the file browser across every desktop app, extracted from Audio-Haxor. Host-agnostic front end (`webui/file-browser.{js,css,html}`): multi-pane layout, sortable + resizable columns, fuzzy filter, color labels, tree sidebar, context menu, previews (audio waveform/key/bpm, image/video thumbs, pdf, exif, git status, dedup, diff, grep). Each host supplies the filesystem backend (the `window.vstUpdater` fs-command contract) — `Audio-Haxor` / `traderview` / `ztranslator` as `#[tauri::command]`s, `zpwr-daw` over a C ABI like `zpwr-embed-terminal`. Ships `crate/` — the shared Rust `fs_` backend (core filesystem ops ported verbatim from the Audio-Haxor `src-tauri` layer with the Tauri glue stripped to pure functions). Private* — internal shared library. · _{docs · report}
`zpwr-algo-production`	Algorithmic music-production engine (Rust) — one action generates a complete, professionally-arranged track: song structure + key/tempo, per-section MIDI, and an exported Ableton Live Set (`.als`), with genre engines (trance, …). Ported from the Audio-Haxor `src-tauri` generators with the library-scanner couplings abstracted behind a host-provided sample source. Powers `zpwr-daw`'s one-click production (INVENTIONS #5). Private — docs vendored to meta. · _{docs · report}
`nmaprs`	Rust port of `nmap`. Full async TCP/UDP/SCTP/IP-protocol scans, idle/zombie scans, NSE-style script probes, ARP/ICMP/timestamp/mask host discovery, top-ports list embedded. · _{docs · report}
`powerliners`	Rust CLI — mature port of Python's `powerline-status` (v0.2.16, 3,000+ `#[test]` functions, 5-binary suite: `powerline` / `powerline-daemon` / `powerline-config` / `powerline-render` / `powerline-lint`, parity-tested against upstream Python). Drop-in for tmux / zsh / bash / vim with sub-millisecond render replacing the ~100 ms python startup tax. · _{docs · report}
`zpwr`	The terminal OS. 457 verbs, 192k LOC, zinit-based, stryke-powered. ⭐ 223 · _{docs · report}
`zpdf`	PDF editor replacing Adobe Acrobat + Preview (Rust, Tauri v2 desktop app) — full document editing, annotation/markup, AcroForms, digital & certificate signatures, OCR, redaction, page management, convert/export. Consumes `zpdf-core`. Paid product — in the app-store. · _{docs · report}
`zpdf-core`	Embeddable PDF engine (pure Rust, no GUI deps) — parse / render / edit / annotate / sign / page-ops behind `zpdf`; builds `rlib` + `staticlib` + `cdylib` so it embeds into `traderview` and the other GUI apps (same pattern as `zpwr-embed-terminal`). Ships a source-derived feature port report. Private. · _{docs · report}
`zemail`	Email client (Rust, Tauri v2 desktop app) — a fast, owned desktop mail app behind a cyberpunk HUD. Consumes `zemail-core`. Paid product — in the app-store. · _{docs · report}
`zemail-core`	Embeddable mail engine (pure Rust, no GUI deps) extracted from `zemail` so the same engine embeds across the GUI stack. Private. · _{docs · report}
`zoffice`	Office suite replacing Microsoft Office (Rust, Tauri v2 desktop app) — documents, spreadsheets, presentations. Consumes `zoffice-core`. Paid product — in the app-store. · _{docs · report}
`zphoto`	Photo suite replacing GIMP and Photostop (Rust, Tauri v2 desktop app) — images. Consumes `zphoto-core`. Paid product — in the app-store. · _{docs · report}
`zphoto-core`	Embeddable photo engine (pure Rust, no GUI deps) — images parse + edit, extracted from `zphoto`. · _{docs · report}
`zoffice-core`	Embeddable office engine (pure Rust, no GUI deps) — document / spreadsheet / presentation parse + edit, extracted from `zoffice`. · _{docs · report}
`zstation`	Workspace of isolated web apps replacing Station (Rust, Tauri v2 desktop app) — one window arranges your web apps (Slack, Gmail, Discord, Notion, …) as Trello-like draggable/resizable tiles, each in its own native session-isolated webview so a login never leaks cookies or storage across services. Consumes `zstation-core`. A station.app port plus added features. Paid product — in the app-store. · _{docs · report}
`zstation-core`	Embeddable workspace engine (pure Rust, no GUI deps) behind `zstation` — service catalog, tile board and on-disk persistence behind one JSON command surface, plus a mountable web view. Builds `rlib` + `staticlib` + `cdylib` so the same station board embeds across the GUI stack. Private. · _{docs · report}
`zthrottle`	System stress, contention profiler & monitor (Rust, Tauri v2 desktop app) — disk / network / CPU / memory throughput and IOPS benchmarks behind a cyberpunk HUD, going beyond single-axis tools like Blackmagic Disk Speed Test with a world-first contention profiler: it drives every subsystem at once and reports the interaction matrix + bottleneck-migration timeline (how each axis degrades under load from the others). Plus a full system monitor — processes with signal control, per-interface network history + live flows, and a persistent storage tree (a SQLite directory index built by one full scan, then kept live by filesystem-watch hooks with no re-walk) with junk detection and a "what can I free?" reclaim view. Consumes `zthrottle-core`. Paid product — in the app-store. · _{docs · report}
`zthrottle-core`	Embeddable benchmark engine (pure Rust, no GUI deps) behind `zthrottle` — four real single-axis benchmarks (disk `F_NOCACHE`/`O_DIRECT` throughput+IOPS, loopback/peer network, CPU int/float kernels, memory STREAM+latency) and the correlated multi-axis contention scheduler, behind one JSON command surface. Builds `rlib` + `staticlib` + `cdylib` so the same engine embeds across the GUI stack. Private. · _{docs · report}
`zlatex`	LaTeX editor (Rust, Tauri v2 desktop app) — a Monaco pane on the left, live-typeset pages on the right: preamble, title block, table of contents, numbered sectioning, justified paragraphs broken by TeX's own algorithm, lists, tables, floats, cross-references, citations, bibliography, and math. No TeX distribution is involved — the typesetter is `zlatex-core`, compiled in, fonts included. A document exports as a multi-page PDF carrying its own LaTeX source, so dropping the file back in reopens editable source. Consumes `zlatex-core`. Paid product — in the app-store.
`zlatex-core`	Embeddable LaTeX engine (pure Rust, no GUI deps) behind `zlatex` — TeX's mouth (catcodes, macro expansion), a text-mode grammar producing a document model, Knuth-Plass total-fit line breaking, page building with a second reference-resolving pass, and math-mode box-and-glue layout (`mlist_to_hlist`, the Chapter 18 spacing table, Appendix G placement) with its parameters read from the face's OpenType MATH table instead of TFM fontdimens. Emits the same render-tree shape zoffice draws, plus multi-page PDF and outline-based SVG / PNG export. Builds `rlib` + `staticlib` + `cdylib`. Private.
`ztranslator-core`	Embeddable event-translation engine (pure Rust, no GUI deps) — the real-time MIDI / OSC / DMX / file-watcher routing engine behind `ztranslator`; integer-VM rule matching, BOME `.bmtp` import/export, JSON projects. Builds `rlib` + `staticlib` + `cdylib` so the same routing engine embeds across the GUI stack. · _{docs · report}
`zmax-gui-core`	Embeddable GUI surface for `zmax-gui` (webui-only, all `zgui-core` widgets) — the MacVim-style menu bar, ⌘-shortcuts, Open/Save/Help dialogs and drag-drop that bridge to the `zmax` IDE PTY, extracted from `zmax-gui`. · _{docs · report}
`zcite`	Reference manager replacing Zotero (Rust, Tauri v2 desktop app) — library, collections, tags & saved searches, citations/bibliographies (APA/MLA/Chicago/IEEE), BibTeX/RIS/CSL-JSON import-export, DOI/ISBN/PMID lookup, duplicate detection. Bundles its embeddable pure-Rust `zcite-core` engine (`rlib` + `staticlib` + `cdylib`) so the same reference engine embeds across the GUI stack. A Zotero port plus added features. Paid product — in the app-store. · _{docs · report}
`ztorrent`	BitTorrent client replacing Transmission (Rust, Tauri v2 desktop app) — torrents, files, peers, trackers and labels, a download/seed queue, ratio and idle seeding limits, the alt-speed (turtle) scheduler, blocklists, watch folders, `.torrent` creation and a Transmission RPC surface. Consumes `ztorrent-core`. Paid product — in the app-store. · _{docs · report}
`ztorrent-core`	Embeddable BitTorrent engine (Rust, no GUI deps) behind `ztorrent` — the session model, queue, seeding limits, turtle scheduler, blocklists and watch folders, byte-exact bencode / `.torrent` create-parse, magnet handling and Transmission RPC translation; the wire itself is `librqbit`, behind the default `net` feature. Builds `rlib` + `staticlib` + `cdylib`. Private. · _{docs · report}
`zreq`	API client replacing Postman (Rust, Tauri v2 desktop app) — workspaces, collections, requests, environments, variables, auth, HTTP execution + history, code generation, import/export. Consumes `zreq-core`. A Postman port plus added features. Paid product — in the app-store. · _{docs · report}
`zreq-core`	Embeddable API-client engine (pure Rust, no GUI deps) behind `zreq` — workspaces / collections / requests / environments / auth / HTTP execution / history / codegen / import-export. Builds `rlib` + `staticlib` + `cdylib` so the same request engine embeds across the GUI stack. Private. · _{docs · report}
`ztunnel`	VPN tunnel manager replacing Tunnelblick (Rust, Tauri v2 desktop app) — manage OpenVPN + WireGuard tunnels (configs, connection manager, OpenVPN-process control, logs, stats, credentials) from one owned, cross-platform desktop app, with an embeddable pure-Rust `ztunnel-core` engine. A Tunnelblick port plus added features. Paid product — in the app-store. · _{docs · report}
`ztunnel-core`	Embeddable VPN-tunnel engine (pure Rust, no GUI deps) behind `ztunnel` — OpenVPN-process control + boringtun WireGuard, tunnel/config model, connection manager, logs, stats, credentials, and a privileged-helper boundary. Builds `rlib` + `staticlib` + `cdylib` so the same tunnel engine embeds across the GUI stack. Private. · _{docs · report}
`zgo`	Launcher replacing Alfred (Rust, Tauri v2 desktop app) — workflows (objects + connections), Script Filter feedback (JSON + legacy XML), fuzzy matching, variable/token expansion, web searches, clipboard history, snippets + auto-expansion. Consumes `zgo-core`. An Alfred port plus added features. Paid product — in the app-store. · _{docs · report}
`zgo-core`	Embeddable launcher engine (pure Rust, no GUI deps) behind `zgo` — workflows / Script Filter feedback / fuzzy matching / variable expansion / web searches / clipboard history / snippets. Builds `rlib` + `staticlib` + `cdylib` so the same launcher engine embeds across the GUI stack. Private. · _{docs · report}
`zftp`	File-transfer client replacing Cyberduck (Rust, Tauri v2 desktop app) — bookmarks and connections over FTP/FTPS/SFTP/WebDAV plus S3, GCS, Azure, Backblaze B2, Swift, Google Drive, Dropbox, OneDrive and Box; `.duck` bookmark import; session manager; download/upload/sync transfer queue; per-session logs and throughput; stored credentials. Consumes `zftp-core`. A Cyberduck port plus added features. Paid product — in the app-store. · _{docs · report}
`zftp-core`	Embeddable file-transfer engine (pure Rust, no GUI deps) behind `zftp` — bookmark model, protocol/URL parsing, `.duck` import, session-lifecycle manager, download/upload/sync transfer queue, per-session logs + throughput, a remote-filesystem transport boundary, credentials. Builds `rlib` + `staticlib` + `cdylib` so the same transfer engine embeds across the GUI stack. Private. · _{docs · report}
`zcontainer`	Container & Kubernetes GUI replacing Docker Desktop + Lens (Rust, Tauri v2 desktop app) — Docker containers/images/volumes/networks + Compose stacks; multi-cluster Kubernetes (pods, workloads, services, CRDs, Helm releases); live log streaming, in-pod exec, port-forwarding, YAML editing. Consumes `zcontainer-core`. The first compiled-native desktop GUI for both — every other tool is Electron (Lens/FreeLens/Headlamp) or a TUI (k9s). Paid product — in the app-store. · _{docs · report}
`zcontainer-core`	Embeddable container/k8s engine (pure Rust, no GUI deps) behind `zcontainer` — Docker + Kubernetes resource CRUD, watch streams, logs, exec, port-forward, Compose, Helm. Builds `rlib` + `staticlib` + `cdylib` so the same engine embeds across the GUI stack. Private. · _{docs · report}
`zterminal`	GPU-accelerated terminal emulator (Rust, OpenGL); BSD/Linux/macOS/Windows, sensible defaults, extensive TOML config, high-throughput VTE performance. Native tmux control via the wire protocol (no subprocess), cross-pane search, broadcast, unified exposé, and tmux-resurrect-style session save/restore from the command palette. Paid product — in the app-store. · _{docs · report}
`ztmux-core`	Embeddable native tmux client engine (Rust, no GUI deps) extracted from `zterminal` — speaks tmux's imsg wire protocol straight to the server socket (no `tmux` subprocess): `transport` (raw imsg client), `proc` (per-pane full command line via libproc / `/proc`), `ops` (session tree / cross-pane search / broadcast / send-keys / sync / focus → JSON), and `snapshot` (dir-parameterized resurrect-style session save/restore). Other GUI apps add the submodule + a path dep to get full tmux control. Private. · _{docs · report}
`ztmux`	A Rust port of tmux — the full terminal multiplexer (server + client, grid/screen model, input parser, layouts, command language, formats, tty backend), not a wrapper around the `tmux` binary and not control mode: the multiplexer itself. Seeded from `tmux-rs` and ported forward against the upstream tmux C sources, both vendored read-only under `vendor/`. Distinct from `ztmux-core` (the embeddable wire-protocol client engine). Free / OSS (MIT). · _{docs · report}
`zmax`	Rust Emacs port — a terminal modal IDE with a Vim-style modal editing core and full Spacemacs functionality layered on top; a windowed GUI build ships as `zmax-gui`. Free / OSS (MPL-2.0) — in the app-store.
`zmax-gui`	Native desktop GUI for `zmax` — wraps the zmax modal-editing core in a windowed front-end (GUI tabs, menus, font rendering, mouse, native open/save dialogs), the way MacVim wraps Vim. Free / OSS (MPL-2.0) — in the app-store.

Tier 2 — Stryke ecosystem + tap (34)

MenkeTechnologies distribution (single tap for every CLI tool) + per-service connector libraries for stryke.

Project	What it is
`homebrew-menketech`	Single Homebrew tap for 33 MenkeTechnologies CLI formulas (`arb` / `awkrs` / `elisprs` / `grcrs` / `groovyrs` / `htoprs` / `iftoprs` / `javars` / `kotlinrs` / `lsofrs` / `nmaprs` / `node-js` / `phplang` / `powerliners` / `pythonrs` / `rlang` / `rubylang` / `scalars` / `storageshower` / `stryke` / `tclrs` / `temprs` / `vimlrs` / `zcolorizer` / `zdbview` / `zmax` / `zpwrchrome-host` / `zshrs` / `zshrs-all` / `zshrs-daemon` / `ztmux` / `zvcs` / `zwire-host`). Formulas auto-bumped by each tool's `Release` workflow via `HOMEBREW_TAP_TOKEN`.
`stryke-arrow`	Apache Arrow integration. · _{docs · report}
`stryke-aws`	AWS SDK bindings (S3, EC2, SQS, Lambda, ...). · _{docs · report}
`stryke-azure`	Microsoft Azure SDK bindings. · _{docs · report}
`stryke-clickhouse`	ClickHouse client — SELECT, JSONEachRow insert, DDL, schema introspection over the HTTP interface (port 8123). Pure-Rust `ureq`/rustls, no tokio. · _{docs · report}
`stryke-demo`	Demo scripts + example programs. · _{docs · report}
`stryke-docker`	Docker engine API client. · _{docs · report}
`stryke-duckdb`	DuckDB embedded analytics. · _{docs · report}
`stryke-email`	Email + campaign client — SMTP send, personalized mass mailing with `{{merge}}` templates, List-Unsubscribe + suppression + rate limiting, through your own authenticated SMTP (lettre, rustls, no tokio). · _{docs · report}
`stryke-fleet`	Parallel expect/PTY automation — transcripted sessions, declarative playbooks, recipe corpus for interactive CLIs, multi-host fan-out. Pure stryke, loaded on `use Fleet`. · _{docs · report}
`stryke-gcp`	Google Cloud Platform SDK bindings. · _{docs · report}
`stryke-grpc`	Reflection-based gRPC client — discovers services at call time, so no local `.proto` is needed for the target server. · _{docs · report}
`stryke-gui`	GUI automation bridge — `stryke_gui` cdylib `dlopen`ed in-process on `use GUI`, fronting mouse/keyboard synthesis (enigo) + screen capture (xcap). Persistent `Enigo` handle in `OnceCell`, no fork-per-call. Isolates X11 / Wayland / CGEvent / SendInput linkage out of the stryke core. · _{docs · report}
`stryke-app`	App automation bridge — `stryke_app` cdylib `dlopen`ed in-process on `use App`. Calls a MenkeTechnologies GUI app's verbs, reads its state, and subscribes to its events over the GUI Automation Bus (one Unix socket per app, `zgui-bridge` host); per-app connection pool, no fork-per-call. Semantic counterpart to `stryke-gui` — drives owned apps by name, not by pixel.
`stryke-k8s`	Kubernetes API client. · _{docs · report}
`stryke-kafka`	Kafka producer/consumer (rdkafka bindings). · _{docs · report}
`stryke-mcpd`	MCP servers as single native binaries — validated tool specs, crash-isolated serving, root-jailed stock tool pack. Pure stryke, loaded on `use Mcpd`. · _{docs · report}
`stryke-mongo`	MongoDB driver. · _{docs · report}
`stryke-mssql`	Microsoft SQL Server / Azure SQL client — parametrized query/execute, transaction batches, scalar/exists, schema introspection over tiberius (pure-Rust TDS, blocking facade over tokio). · _{docs · report}
`stryke-mysql`	MySQL/MariaDB driver. · _{docs · report}
`stryke-neo4j`	Neo4j graph client — parametrized Cypher query/run, scalar/row helpers, schema introspection (labels, rel types, indexes, constraints) over Bolt (neo4rs, pure-Rust, blocking facade over tokio). · _{docs · report}
`stryke-office`	Office/ODF/PDF/image import+export — Excel/Word/PowerPoint (xlsx/docx/pptx) + OpenDocument (ods/odt/odp) + PDF + PIL-style images (png/jpeg/gif/bmp/webp/tiff), all native (no LibreOffice). · _{docs · report}
`stryke-parquet`	Apache Parquet read/write. · _{docs · report}
`stryke-polars`	Full pandas + numpy surface — DataFrame/Series/Index/IO + ndarray/ufuncs/linalg/random/fft/polynomial/masked/datetime64 — in one cdylib, `dlopen`ed in-process on `use Polars`. Heavy deps kept out of the stryke core. · _{docs · report}
`stryke-postgres`	PostgreSQL driver. · _{docs · report}
`stryke-redis`	Redis client. · _{docs · report}
`stryke-scrape`	Web scraping / crawling client — fetch, robots-respecting bounded crawl, sitemap discovery, plus pure CSS / table / link / structured-data (JSON-LD, OpenGraph) extraction. · _{docs · report}
`stryke-scylla`	ScyllaDB / Cassandra client — CQL query, DDL, schema introspection over the native binary protocol. Pure-Rust scylla driver on an embedded tokio runtime. · _{docs · report}
`stryke-search`	Elasticsearch / OpenSearch client — index admin, document CRUD, bulk, full query DSL + aggregation builders, scroll/PIT, templates, ingest pipelines, snapshots, cluster/tasks ops. One client for both engines; pure-Rust `ureq`/rustls transport, no JVM. · _{docs · report}
`stryke-selenium`	Selenium WebDriver bindings — browser automation. · _{docs · report}
`stryke-spark`	Apache Spark integration. · _{docs · report}
`stryke-terminal`	Headless VTXXX terminal emulator — a faithful pyte port. Feed raw PTY bytes (from strykelang's built-in `pty_read`) and read the rendered screen: grid, cursor, per-cell colors + attributes, modes, scroll margins, tab stops, charsets, scrollback. cdylib, loaded on first `use Terminal`. · _{docs · report}
`stryke-utils`	Pure stryke library — shared helpers written in stryke itself, no Rust or external deps. · _{docs · report}
`stryke-zmq`	ZeroMQ client — brokerless req/rep, pub/sub, push/pull, dealer/router. cdylib with libzmq vendored. · _{docs · report}

Tier 3 — zsh-more-completions (1)

Project What it is

zsh-more-completions 47,393-completion zsh corpus (8,360 src/ + 34,547 more_src/–more_src8/ + 3,398 man_src/ + 1,067 architecture_src/ + 21 override_src/; counts _* completion functions only — produced by scripts/print-repo-stats.zsh). ⭐ 56. The largest curated completion collection in existence. Lives outside Tier 1 because it's data + completion functions, not an executable. · _{docs · report}

Project	What it is
`zsh-more-completions`	47,393-completion zsh corpus (8,360 `src/` + 34,547 `more_src/`–`more_src8/` + 3,398 `man_src/` + 1,067 `architecture_src/` + 21 `override_src/`; counts `_*` completion functions only — produced by `scripts/print-repo-stats.zsh`). ⭐ 56. The largest curated completion collection in existence. Lives outside Tier 1 because it's data + completion functions, not an executable. · _{docs · report}

Tier 4 — Zsh ecosystem plugins (28)

The plugin family that zpwr and any zsh user can load via zinit / oh-my-zsh. The full ZPWR_GH_PLUGINS canonical list plus the legacy zsh-* family.

Project	What it is
`zsh-expand`	Expand aliases / global aliases / typos on space. ⭐ 44. · _{docs · report}
`zsh-cargo-completion`	Cargo completion. ⭐ 36. · _{docs · report}
`zsh-learn`	MySQL/MariaDB-backed learning collection — save, query, quiz. ⭐ 9. · _{docs · report}
`zsh-git-acp`	`git add commit push` in one keybinding. ⭐ 7. · _{docs · report}
`zsh-better-npm-completion`	Better npm completion. · _{docs · report}
`zsh-cpan-completion`	CPAN completion. · _{docs · report}
`zsh-dotnet-completion`	.NET completion. · _{docs · report}
`zsh-gem-completion`	Ruby gem completion. · _{docs · report}
`zsh-git-repo-cache`	Git repo cache helper. · _{docs · report}
`zsh-nginx`	nginx config completion. · _{docs · report}
`zsh-pip-description-completion`	pip completion with package descriptions. · _{docs · report}
`zsh-sed-sub`	sed substitution helper. · _{docs · report}
`zsh-sudo`	`Esc Esc` to prepend `sudo` to the current line. · _{docs · report}
`zsh-xcode-completions`	Xcode CLI tools completion. · _{docs · report}
`zsh-docker-aliases`	Docker aliases + functions.
`zsh-openshift-aliases`	52 `oc`-* aliases + login macros (`ocdev`, `ocqa`) + auto-sourced `oc` completion. · _{docs · report}
`zsh-travis`	`tg`/`tb`/`tbr`/`tpr` — open Travis CI build pages from inside the project. · _{docs · report}
`zsh-very-colorful-manuals`	Neon-tints `man` page output via `LESS_TERMCAP_*` env. · _{docs · report}
`zsh-z`	`z <dir>` — frecency-jump to recently visited directories.
`zsh-zinit-final`	Empty-by-design latch for zinit `atinit` / `atload` ices that need to fire after every other plugin.
`fasd-simple`	Frecency `cd` / file picker. v1.0.x cleanup of the original `fasd`.
`fzf-tab`	Replace zsh's default tab completion with fzf.
`fzf-zsh-plugin`	fzf-shipped zsh keybindings + completion + history search.
`gh_reveal`	`reveal` — open the current git project in the default browser.
`jhipster-oh-my-zsh-plugin`	JHipster CLI completion + aliases.
`kubectl-aliases`	790 `kubectl` aliases (kg=get, kgp=get-pods, …).
`revolver`	Spinner / progress widget for zsh scripts.
`zunit`	Powerful zsh unit-testing framework.

Tier 5 — Editor / multiplexer plugins (20)

Plugins that target Vim/Neovim and tmux rather than zsh proper.

Project	What it is
`VimColorSchemes`	732 hand-curated Vim colorschemes packaged as a single Pathogen / vim-plug / lazy.nvim bundle. The largest one-bundle scheme collection. · _{docs · report}
`vim-stryke`	Vim / Neovim support for the stryke language — `*.stk` + shebang filetype detection, a standalone stryke syntax grammar generated from the stryke binary's own reflection tables (all 10,488 builtins, 90 keywords, 39 parallel primitives, sigils / regex / thread macros), brace-aware indentation, ALE linting via `stryke --lint`, and LSP (vim-lsp / coc.nvim) via `stryke --lsp`. Pathogen / vim-plug / native-package install. · _{docs · report}
`vscode-stryke`	VS Code / VSCodium extension for the stryke language — `*.stk` filetype detection, a stryke-native TextMate grammar generated from the stryke binary's reflection tables (the complete builtin surface), and LSP via `stryke --lsp`. · _{docs · report}
`emacs-stryke`	`stryke-mode` for Emacs — a generated `stryke-stdlib.el` carrying the complete language surface (all 10,488 builtins + 39 parallel primitives) pulled from the stryke binary's own reflection tables. Stored as hash tables matched by a font-lock function (a single `regexp-opt` over 10,488 names overflows Emacs' regexp compiler), plus brace indent and LSP via `stryke --lsp` (eglot + lsp-mode). Regenerate after a stryke upgrade via `scripts/gen-stdlib.sh`. · _{docs · report}
`vim-zsh`	Vim / Neovim support for the `zshrs` shell — `*.zsh` / dotfile / shebang filetype detection (`filetype=zshrs`), a standalone grammar generated from `zshrs --dump-reflection` (137 builtins, 113 zshrs extensions on their own highlight group, 245 special vars, control + decl keywords), shell-block-aware indent, ALE via `zshrs -n`, and LSP (vim-lsp / coc.nvim) via `zshrs --lsp`. · _{docs · report}
`vscode-zsh`	VS Code / VSCodium support for `zshrs` — a `source.zshrs` TextMate grammar generated from `zshrs --dump-reflection` (137 builtins, 113 zshrs extensions on their own scope, 245 special vars), `*.zsh` / dotfile / shebang detection, and LSP via `zshrs --lsp`. · _{docs · report}
`emacs-zsh`	`zshrs-mode` for Emacs — font-lock generated from `zshrs --dump-reflection` (137 builtins, 113 zshrs extensions via a dedicated `zshrs-extension-face`, 245 special vars), shell-block-aware indent, and LSP via `zshrs --lsp` (eglot + lsp-mode). Regenerate via `scripts/gen-stdlib.sh`. · _{docs · report}
`vscode-awk`	VS Code / VSCodium extension for AWK (`awkrs`) — `*.awk` filetype detection, a hand-written `source.awk` TextMate grammar (`BEGIN`/`END`, control keywords, built-in vars + functions, field refs, `/regex/` literals), an `awk.run` command, LSP via `awkrs --lsp`, and DAP debugging via `awkrs --dap`. · _{docs · report}
`vim-awk`	Vim / Neovim support for AWK (`awkrs`) — `*.awk` filetype detection, syntax + brace-aware indent, run / `:make` via `awkrs`, and LSP via `awkrs --lsp`. · _{docs · report}
`emacs-awk`	`awkrs-mode` for Emacs — font-lock for AWK (keywords, built-in vars/functions, field refs, `/regex/`), indent, run via `awkrs`, eldoc + completion from a built-in-function stdlib, and LSP via `awkrs --lsp` (eglot + lsp-mode). · _{docs · report}
`vscode-viml`	VS Code / VSCodium extension for VimL / Vimscript (`vimlrs`) — `*.vim` + `vimrc` / `gvimrc` / `init.vim` filetype detection, a hand-written `source.viml` TextMate grammar (control keywords, ex commands, scope sigils `g:` / `s:` / `v:`, built-in functions, both string forms), a `vim.run` command, LSP via `vimlrs --lsp`, and DAP debugging via `vimlrs --dap`. · _{docs · report}
`vim-viml`	Vim / Neovim support for VimL / Vimscript (`vimlrs`) — `*.vim` + `vimrc` / `gvimrc` / `init.vim` filetype detection, syntax + keyword-aware indent, run / `:make` (`:VimlRun`) via `vimlrs`, ALE linting, and LSP via `vimlrs --lsp` (vim-lsp / coc.nvim) plus nvim-dap via `vimlrs --dap`. · _{docs · report}
`emacs-viml`	`vimlrs-mode` for Emacs — font-lock for VimL / Vimscript (keywords, ex commands, scope + special `v:` vars, built-in functions), keyword-aware indent, run via `vimlrs`, eldoc + completion from a built-in-function stdlib, and LSP via `vimlrs --lsp` (eglot + lsp-mode). · _{docs · report}
`vscode-arb`	VS Code / VSCodium extension for arb — the pipe-native TUI/web dashboard language (jq/xpath/css/yq superset on `fusevm`/JIT). `*.arb` filetype detection, a `source.arb` TextMate grammar (keywords, widgets, query verbs, input sources, regex + duration/size literals, widget paths, flags), an `arb.run` command, LSP via `arb --lsp`, and DAP debugging via `arb --dap`. · _{docs · report}
`vim-arb`	Vim / Neovim support for arb — `*.arb` filetype detection, syntax + brace-aware indent, run / `:make` via `arb`, ALE linting, and LSP via `arb --lsp` (vim-lsp / coc.nvim) plus nvim-dap via `arb --dap`. · _{docs · report}
`emacs-arb`	`arb-mode` for Emacs — font-lock for arb (keywords, widgets, query verbs, input sources, regex + duration/size literals), indent, run via `arb`, eldoc + completion from a built-in stdlib, and LSP via `arb --lsp` (eglot + lsp-mode). · _{docs · report}
`vscode-elisp`	VS Code / VSCodium extension for Emacs Lisp (`elisprs`) — `*.el` filetype detection, a `source.elisp` TextMate grammar (special forms, built-in functions, keyword symbols, char literals, quoting), an `elisp.run` command, LSP via `elisp --lsp`, and DAP debugging via `elisp --dap`. · _{docs · report}
`vim-elisp`	Vim / Neovim support for Emacs Lisp (`elisprs`) — `*.el` filetype detection, syntax + paren-aware indent, run / `:make` via `elisp`, ALE linting, and LSP via `elisp --lsp` (vim-lsp / coc.nvim) plus nvim-dap via `elisp --dap`. · _{docs · report}
`emacs-elisp`	`elisprs-mode` for Emacs — font-lock for Emacs Lisp via `elisprs` (special forms, built-in functions, keyword symbols, char literals, quoting), paren-aware indent, run via `elisp`, eldoc + completion from a built-in stdlib, and LSP via `elisp --lsp` (eglot + lsp-mode). · _{docs · report}
`tmux-fzf-url`	Pop a fzf picker over every URL currently visible in the tmux pane; selected URL opens in the default browser.

Tier 6 — Apps, extensions, web & web-APIs (23)

Browser extensions, supporting apps, audio plugins, public website, storefront, and web-API services. (Tauri v2 desktop GUI apps traderview and Audio-Haxor live in Tier 1; the powerliners CLI port lives in Tier 1 too.)

Project	What it is
`zwire`	A Chromium superset in the cyberpunk HUD, via two build paths. Default is a runtime rebrand (no compile): preloads the `zpwrchrome` power-tool, HUD chrome colors, and a HUD new-tab page on a pinned unbranded Chromium snapshot (no Google branding, no "for automated testing" banner; it keeps the `--load-extension` switch dropped from branded Chrome 137+), launched against a dedicated `~/.zwire` profile; `scripts/rebrand-macos.sh` patches the base bundle's Dock name + icon in place. Optional source fork (`fork/`, compiles Chromium) takes the HUD into the whole chrome — tab shapes, UI fonts, neon toolbar. Reuses `zpwrchrome` as a submodule. MIT. · _docs
`zpwrchrome`	Browser power-tool: UNIX `pass` integration, segmented multi-connection download manager (default Chrome takeover), JetBrains-style tab switcher with cross-window MRU + scenes + opener-tree + minimap, fzf history search, Tampermonkey-equivalent userscripts, full-page screenshot, Wappalyzer-compatible tech detection, cyberpunk page-theme injector, Turn Off the Lights cinema dimmer, reader mode, post-download custom commands, JSON viewer, UA switcher, find-in-all-tabs. Manifest V3, 54 commands (4 default-keyed + 50 user-bindable). Ships a companion Chrome theme + the native messaging host `zpwrchrome-host` (the Rust port of browserpass-native + the segmented downloader + `run.spawn` for post-download commands) — installable via `brew install zpwrchrome-host` from the `homebrew-menketech` tap. · _{docs · report}
`storageshower`	Disk-usage TUI in Rust (sibling to iftoprs). Walks a directory tree, presents space-by-folder with sort + drill-down.
`zpwr-jobs`	CLI job-application pipeline manager — tracks job postings, resumes, and cover letters through an application workflow. Private — docs vendored to meta. · _{docs · report}
`MenkeTechnologies.github.io`	Public-facing personal site / project landing page (cyberpunk HUD, static HTML + CSS).
`api-rest-generator`	Web-API codegen tool. Rust port (v0.2.0+) of the original Kotlin Spring-Boot-REST-API generator — feed it MySQL / PostgreSQL / SQLite / MSSQL DDL, get a fully wired Spring Boot REST backend (entities, controllers, DAOs, repositories) in Java / Kotlin / Groovy. Kotlin source preserved under `src/main/kotlin/` for reference. · _{docs · report}
`LearningCollectionAPI`	Web API. Java/Kotlin Spring Boot REST service — backing service for the `zsh-learn` plugin (save / query / quiz / search vocabulary cards over HTTP). · _{docs · report}
`zpwr-synth`	World first — part of the first fully-modular patch-graph audio plugin quartet (with `zpwr-daw`) to pair free patch-graph wiring with a no-cable knob panel, one-click EZ auto-wiring, and stereo-mirror + offset-preserving stereo link. JUCE software synthesizer (C++). Fully modular patch-graph instrument on the shared `zpwr-patch-core` engine, modeled on SynthMaster 3 — Instrument → Layer[16] → Voice where each voice is a free patch graph of 299 voice modules (VA/wavetable/FM/additive/supersaw/Karplus oscillators, filters, ADSR/LFO/S&H, VCA), plus a master + unlimited-aux FX-bus rack running the shared 4,238-module audio pack. A PERFORM stage (4-corner preset morph, an Omnisphere-style Orb with motion record/loop, XY macro pads, scene snapshots, randomize, scale/chord keyboard, arp+latch), Stereo + Stereo Lock chain mirroring, and MIDI Program/Bank-Change response toggles round it out. DSP core is a pure-C++ static lib (no JUCE dep, headless-unit-testable). Builds VST3 / AU / CLAP / Standalone on macOS (ARM/Intel) + Linux (x86_64/aarch64). Paid product — docs vendored locally. · _{docs · report}
`zpwr-fx`	World first — part of the first fully-modular patch-graph audio plugin quartet (with `zpwr-daw`) to pair free patch-graph wiring with a no-cable knob panel, one-click EZ auto-wiring, and stereo-mirror + offset-preserving stereo link. JUCE fully modular multi-effects plugin (C++). A free patch graph on the shared `zpwr-patch-core` engine — wire 4,238 DSP modules (incl. 194 analog-circuit models) into your own algorithm, with a per-param mod matrix, unlimited layers, and EZ-wire auto-routing. Not a fixed slot rack. Adds Stereo + Stereo Lock mirroring, a PERFORM stage (preset morph, Orb motion record/loop, XY macros, snapshots, randomize), and MIDI Program/Bank-Change toggles. Builds VST3 / AU / CLAP / Standalone. Paid product — docs vendored locally. · _{docs · report}
`zpwr-midi-fx`	World first — part of the first fully-modular patch-graph audio plugin quartet (with `zpwr-daw`) to pair free patch-graph wiring with a no-cable knob panel, one-click EZ auto-wiring, and stereo-mirror + offset-preserving stereo link. JUCE fully modular MIDI-effects plugin — companion to `zpwr-fx`, the same free patch-graph engine instantiated on the note stream: 66 note-stream modules (arpeggiation / chord / scale / Euclidean+generative seq / humanize / transform), per-param mod matrix, EZ-wire. Shares the PERFORM stage (preset morph, Orb, XY macros, snapshots), Stereo + Stereo Lock, and MIDI Program/Bank-Change toggles. Builds VST3 / AU / CLAP / Standalone. Paid product — docs vendored locally. · _{docs · report}
`zpwr-patch-core`	Signal-agnostic modular patch graph (C++20, depends on `juce_core`). The shared cable-routing core behind the plugin stack — owns what's identical in every modular plugin (patch graph, soft knobs, shared WebEditor, patch versioning/migration) and knows nothing about audio or MIDI. Reused by `zpwr-fx`, `zpwr-synth`, and `zpwr-midi-fx`. Private — part of the paid audio stack. · _{docs · report}
`zpwr-hooks-editor`	Shared stryke Hooks code editor (JS) — a Monaco editor (+ monaco-vim, monaco-emacs, and a thin stryke-LSP adapter) esbuild-bundled into vendored IIFE artifacts (`hooks-editor.bundle.{js,css}` + `hooks-editor.worker.js`). Extracted from Audio-Haxor so the editor is single-sourced instead of duplicated across apps. Build-on-each-consumer: the bundler reads `src/` from this repo but resolves `monaco-` from the consuming app's `node_modules` and writes into its `frontend/lib/`. Consumed by all four apps — `Audio-Haxor`, `traderview`, `ztranslator` (Tauri, at `crates/`) and `zpwr-daw` (JUCE WebView, at `libs/`). Private* — internal shared component. · _{docs · report}
`zpwr-modal-editor`	Shared modal-editing editor (TypeScript) — one Vim/Emacs modal-editing surface for every GUI app. The Vim and Emacs engines are vendored from `monaco-vim` / `monaco-emacs` and adapted behind a thin surface adapter so the editor drops into any app (word / ppt / …) regardless of its host. esbuild-bundled to a vendored IIFE (`window.ZModal`); `monaco-editor` is a peer dependency resolved from the consuming app. Sibling to `zpwr-hooks-editor` — that one is the stryke-LSP code editor, this one is the reusable modal-key layer. MIT — shared component. · _{docs · report}
`zpwr-i18n`	Shared i18n runtime (JS) — one portable internationalization runtime shared across all four GUI apps, extracted from Audio-Haxor. Host-agnostic: catalogs load from JSON files (not Audio-Haxor's SQLite/Tauri loader), so the same code runs in Tauri apps and JUCE WebViews. Flat `{ "namespace.key": "string with {vars}" }` catalogs, one JSON per locale, 27 supported UI locales; shared components (e.g. `zpwr-file-browser`) ship their own per-locale fragment that the host merges in via `extraBases`. API on `window` — `appFmt`/`toastFmt`/`t` (interpolate + missing-key fallback to the key), `applyUiI18n`, `loadLocale`, `bootI18n`, `mergeI18nCatalog`. Private — internal shared component. · _{docs · report}
`zpwr-clip-engine`	Shared DAW arranger/sequencer frontend (JS) — the canvas clip-grid + swappable domains (arranger, piano-roll, session launcher, automation lanes) plus the clip palette, MIDI export, and project/bank serialization, extracted from `zpwr-daw` so every GUI app embeds one arranger through a single `initClipSeq({ nf, getCAT })` entry point. `zpwr-daw` (JUCE/C++) supplies a native audio backend; the synth / fx / midi-fx apps use the bundled non-audio JS backend (`window.makeBasicClipBackend()`). Private — internal shared component.
`zgui-core`	Shared cyberpunk GUI toolkit (JS) — one canonical implementation of the shell, settings, dialog, table, command-palette, fzf matcher, colorscheme builder and notification chrome (namespace `window.ZGui`) so the GUI apps (`Audio-Haxor`, `traderview`, `ztranslator`, `zpdf`, `zemail`, `zoffice`, `zreq`, `ztunnel`, `zgo`, …) stop drifting their own divergent copies. Host-agnostic webui modules extracted from the apps themselves (Audio-Haxor, zreq, `zpwr-patch-core`); consume like `zpwr-i18n` / `zpwr-file-browser` — add as a submodule and copy `webui/` into `frontend/` at build time. Private* — internal shared component. · _{docs · report}
`zgui-bridge`	GUI Automation Bus socket host (Rust) — the local Unix-socket host that lets `stryke` scripts drive every GUI app: an app calls `serve(app, handler)` and `zgui-bridge` opens a per-app socket routing `call` / `get` / `verbs` / `subscribe` frames to the app's automation surface (in-process or from the shell). Foundational crates only (`serde`), no async runtime; see `GUI_AUTOMATION_BUS.md`. Private — internal shared component.
`zdsp-core`	Shared real-time audio DSP engine (C++, header-only, JUCE-based) — the audio-stack analog of `zgui-core`: one implementation of the core DSP units + playback pipeline, vendored by every audio app instead of each re-deriving its own. Seven verbatim-ported units on `zdsp::core`: `OlaTimeStretch` (+ `SpeedMode` — Hann-windowed overlap-add time-stretch, speed without pitch shift), `channel_strip` (lock-free 3-band IIR EQ + gain/pan via RT-safe `DspAtomics`), `ToneAudioSource` (sine test-tone), `InputPeakCallback` (input peak meter), `computeSpectrogramGrid` (offline STFT → dBFS grid, the DSP half of `ZGui.viz`), `LockFreeStreamSource` (RT-safe streaming + glitch-free stream→RAM hot-swap), and `DspStereoFileSource` (the transport-ready playback orchestrator composing all of the above, with an app-implemented `InsertChain` for the plugin rack). Consumers `add_subdirectory(zdsp-core)` and link `zdsp::core`; JUCE (`juce_audio_basics` + `juce_core`) must already be present — the library does not fetch JUCE itself. Consumed by `Audio-Haxor`, `zpwr-patch-core`, and the plugin apps (`zpwr-daw` / `zpwr-synth` / `zpwr-fx` / `zpwr-midi-fx`). Paid product — proprietary (`UNLICENSED`), part of the paid audio stack. · _{docs · report}
`zpwr-theme`	Cyberpunk HUD color theme for VS Code + JetBrains — the Strykelang HUD palette (deep-space ink `#05050a`, neon cyan `#05d9e8`, magenta scanlines `#d300c5`) shared with `zpwrchrome`, `zpwr`, and the docs design system, packaged for both editor families from one `PALETTE.md`. `vscode/` ships a `contributes.themes` extension with full workbench + token colors (stryke sigils / `~>` threading / parallel builtins get the magenta accent); `jetbrains/` ships a UI theme + matching editor color scheme with a dependency-free `zip`-only packager (no Gradle/SDK). Companion to `vscode-stryke`.
`app-store`	Static storefront (HTML/CSS/JS) for the entire MenkeTechnologies catalog — 250 products across 11 categories: paid desktop apps & plugins (`zmusic`, `zpdf`, `zemail`, `zoffice`, `zcite`, `zreq`, `ztunnel`, `zgo`, `zftp`, `zcontainer`, `zterminal`, `Audio-Haxor`, `traderview`, `ztranslator`, `zpwr-daw`, `zpwr-synth`, `zpwr-fx`, `zpwr-midi-fx`, licensed per major version) plus every free/OSS repo (`zshrs`, `stryke`, `zmax`, the Rust CLI tools, the stryke package ecosystem, the zsh-plugin family) with GitHub download links (`releases/latest` or `/tags`). Shopify-style checkout, search + category filters, live catalog stats. Shares the strykelang-docs HUD design system; no build step; dependency-free `node:test` suite + CI. · _{store · docs · report}
`zpwr-license`	Offline-first software licensing for the paid catalog (PRIVATE). Ed25519-signed license keys, an issuer CLI, and an optional self-hosted activation server. Verification runs offline in the binary (kills keygens, works air-gapped); offline node-locking binds a key to a machine with no server (anti-sharing); online activation adds live seats + revocation. Embedded anti-tamper layer (debugger / injection / self-binary-signature / key-substitution / clock-rollback checks) with obfuscated strings + symbols. Rust workspace (`license-core` + `license-cli` + `license-server`), no licensing SaaS. Private — anti-piracy infrastructure.
`zpwr-account`	Accounts + subscriptions + device activation for the paid catalog (PRIVATE) — the stateful commercial layer on top of `zpwr-license`'s offline crypto core. Axum + PostgreSQL service (`account-db` / `account-server` / `account-client` crates) serving a portal API, a device-activation API (`/v1/activate` · `/validate` · `/deactivate` · `/crl`), an admin API and a static ZGui portal. Two-key design: the license issuer key stays offline in the `zpwr-license` CLI and a separate entitlement key signs the short-lived machine-bound entitlements subscribers receive, so a breach of the online service can never mint a license. `account-client` is the gate every paid app links — offline entitlement verification, background refresh, offline grace, run-or-lock. Private — commercial infrastructure.
`MenkeTechnologiesPublications`	Paid publications (PRIVATE). The companion books, reference manuals/PDFs, and the zpwr encyclopedia for `strykelang`, `zshrs`, and `zpwr`, plus their generation pipeline (pandoc + LaTeX). Self-contained: vendors the public source repos as `src/` submodules and builds each book from that source; the free public docs sites stay in each product's own repo. Private — paid product.

Tier 7 — znative plugins (9)

Classic zsh utilities ported to native zshrs plugins — compiled Rust cdylibs loaded at runtime with zmodload -R against the crates.io znative SDK, installed via the znative package manager. Not sourced shell functions parsed on every startup — compiled builtins. All Free / OSS (MIT).

Project	What it is
`zshrs-forgit`	forgit — the interactive `git` + `fzf` utility (add, log, diff, stash) — ported to a native `zshrs` plugin: compiled Rust builtins in a `cdylib`, not sourced functions.
`zshrs-git-fuzzy`	`git-fuzzy` (the fzf-driven `git` UI) status view ported to a native `zshrs` plugin.
`zshrs-git-repos`	`zsh-git-repo-cache` ported to a native `zshrs` plugin — parallel clean/dirty scan across every tracked repo.
`zshrs-revolver`	`revolver` (the reusable progress-spinner / status-line utility) ported to a native `zshrs` plugin.
`zshrs-kubectl-completion`	`kubectl` completion as a native `zshrs` plugin — delegates to `kubectl __complete` for live, version-accurate completions.
`zshrs-zsh-z`	`zsh-z` — the frecency directory jumper — ported to a native `zshrs` plugin.
`zshrs-fasd`	`fasd` (frecency over files and directories — `a`/`s`/`d`/`f`/`j`/`v`) ported to a native `zshrs` plugin; regex + fuzzy matching and frecency scoring reimplemented in Rust.
`zshrs-reveal`	`reveal` — open the current repo's GitHub / Heroku pages in the browser — ported to a native `zshrs` plugin.
`zshrs-zwire`	The `zwire` browser's automation bus as compiled builtins — tabs, windows, tiling, the live page as typed state, hooks, transactions and the pub/sub bus, spoken over `zwire-host`'s local socket with no `curl` and no client library.

[0x02] CI STATUS BOARD

Live GitHub Actions status for every submodule in one table — scan the whole org from one page; the Tier column matches the submodule map. CI badges pin each repo's default branch; Release badges show the latest tag-triggered run; Version badges show each repo's latest semver tag (live from shields.io, linked to the repo's tags page). — = no workflow / no tags yet, or a private repo (paid products have no public Actions runs, badges, or tags). The board is generated from .gitmodules + each repo's active workflow list (gh api repos/MenkeTechnologies/<repo>/actions/workflows).

Tier	Repo	CI	Release	Version
1 — Core	`strykelang`
1 — Core	`zshrs`
1 — Core	`fusevm`		—
1 — Core	`lsofrs`
1 — Core	`temprs`
1 — Core	`awkrs`
1 — Core	`vimlrs`
1 — Core	`elisprs`
1 — Core	`rubylang`
1 — Core	`rlang`
1 — Core	`arb`
1 — Core	`pythonrs`
1 — Core	`phplang`
1 — Core	`node-js`
1 — Core	`javars`
1 — Core	`kotlinrs`
1 — Core	`scalars`
1 — Core	`groovyrs`
1 — Core	`go-rs`
1 — Core	`tclrs`
1 — Core	`texrs`
1 — Core	`zvcs`
1 — Core	`iftoprs`
1 — Core	`htoprs`
1 — Core	`zcolorizer`
1 — Core	`grcrs`
1 — Core	`zdbview`
1 — Core	`ztranslator`	—	—	—
1 — Core	`Audio-Haxor`	—	—	—
1 — Core	`traderview`	—	—	—
1 — Core	`zpwr-daw`	—	—	—
1 — Core	`zmusic`	—	—	—
1 — Core	`zmusic-core`	—	—	—
1 — Core	`zpwr-crate`	—	—	—
1 — Core	`zpwr-embed-terminal`	—	—	—
1 — Core	`zwire-host`
1 — Core	`zpwr-file-browser`	—	—	—
1 — Core	`zpwr-algo-production`	—	—	—
1 — Core	`nmaprs`
1 — Core	`powerliners`
1 — Core	`zpwr`		—
1 — Core	`zpdf`	—	—	—
1 — Core	`zpdf-core`	—	—	—
1 — Core	`zemail`	—	—	—
1 — Core	`zemail-core`	—	—	—
1 — Core	`zoffice`	—	—	—
1 — Core	`zphoto`	—	—	—
1 — Core	`zphoto-core`	—	—	—
1 — Core	`zoffice-core`	—	—	—
1 — Core	`zstation`	—	—	—
1 — Core	`zstation-core`	—	—	—
1 — Core	`zthrottle`	—	—	—
1 — Core	`zthrottle-core`	—	—	—
1 — Core	`zlatex`	—	—	—
1 — Core	`zlatex-core`	—	—	—
1 — Core	`ztranslator-core`	—	—	—
1 — Core	`zmax-gui-core`	—	—	—
1 — Core	`zcite`	—	—	—
1 — Core	`ztorrent`	—	—	—
1 — Core	`ztorrent-core`	—	—	—
1 — Core	`zreq`	—	—	—
1 — Core	`zreq-core`	—	—	—
1 — Core	`ztunnel`	—	—	—
1 — Core	`ztunnel-core`	—	—	—
1 — Core	`zgo`	—	—	—
1 — Core	`zgo-core`	—	—	—
1 — Core	`zftp`	—	—	—
1 — Core	`zftp-core`	—	—	—
1 — Core	`zcontainer`	—	—	—
1 — Core	`zcontainer-core`	—	—	—
1 — Core	`zterminal`	—	—	—
1 — Core	`ztmux-core`	—	—	—
1 — Core	`ztmux`
1 — Core	`zmax`
1 — Core	`zmax-gui`	—
2 — Stryke ecosystem + tap	`homebrew-menketech`		—
2 — Stryke ecosystem + tap	`stryke-arrow`
2 — Stryke ecosystem + tap	`stryke-aws`
2 — Stryke ecosystem + tap	`stryke-azure`
2 — Stryke ecosystem + tap	`stryke-clickhouse`
2 — Stryke ecosystem + tap	`stryke-demo`		—
2 — Stryke ecosystem + tap	`stryke-docker`
2 — Stryke ecosystem + tap	`stryke-duckdb`
2 — Stryke ecosystem + tap	`stryke-email`
2 — Stryke ecosystem + tap	`stryke-fleet`
2 — Stryke ecosystem + tap	`stryke-gcp`
2 — Stryke ecosystem + tap	`stryke-grpc`
2 — Stryke ecosystem + tap	`stryke-gui`
2 — Stryke ecosystem + tap	`stryke-app`	—
2 — Stryke ecosystem + tap	`stryke-k8s`
2 — Stryke ecosystem + tap	`stryke-kafka`
2 — Stryke ecosystem + tap	`stryke-mcpd`
2 — Stryke ecosystem + tap	`stryke-mongo`
2 — Stryke ecosystem + tap	`stryke-mssql`
2 — Stryke ecosystem + tap	`stryke-mysql`
2 — Stryke ecosystem + tap	`stryke-neo4j`
2 — Stryke ecosystem + tap	`stryke-office`
2 — Stryke ecosystem + tap	`stryke-parquet`
2 — Stryke ecosystem + tap	`stryke-polars`
2 — Stryke ecosystem + tap	`stryke-postgres`
2 — Stryke ecosystem + tap	`stryke-redis`
2 — Stryke ecosystem + tap	`stryke-scrape`
2 — Stryke ecosystem + tap	`stryke-scylla`
2 — Stryke ecosystem + tap	`stryke-search`
2 — Stryke ecosystem + tap	`stryke-selenium`
2 — Stryke ecosystem + tap	`stryke-spark`
2 — Stryke ecosystem + tap	`stryke-terminal`
2 — Stryke ecosystem + tap	`stryke-utils`
2 — Stryke ecosystem + tap	`stryke-zmq`
3 — zsh-more-completions	`zsh-more-completions`		—
4 — Zsh ecosystem plugins	`zsh-expand`		—
4 — Zsh ecosystem plugins	`zsh-cargo-completion`		—
4 — Zsh ecosystem plugins	`zsh-learn`		—
4 — Zsh ecosystem plugins	`zsh-git-acp`		—
4 — Zsh ecosystem plugins	`zsh-better-npm-completion`		—
4 — Zsh ecosystem plugins	`zsh-cpan-completion`		—
4 — Zsh ecosystem plugins	`zsh-dotnet-completion`		—
4 — Zsh ecosystem plugins	`zsh-gem-completion`		—
4 — Zsh ecosystem plugins	`zsh-git-repo-cache`		—
4 — Zsh ecosystem plugins	`zsh-nginx`		—
4 — Zsh ecosystem plugins	`zsh-pip-description-completion`		—
4 — Zsh ecosystem plugins	`zsh-sed-sub`		—
4 — Zsh ecosystem plugins	`zsh-sudo`		—
4 — Zsh ecosystem plugins	`zsh-xcode-completions`		—
4 — Zsh ecosystem plugins	`zsh-docker-aliases`		—
4 — Zsh ecosystem plugins	`zsh-openshift-aliases`		—
4 — Zsh ecosystem plugins	`zsh-travis`		—
4 — Zsh ecosystem plugins	`zsh-very-colorful-manuals`		—
4 — Zsh ecosystem plugins	`zsh-z`		—
4 — Zsh ecosystem plugins	`zsh-zinit-final`		—
4 — Zsh ecosystem plugins	`fasd-simple`		—
4 — Zsh ecosystem plugins	`fzf-tab`		—
4 — Zsh ecosystem plugins	`fzf-zsh-plugin`		—
4 — Zsh ecosystem plugins	`gh_reveal`		—
4 — Zsh ecosystem plugins	`jhipster-oh-my-zsh-plugin`		—
4 — Zsh ecosystem plugins	`kubectl-aliases`		—
4 — Zsh ecosystem plugins	`revolver`		—
4 — Zsh ecosystem plugins	`zunit`		—
5 — Editor / multiplexer plugins	`VimColorSchemes`		—
5 — Editor / multiplexer plugins	`vim-stryke`		—
5 — Editor / multiplexer plugins	`vscode-stryke`		—
5 — Editor / multiplexer plugins	`emacs-stryke`		—
5 — Editor / multiplexer plugins	`vim-zsh`		—
5 — Editor / multiplexer plugins	`vscode-zsh`		—
5 — Editor / multiplexer plugins	`emacs-zsh`		—
5 — Editor / multiplexer plugins	`vscode-awk`		—
5 — Editor / multiplexer plugins	`vim-awk`		—
5 — Editor / multiplexer plugins	`emacs-awk`		—
5 — Editor / multiplexer plugins	`vscode-viml`		—
5 — Editor / multiplexer plugins	`vim-viml`		—
5 — Editor / multiplexer plugins	`emacs-viml`		—
5 — Editor / multiplexer plugins	`vscode-arb`		—
5 — Editor / multiplexer plugins	`vim-arb`		—
5 — Editor / multiplexer plugins	`emacs-arb`		—
5 — Editor / multiplexer plugins	`vscode-elisp`		—
5 — Editor / multiplexer plugins	`vim-elisp`		—
5 — Editor / multiplexer plugins	`emacs-elisp`		—
5 — Editor / multiplexer plugins	`tmux-fzf-url`		—
6 — Apps, extensions, web & web-APIs	`zwire`		—
6 — Apps, extensions, web & web-APIs	`zpwrchrome`
6 — Apps, extensions, web & web-APIs	`storageshower`
6 — Apps, extensions, web & web-APIs	`zpwr-jobs`	—	—	—
6 — Apps, extensions, web & web-APIs	`MenkeTechnologies.github.io`		—
6 — Apps, extensions, web & web-APIs	`api-rest-generator`		—
6 — Apps, extensions, web & web-APIs	`LearningCollectionAPI`		—
6 — Apps, extensions, web & web-APIs	`zpwr-synth`	—	—	—
6 — Apps, extensions, web & web-APIs	`zpwr-fx`	—	—	—
6 — Apps, extensions, web & web-APIs	`zpwr-midi-fx`	—	—	—
6 — Apps, extensions, web & web-APIs	`zpwr-patch-core`	—	—	—
6 — Apps, extensions, web & web-APIs	`zpwr-hooks-editor`	—	—	—
6 — Apps, extensions, web & web-APIs	`zpwr-modal-editor`	—	—
6 — Apps, extensions, web & web-APIs	`zpwr-i18n`	—	—	—
6 — Apps, extensions, web & web-APIs	`zpwr-clip-engine`	—	—	—
6 — Apps, extensions, web & web-APIs	`zgui-core`	—	—	—
6 — Apps, extensions, web & web-APIs	`zgui-bridge`	—	—	—
6 — Apps, extensions, web & web-APIs	`zdsp-core`	—	—	—
6 — Apps, extensions, web & web-APIs	`zpwr-theme`		—
6 — Apps, extensions, web & web-APIs	`app-store`	—	—	—
6 — Apps, extensions, web & web-APIs	`zpwr-license`	—	—	—
6 — Apps, extensions, web & web-APIs	`zpwr-account`	—	—	—
6 — Apps, extensions, web & web-APIs	`MenkeTechnologiesPublications`	—	—	—
7 — znative plugins	`zshrs-forgit`
7 — znative plugins	`zshrs-git-fuzzy`
7 — znative plugins	`zshrs-git-repos`
7 — znative plugins	`zshrs-revolver`
7 — znative plugins	`zshrs-kubectl-completion`
7 — znative plugins	`zshrs-zsh-z`
7 — znative plugins	`zshrs-fasd`
7 — znative plugins	`zshrs-reveal`
7 — znative plugins	`zshrs-zwire`

[0x03] COMMON OPERATIONS

Pull every submodule to its remote tip

git submodule update --remote --merge

--remote fetches the latest commit from each submodule's tracking branch (defaults to the remote's default branch). --merge merges local + remote rather than detaching HEAD.

Status across all submodules at once

git submodule foreach --recursive 'git status -s'

Shows uncommitted changes inside every submodule. Use --quiet to suppress the per-submodule banner.

Pull (fast-forward) every submodule

git submodule foreach --recursive 'git pull --ff-only || true'

|| true keeps the loop going even if one submodule has unrelated history.

Commit + push from inside one submodule

cd strykelang
git commit -am 'feat: ...'
git push
cd ..
git add strykelang
git commit -m 'bump strykelang pointer'
git push

The outer meta-repo commit records the new SHA the submodule points to.

List every submodule with its pinned SHA

git submodule status

Prefix + means the working tree diverges from the pinned SHA; - means the submodule isn't initialized.

[0x04] HELPER SCRIPTS

The bin/ and scripts/ directories ship wrappers for common operations. Most are POSIX shell with no dependencies beyond git; gen-ci-board needs bash + authenticated gh, gen-code-volume needs stryke + tokei, gen-doc-inventory.mjs needs node (run it as node bin/gen-doc-inventory.mjs), and the icon generators need rsvg-convert (librsvg), the Tauri CLI, and macOS sips/iconutil. The app-release scripts (gen-gui-actions-live, ship-apps, deploy-apps) are macOS-only and need the Tauri CLI plus authenticated gh; the first two are stryke. The publications pipeline (scripts/collect-pdfs.sh, scripts/bp.stk) needs pandoc + LuaLaTeX and, for the release step, stryke + authenticated gh.

Script	What it does
`bin/pull-all`	Pull every submodule to its tracking-branch tip in parallel.
`bin/status-all`	One-line status for every submodule (branch + ahead/behind + dirty marker).
`bin/foreach`	Run an arbitrary shell command inside every submodule.
`bin/sync-pointers`	After running pull-all, stage + commit all submodule pointer bumps in one commit.
`bin/release-all`	Coordinated `Cargo.toml` bump + commit + tag + push across every submodule that backs a homebrew formula.
`bin/gen-ci-board`	Regenerate the [0x02] CI Status Board from the submodule map + live workflow lists (`--in-place` splices README.md).
`bin/gen-code-volume`	Regenerate the [0x09] Code Volume tables (stryke) — `tokei` de-duplicated by git: nested submodule mountpoints counted once at their top-level checkout (`--in-place` splices README.md and restamps the header `rust-…M_LOC` / `code-…M_lines` badges).
`bin/gen-app-icon.sh`	Render one GUI app icon from the shared cyberpunk brand template (chamfered neon frame + width-pinned glyph/wordmark, vendored Orbitron). Args: accent, glyph, wordmark, out.png.
`bin/gen-all-icons.sh`	Regenerate every GUI app's icon set from that one template (Tauri via `tauri icon`, JUCE via `iconutil`), so all apps share `zterminal`'s geometry and differ only by accent/glyph. Reads the shared brand assets in `bin/icon-assets/`.
`bin/gen-gui-actions-live`	Regenerate `docs/GUI_SCRIPT_ACTIONS.md` from the live automation-bus surface (stryke): opens each GUI app, queries `verbs()` over its Unix socket, closes it. Sees the whole runtime surface (appShell + `opts.commands` + dynamically-registered verbs). Requires every app to be launchable.
`bin/gen-gui-actions.sh`	Static fallback for the same catalog — greps each app's verb sources at `origin/main`. Cannot see dynamically-registered or appShell verbs, so `gen-gui-actions-live` is authoritative.
`bin/gen-doc-inventory.mjs`	Regenerate `docs/inventory.html`: a clickable inventory of every page under `docs/`, plus a chrome-sync audit that flags pages not wired to the shared HUD CSS/JS, missing headers, dead-end nav, broken relative links, or a lagging color-scheme catalog.
`bin/sync-doc-mirrors`	Refresh the GitHub Pages doc mirrors under `docs/<repo>/` from each submodule's own `docs/` (Pages builds without submodules, so every per-project page must exist as a real file here). Copies verbatim, rewriting the shared-chrome paths one level up; only refreshes mirrors that already exist on both sides. `--dry-run` to preview.
`bin/deploy-apps`	Build every Tauri app's release `.app`, install it to `/Applications`, and upload a headless `.dmg` (via `hdiutil`, no Finder popup) to a GitHub release.
`bin/ship-apps`	Full GUI-app release pipeline (stryke): bump each app's bundled `zgui-core`, patch-bump the version, commit + push, bump the meta gitlink, then build, install, and publish a dmg + pkg at `v<version>`. The GUI-app counterpart to `release-all`.
`bin/ship-sync-zgui.sh`	Pin every `zgui-core` worktree under one app checkout — the app's own submodule and the nested copies inside each engine-`*-core` — to a target SHA before `ship-apps` builds, so the artifact can't embed a stale toolkit. Worktrees carrying uncommitted work are reported and left untouched.
`scripts/collect-pdfs.sh`	Gather every authored PDF across the tree into `MenkeTechnologiesPublications/all-pdfs/` with a `MANIFEST.md` (page counts, category, source, built/code dates, staleness) and a sortable `index.html` catalog built from the `zgui-core` data-table widget.
`scripts/bp.stk`	Publications release (stryke): rebuild stale PDFs in parallel via `pmap`, refresh the manifest, mirror the PDFs into `app-store/docs/`, bump + tag + push, cut the GitHub release, then move the meta gitlinks forward.

# pull everything
./bin/pull-all

# what's dirty?
./bin/status-all

# build every Rust project
./bin/foreach 'test -f Cargo.toml && cargo build --release || true'

# bump every pointer to current submodule HEAD
./bin/sync-pointers && git push

# preview a coordinated patch-bump across every formula-backed crate
./bin/release-all --dry-run

# cut a minor release across two crates and push tags
./bin/release-all --bump=minor --only=awkrs,zshrs

release-all reads homebrew-menketech/Formula/*.rb to learn which submodules ship as binaries, derives the tag prefix from each formula's release URL (so awkrs gets vX.Y.Z and zpwrchrome-host gets host-vX.Y.Z), and dedupes formulae that share a repo (e.g. zshrs.rb + zshrs-all.rb → one bump). It does not regenerate the formulae — each crate's release CI builds the artifacts; once those exist, update Formula/*.rb (url + sha256 + version) and commit the tap.

[0x05] UPDATING SUBMODULE POINTERS

A submodule entry in .gitmodules points to a specific commit SHA in the submodule's history. The meta repo doesn't auto-follow new commits — you bump the pointer explicitly.

# fetch latest commits from every remote
git submodule foreach --recursive 'git fetch --quiet'

# fast-forward each submodule to its tracking branch tip
git submodule update --remote --merge

# stage + commit the new SHAs
git add .
git commit -m 'submodules: weekly pointer sync'
git push

Or use the helper:

./bin/pull-all && ./bin/sync-pointers && git push

[0x06] PER-HOST SETUP

macOS / Linux

# prereq: git 2.13+ (parallel submodule clones) and ~8 GB free (more if you build)
git clone --recurse-submodules -j 8 https://github.com/MenkeTechnologies/MenkeTechnologiesMeta.git
cd MenkeTechnologiesMeta

# build the Rust CLIs
./bin/foreach 'test -f Cargo.toml && cargo build --release || true'

# install zpwr (the terminal OS)
./zpwr/install/zpwrInstall.sh

# install any CLI tool via the unified homebrew tap (33 formulas: arb, awkrs, elisprs, grcrs, groovyrs, htoprs, iftoprs, javars, kotlinrs, lsofrs, nmaprs, node-js, phplang, powerliners, pythonrs, rlang, rubylang, scalars, storageshower, stryke, tclrs, temprs, vimlrs, zcolorizer, zdbview, zmax, zpwrchrome-host, zshrs, zshrs-all, zshrs-daemon, ztmux, zvcs, zwire-host)
brew tap MenkeTechnologies/menketech
brew install stryke zshrs lsofrs iftoprs htoprs awkrs nmaprs temprs powerliners storageshower zpwrchrome-host zmax elisprs vimlrs zcolorizer zdbview ztmux zwire-host
# `zshrs-all` is the full zshrs install (shell + zd client + recorder +
# daemon). It conflicts_with `zshrs` — pick one. Use `zshrs-all` if you
# want the recorder/daemon tooling alongside the shell binary.

CI / Docker

FROM rust:1-bookworm
RUN git clone --recurse-submodules -j 8 \
    https://github.com/MenkeTechnologies/MenkeTechnologiesMeta.git /workspace
WORKDIR /workspace
RUN ./bin/foreach 'test -f Cargo.toml && cargo build --release || true'

Air-gapped / mirror

The meta repo is mirror-friendly — every submodule URL is unauthenticated HTTPS to a single MenkeTechnologies/<repo>.git namespace. Mirror with:

git clone --recurse-submodules --mirror https://github.com/MenkeTechnologies/MenkeTechnologiesMeta.git

[0x07] WORKING INSIDE A SUBMODULE

Submodules check out in detached HEAD state at the pinned SHA. Before committing changes:

cd strykelang
git checkout main          # detach -> branch
# make changes, commit, push
git push origin main
cd ..
git add strykelang         # record the new SHA in the meta repo
git commit -m 'bump strykelang'
git push

To make git submodule update always check out the tracking branch instead of detaching:

git config -f .gitmodules submodule.strykelang.update merge
git config -f .gitmodules submodule.strykelang.branch main
git commit -am 'config: track strykelang main branch'

[0x08] DISK FOOTPRINT

Measured fresh-clone size (checked-out tracked files + .git/modules/, after git clone --recurse-submodules). Gitignored build output (target/, node_modules/) is excluded — a fresh clone carries none of it:

Tier	Repos	Approx size
Tier 1 — Core	75	~4.2 GB
Tier 2 — Stryke ecosystem	34	~40 MB
Tier 3 — zsh-more-completions	1	~195 MB
Tier 4 — Zsh ecosystem plugins	28	~22 MB
Tier 5 — Editor / multiplexer plugins	20	~16 MB
Tier 6 — Apps, extensions, web & web-APIs	23	~3.8 GB
Tier 7 — znative plugins	9	~1.5 MB
Total	190	~8.3 GB

Each repo's size counts its own git object store, so a nested submodule's objects are counted again under every parent that vendors it — which is exactly what a recursive clone puts on disk. The bulk is MenkeTechnologiesPublications/ (~1.9 GB — it vendors strykelang, zshrs, and zpwr as its own src/ submodules, so a full recursive clone re-fetches all three a second time under it), traderview/ (~682 MB), zmax-gui/ (~589 MB) and zmax/ (~573 MB), MenkeTechnologies.github.io/ (~506 MB — accumulated screenshot history), Audio-Haxor/ (~451 MB — Tauri v2 frontend assets + JUCE C++), zpwr-fx/ (~340 MB), and zpwr-synth/ (~290 MB). Cargo target/ directories are .gitignored and re-derived during build — as is zwire/dist/ (the ~772 MB Chromium snapshot, fetched at setup, not cloned), which is why zwire is only ~42 MB here. Numbers refresh as repos add commits.

To save space on a host where you only need a subset, init only those:

git clone https://github.com/MenkeTechnologies/MenkeTechnologiesMeta.git
cd MenkeTechnologiesMeta
git submodule init strykelang zshrs lsofrs    # init only what you want
git submodule update --depth 1                # shallow clone for the initialized set

[0x09] CODE VOLUME

Measured with tokei across the full recursive working tree, de-duplicated by git. The same engines are vendored inside many apps (under libs/, lib/, crates/, vendor/, …) as nested submodules; every nested submodule mountpoint is excluded so each engine is counted exactly once at its own top-level checkout, never where it is re-mounted. Third-party submodules (JUCE, clap-juce-extensions, upstream powerline) and the vendored fish source are excluded — not authored here. Build artifacts (target/, node_modules/, build/) are skipped via .gitignore. Code is source lines only (blanks + comments excluded); .stk (stryke source) has no tokei lexer, so it is counted separately as non-blank, non-#-comment lines — the same definition tokei uses. Regenerate with bin/gen-code-volume --in-place.

Language	Code	Files
Rust	4,996,961	12,233
JSON	2,393,411	860
TeX	1,854,280	173
JavaScript	745,093	4,549
HTML	604,746	1,426
C Header	387,834	1,914
C++	384,299	1,138
Python	286,754	1,208
Zsh	285,383	1,338
C	263,643	446
Stryke (`.stk`)	201,945	3,398
Shell	134,856	3,602
Vim Script	125,676	992
CSS	119,687	460
Perl	107,492	1,793
AWK	82,707	2,192
Scheme	77,756	2,338
C++ Header	73,770	260
TOML	68,573	1,113
Kotlin	29,909	281
SQL	29,409	124
Objective-C++	20,833	65
Other (89 languages)	113,207	1,647
Total	13,388,224	44,923

The JSON mass is dominated by traderview frontend i18n locales plus zpwr-synth factory-preset banks; the remainder is fixtures, completion data, and bytecode/cache snapshots. The Perl mass is strykelang/parity/cases — hand-written parity scripts that pin strykelang behavior 1:1 against Perl 5.

Largest single repos by source (same exclusions; .stk counted as above):

Repo	Primary	Secondary
`traderview`	JSON 1,581,635	Rust 784,604
`MenkeTechnologiesPublications`	TeX 1,848,172	HTML 133,104
`zpwr-fx`	C++ 333,824	C Header 306,882
`strykelang`	Rust 417,622	Stryke 162,579
`zshrs`	Rust 541,609	Zsh 56,822
`zmax`	Rust 320,336	JSON 143,978
`zvcs`	Rust 516,614	Shell 12,676
`zmax-gui`	Rust 252,968	JSON 96,307
`docs`	HTML 393,255	JavaScript 6,806
`Audio-Haxor`	Rust 140,344	JSON 121,593

Numbers refresh as repos add commits — regenerate with bin/gen-code-volume --in-place.

Against a typical engineer-career

Every line above is hand-authored. The standard software-engineering productivity figures (Brooks' Mythical Man-Month, COCOMO, Capers Jones) put net maintained output at roughly 20–100 lines/day sustained — call a 40-year career ~9,200 working days. The multiple below is Total ÷ (rate × 9,200) against the measured Total above:

Net LOC/day baseline	Career total	This tree ÷ baseline
100/day (optimistic ceiling)	~920,000	~15×
50/day (mid estimate)	~460,000	~29×
20/day (conservative)	~184,000	~73×

The defensible floor is ≥14 engineer-careers of authored code, produced in one — it uses the highest productivity baseline, so the multiple only grows under any more realistic assumption.

The baseline is an industry estimate, not a measured value; the Total is measured (tokei + the .stk pass). This is line-volume, not a claim about impact or difficulty.

[0xFF] LICENSE

MIT License — MenkeTechnologies. See LICENSE.

Each submodule retains its own license; see the LICENSE file inside each submodule directory.

MenkeTechnologies on GitHub · strykelang · zshrs · zpwr

`MenkeTechnologies on GitHub` · `strykelang` · `zshrs` · `zpwr`