strykelang language, the zshrs shell, the
fusevm bytecode VM, Rust CLI tools, Tauri v2 desktop apps,
the 33-repo Stryke ecosystem, 28 zsh plugins, 8 native zshrs
plugins, and the umbrella meta repo that vendors them all. Every site is mirrored under
https://menketechnologies.github.io/<repo>/.
Vendors every MenkeTechnologies project as a git submodule. One git clone --recurse-submodules produces a fully-loaded dev workstation.
The set of projects sharing the unified strykelang-authored documentation template: README header, ToC convention [0xNN], docs/index.html chrome, docs/report.html engineering report, man pages. Includes the eighteen fusevm-hosted languages, the Rust CLI tools & TUIs, the Tauri v2 / JUCE desktop apps and their embeddable *-core engines, and the shared audio / GUI components.
strykelangThe fastest dynamic language for parallel ops. Perl 5 compatible interpreter in Rust, bytecode VM + Cranelift JIT, 10,493 builtins.
zshrsThe first compiled Unix shell. 1:1 zsh C-port + extensions, persistent worker pool, AOP intercept, rkyv bytecode cache.
fusevmLanguage-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, javars, kotlinrs, scalars, groovyrs, rlang, go-rs, tclrs and texrs. Also ships a cooperative green-thread scheduler + channels + select (fusevm::sched) hosting go-rs's goroutines.
lsofrsRust rewrite of lsof — 5-21× faster, 7-tab TUI (ratatui), 31 cyberpunk themes.
temprsTemporary file stack manager. Atomic flock-protected master record, dual indexing (position or @name).
awkrsAWK in Rust. Bytecode VM + Cranelift JIT + persistent rkyv bytecode cache + parallel records.
vimlrsVimL (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).
elisprsEmacs 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 shipped. Free / OSS (MIT).
rubylangRuby in Rust — a compiled Ruby runtime that runs .rb outside MRI. Lexes and parses Ruby to an AST, lowers it to fusevm bytecode, and executes on the shared three-tier Cranelift JIT (the engine behind strykelang / zshrs / awkrs / vimlrs / elisprs): arithmetic and comparisons lower to native VM ops while 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).
arbVisualize 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).
iftoprsReal-time bandwidth monitor. TUI built on ratatui, 31 themes, process attribution via lsof, NDJSON streaming.
htoprsA 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
grcrsA faithful Rust port of grc (Generic Colouriser 1.13) — the regexp-driven ANSI stream painter. Ships the original binary pair: grc (launcher — matches the command line against grc.conf, runs it, pipes stdout/stderr through the colouriser) and grcat (reads regexp/colour config blocks and paints stdin line by line), on a fancy-regex core. MIT.
zdbviewTerminal 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 search, schema view. rkyv archives are not self-describing, so a format registry carries a byte-compatible copy of each producer's archive type and decodes eight of them (zshrs script + autoload, strykelang, awkrs, vimlrs, elisprs, pythonrs, rubylang/arb) to real key/value records with full create / update / rename / delete, re-serialized byte-identically to the producing host and written back atomically; unrecognized files fall back to embedded strings + hex dump. Backend is chosen by header magic, never filename. ratatui + crossterm TUI: vim motions, auto/hex/text/disasm detail view, OSC 52 clipboard, CSV/JSON export, recent-files picker. MIT.
ztranslatorReal-time event-translation desktop app in pure Rust — also embeddable as a routing engine. Bridges MIDI, OSC, DMX, and file-watcher triggers to MIDI/OSC/DMX out, keystroke, mouse, AppleScript, or host commands, with a per-translator rules VM and BOME .bmtp import/export.
Audio-HaxorTauri v2 desktop GUI app + JUCE engine. VST2/VST3/AU/CLAP scanner, sample vault, DAW project index, KVR version checker.
traderviewTauri v2 desktop GUI app — TraderVue-style trading journal with embedded Postgres, vanilla JS + uPlot frontend. Multi-user axum web service from the same workspace.
zpwr-dawDAW arranger + the 4th patch-graph plugin (standalone app, VST3/AU/CLAP, embeddable library; formerly zpwr-clip-engine). One generalized grid engine over notes / arrangement / automation / trigger domains, with a JUCE-free C++ core exposing a C ABI + Rust bindings. Private — docs vendored to meta.
zpwr-crateShared sample-library “crate” browser (Rust) — the audio stack's filesystem + SQLite/FTS5 sample scanner and faceted query layer. Builds rlib + staticlib + cdylib: consumed natively by Audio-Haxor and over a C ABI by zpwr-daw. Private internal shared library.
zpwr-embed-terminalShared embedded PTY terminal (Rust) — one portable-pty core + xterm.js front end extracted from Audio-Haxor. Builds rlib + staticlib + cdylib: used natively by Audio-Haxor / traderview / ztranslator and over the C ABI by zpwr-daw (JUCE/C++). Private internal shared library.
zwire-hostChrome 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.
zpwr-file-browserShared file browser (Rust + JS) — a host-agnostic file-tree / list front end (taken verbatim from Audio-Haxor) backed by a pure-Rust filesystem crate. Builds for all four apps — Audio-Haxor / traderview / ztranslator (Tauri) and zpwr-daw (JUCE WebView). Private shared component.
zpwr-algo-productionAlgorithmic 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 per-genre engines. Ported from the Audio-Haxor generators behind a host-provided sample source. Powers zpwr-daw's one-click production. Private internal engine.
nmaprsRust port of nmap. Full async TCP/UDP/SCTP/IP-protocol scans, idle/zombie scans, NSE-style script probes.
powerlinersMature Rust port of Python's powerline-status. 5-binary suite, sub-millisecond render replacing the ~100 ms python startup tax.
zpdfPDF editor replacing Adobe Acrobat + Preview (Rust, Tauri v2 desktop app) — full editing, annotation/markup, AcroForms, digital & certificate signatures, OCR, redaction, page management, convert/export. Consumes zpdf-core. Paid product (in the app-store).
zpdf-coreEmbeddable PDF engine (pure Rust, no GUI deps) — parse/render/edit/annotate/sign/page-ops behind zpdf; rlib + staticlib + cdylib so it embeds into traderview and the other GUI apps. Ships a source-derived feature port report. Private.
zemailEmail 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).
zemail-coreEmbeddable mail engine (pure Rust, no GUI deps) extracted from zemail so the same engine embeds across the GUI stack. Private.
zofficeOffice suite replacing Microsoft Office (Rust, Tauri v2 desktop app) — documents, spreadsheets, presentations. Consumes zoffice-core. Paid product (in the app-store).
zphotoPhoto suite replacing GIMP and Photostop (Rust, Tauri v2 desktop app) — images. Consumes zphoto-core. Paid product — in the app-store.
zphoto-coreEmbeddable photo engine (pure Rust, no GUI deps) — images parse + edit, extracted from zphoto.
zoffice-coreEmbeddable office engine (pure Rust, no GUI deps) — document/spreadsheet/presentation parse + edit, extracted from zoffice.
zstationWorkspace 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.
zstation-coreEmbeddable 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.
ztranslator-coreEmbeddable 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. rlib + staticlib + cdylib so it embeds across the GUI stack.
zmax-gui-coreEmbeddable 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.
zciteReference 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.
zreqAPI 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.
zreq-coreEmbeddable 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.
ztunnelVPN 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.
ztunnel-coreEmbeddable 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.
zgoLauncher 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.
zgo-coreEmbeddable 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.
zftpFile-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.
zftp-coreEmbeddable 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.
zcontainerContainer & 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.
zcontainer-coreEmbeddable 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.
zlatexLaTeX 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-coreEmbeddable 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. rlib + staticlib + cdylib. Private.
zmusicPlay-along instrument trainer for keys, pads and drums (Rust + Tauri v2 desktop app over a C++20 / JUCE 8 audio sidecar) — 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. Consumes zmusic-core. Paid product (in the app-store).
zmusic-coreEmbeddable play-along trainer engine (pure Rust, no GUI deps) behind zmusic — SMF import into a Chart that serializes to the same 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). rlib + staticlib + cdylib. Private.
ztorrentBitTorrent 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).
ztorrent-coreEmbeddable 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. rlib + staticlib + cdylib. Private.
zterminalGPU-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.
ztmux-coreEmbeddable 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.
ztmuxA 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).
zmaxRust 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-guiNative 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.
pythonrsPython in Rust — runs .py outside CPython. Lexes and parses Python to an AST, lowers it to fusevm bytecode, and runs on the shared three-tier Cranelift JIT (the engine behind strykelang / zshrs / awkrs / vimlrs / elisprs / rubylang); unlike CPython it caches the compiled result on every run and can bake a script into a native binary. Standalone python binary + REPL, --lsp / --dap, rkyv bytecode cache, AOT native compile. Free / OSS (MIT).
node-jsJavaScript in Rust — runs .js outside V8. Lowers JavaScript to shared fusevm bytecode and JITs the hot loops with one Cranelift JIT; a real I/O event loop + net / http / stream and a CommonJS node_modules loader run real Express (serves HTTP, no shadowing). BigInt, regex, tagged templates, async. Standalone node binary, -e, --lsp / --dap, rkyv bytecode cache. Free / OSS (MIT).
phplangPHP in Rust — runs .php outside Zend. Lowers PHP to shared fusevm bytecode and lets the tracing JIT compile the hot loops, on the same VM as strykelang / zshrs / awkrs / rubylang; arrays and objects run on a thread-local PhpHost heap. Standalone php binary + REPL, --lsp / --dap, rkyv bytecode cache. Free / OSS (MIT).
javarsJava in Rust — runs Java on fusevm instead of the JVM. Lexes and parses Java to an AST, lowers it to shared bytecode, and runs on the three-tier Cranelift JIT (the engine behind strykelang / zshrs / awkrs / rubylang). Standalone java binary + REPL, --lsp, rkyv bytecode cache. Free / OSS (MIT).
kotlinrsKotlin in Rust — compiles and runs Kotlin on fusevm with no JVM warm-up. Lowers Kotlin to shared bytecode on the three-tier Cranelift JIT behind strykelang / zshrs / awkrs. Standalone kotlin binary + REPL, --lsp, rkyv bytecode cache. Free / OSS (MIT).
scalarsScala in Rust — runs Scala on fusevm instead of the JVM. object / def main and extends App, val / var, range for, newline inference, all lowered to shared bytecode on the three-tier Cranelift JIT; byte-diffed against reference scala by a parity-fuzz harness. Standalone scala binary + REPL, --lsp, rkyv bytecode cache. Free / OSS (MIT).
groovyrsGroovy in Rust — runs Groovy on fusevm instead of the JVM. Script model, GDIV division, for-in desugar, newline lexer, lowered to shared bytecode on the three-tier Cranelift JIT behind strykelang / zshrs / awkrs. Standalone groovy binary + REPL, --lsp, rkyv bytecode cache. Free / OSS (MIT).
rlangR 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 — byte-identical to GNU R 4.6.1 across a 48-snippet differential parity harness. Standalone Rscript binary + REPL, --lsp / --dap, inline-Rust FFI (.rust / .Call), rkyv bytecode cache, AOP intercepts. Free / OSS (MIT).
go-rsGo 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. The sixteenth fusevm frontend: single-file package main, top-level func + methods, := / var, Go automatic semicolon insertion, static int/float typing, slices and maps, structs with value-copy semantics, interfaces with dynamic method dispatch, closures, and goroutines / channels / select on a cooperative scheduler added to the shared fusevm VM itself (fusevm::sched, v0.14.14–0.14.15), plus fmt/strings/strconv/math/sort/os — checked byte-for-byte against reference go. Full toolchain parity: standalone go binary with --lsp / --dap, man pages, _go completion, inline rust {} FFI, --dump-tokens / --dump-ast / --disasm. Free / OSS (MIT).
tclrsTcl in Rust — Tcl as a fusevm frontend (parse → fusevm bytecode): no bespoke VM, no interpreter loop, no code generator in the crate. The seventeenth fusevm 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 and no runtime parse. 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: 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, --aot links a native binary carrying no Tcl interpreter, and the toolchain is complete: reedline REPL, --lsp / --dap, _tclrs, man pages, generated reference.html, inline rust {} FFI, --dump-tokens / --dump-ast / --disasm / --tiers. Free / OSS (MIT).
texrsTeX in Rust — Knuth's mouth and expander lowered onto fusevm bytecode and run on the shared 3-tier Cranelift JIT; every TeX since 1982 interprets the expander, this one compiles it. The eighteenth and newest fusevm frontend: the mouth turns bytes into tokens under a mutable category-code table, the expander turns tokens into other tokens (\def / \csname / \the / the conditionals) — the half a macro-heavy document spends its time in. The stomach (box building, DVI shipping) is not implemented, so this is not a typesetter yet. Ships the CLI, --lsp / --dap, _texrs, man pages, an HTML docs site, a generated reference.html, and --dump-tokens / --disasm / --tiers; inline rust {} FFI and --dump-ast still ahead of it. Free / OSS (MIT).
zvcsA git-superset VCS forked off gitoxide — a single git binary that shadows git and adds what git structurally cannot: fair mutual exclusion, self-attaching submodules, forward-only pointer bumps, built for a meta-repo under many concurrent agents. Superset verbs zsync / zbump / zdaemon. Free / OSS.
zthrottleA from-scratch desktop system-stress + benchmark tool in Rust — drives every subsystem (CPU, memory, disk, GPU) at once and shows how each one degrades under load from the others, instead of measuring one thing with the rest idle. Tauri v2 desktop app over the zthrottle-core engine.
The Stryke connector ecosystem — per-backend integration crates (cloud, databases, streaming, GPU, k8s, …) plus the Homebrew tap.
homebrew-menketechSingle Homebrew tap: one formula per CLI in the fleet — 37 formulas today, plus the zwire cask. Covers stryke, zshrs / zshrs-all / zshrs-daemon / zshrs-native, every fusevm frontend, the Rust CLIs and TUIs, zmax, ztmux and zvcs. Formulas auto-bumped by each tool's Release workflow via HOMEBREW_TAP_TOKEN; the tap's README carries the live count and the full table.
stryke-appApp-automation cdylib for stryke's App package — drive MenkeTechnologies GUI apps over the GUI Automation Bus. Free / OSS (MIT).
stryke-fleetParallel expect/PTY automation — transcripted sessions, declarative playbooks, multi-host fan-out.
stryke-guiGUI automation bridge — stryke_gui cdylib dlopened 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.
stryke-mcpdMCP servers as single native binaries — validated tool specs, crash-isolated serving, root-jailed tool pack.
stryke-officeOffice/ODF/PDF/image import+export — xlsx/docx/pptx, ods/odt/odp, PDF, images. All native (no LibreOffice).
stryke-polarsFull pandas + numpy surface — DataFrame/Series/Index/IO + ndarray/ufuncs/linalg/random/fft/polynomial/masked/datetime64 — in one cdylib, dlopened in-process on use Polars. Heavy deps kept out of the stryke core.
stryke-terminalHeadless VTXXX terminal-emulator cdylib for stryke's terminal package — a faithful pyte port that turns raw PTY bytes into a rendered screen grid (cursor, colors, modes, scrollback). Golden-tested against pyte; the screen model behind strykelang's built-in pty_*. Free / OSS (MIT).
stryke-utilsPure stryke library — shared helpers written in stryke itself, no Rust or external deps.
The auto-generated completions corpus.
The zsh plugin family — completions, aliases, and workflow plugins, including vendored favourites.
zsh-openshift-aliases53 oc aliases (including the ocdev / ocqa login macros) + auto-sourced oc completion.
zsh-zinit-finalEmpty-by-design latch for zinit atinit / atload ices that need to fire after every other plugin.
Editor & multiplexer plugins — Vim / VS Code / Emacs language support and the tmux URL picker.
VimColorSchemes732 hand-curated Vim colorschemes packaged as a single Pathogen / vim-plug / lazy.nvim bundle. The largest one-bundle scheme collection.
vim-strykeVim / Neovim support for the stryke language — *.stk filetype detection, a syntax grammar generated from the stryke binary's reflection tables, brace indent, ALE linting, and LSP via stryke --lsp.
vscode-strykeVS Code / VSCodium extension for stryke — *.stk detection, a stryke-native TextMate grammar from the binary's reflection tables, and LSP via stryke --lsp.
emacs-strykestryke-mode for Emacs — a generated stdlib carrying the full language surface, font-lock, brace indent, and LSP via stryke --lsp (eglot + lsp-mode).
vim-zshVim / Neovim support for the zshrs shell — *.zsh / dotfile / shebang detection, a grammar from zshrs --dump-reflection, ALE via zshrs -n, and LSP via zshrs --lsp.
vscode-zshVS Code / VSCodium support for zshrs — a source.zshrs TextMate grammar from zshrs --dump-reflection, filetype detection, and LSP via zshrs --lsp.
emacs-zshzshrs-mode for Emacs — font-lock from zshrs --dump-reflection, shell-block-aware indent, and LSP via zshrs --lsp (eglot + lsp-mode).
vscode-awkVS Code / VSCodium extension for AWK (awkrs) — *.awk detection, a hand-written source.awk TextMate grammar (BEGIN/END, control keywords, built-in vars + functions, field refs, /regex/), an awk.run command, LSP via awkrs --lsp, and DAP debugging via awkrs --dap.
vim-awkVim / Neovim support for AWK (awkrs) — *.awk filetype detection, syntax + brace-aware indent, run / :make via awkrs, and LSP via awkrs --lsp.
emacs-awkawkrs-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).
vscode-vimlVS 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.
vim-vimlVim / 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.
emacs-vimlvimlrs-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).
tmux-fzf-urlPop a fzf picker over every URL currently visible in the tmux pane; selected URL opens in the default browser.
vscode-elispVS Code / VSCodium extension for Emacs Lisp, backed by the elisprs interpreter — .el detection, an elisp grammar, and LSP via elisp --lsp.
vim-elispVim / Neovim support for Emacs Lisp, targeting the elisprs runtime — .el detection, syntax, and LSP via elisp --lsp.
emacs-elispEmacs' own lisp editing plus the elisprs runtime — open a .el and run, evaluate, and language-server against the standalone elisp interpreter's subrs.
vscode-arbVS Code / VSCodium extension for arb — .arb detection and syntax for the pipeline-visualization language, turning a Unix pipeline into a live TUI or served web page from a declarative spec.
vim-arbVim / Neovim support for arb — load it with pathogen, open a .arb, and the widgets, query verbs, and pipeline spec light up.
Apps, browser extensions, web-API services, shared runtime components, the storefront, publications, and the meta umbrella's own public site.
zwireA 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.
zpwrchromeThe fastest recent-tabs Chrome extension with the most keyboard shortcuts. Manifest V3, cross-window MRU stack, 55 commands, UNIX pass integration via the bundled zpwrchrome-host Rust port.
storageshowerDisk-usage TUI in Rust (sibling to iftoprs). Walks a directory tree and presents space-by-folder with sort + drill-down.
zpwr-jobsCLI job-application pipeline manager — tracks job postings, resumes, and cover letters through an application workflow.
MenkeTechnologies.github.ioThe public site — this index of project docs, the landing page, screenshot history. Source for menketechnologies.github.io.
api-rest-generatorREST API generator from raw SQL DDL dumps. Targets Spring Boot (Java/Kotlin/Groovy) and Loco (Rust/Axum/SeaORM). Published on crates.io.
LearningCollectionAPIJava/Kotlin Spring Boot REST service — backing service for the zsh-learn plugin (save / query / quiz / search vocabulary cards over HTTP).
zpwr-synthJUCE software synthesizer (C++) — fully modular patch-graph instrument on the shared zpwr-patch-core engine. Instrument → Layer[16] → Voice, 309 voice modules, PERFORM stage, Stereo Lock. Builds VST3 / AU / CLAP / Standalone. Paid product.
zpwr-fxJUCE fully modular multi-effects plugin (C++) — a free patch graph over 3,366 audio modules on the shared zpwr-patch-core engine, per-param mod matrix, EZ-wire auto-routing, Stereo Lock. Builds VST3 / AU / CLAP / Standalone. Paid product.
zpwr-midi-fxJUCE fully modular MIDI-effects plugin — the same patch-graph engine on the note stream: 563 note-stream modules (arp / chord / scale / Euclidean seq / humanize), mod matrix, EZ-wire. Builds VST3 / AU / CLAP / Standalone. Paid product.
zpwr-patch-coreSignal-agnostic modular patch graph (C++20) — the shared cable-routing core behind the plugin stack (patch graph, soft knobs, shared WebEditor, versioning/migration). Reused by zpwr-fx, zpwr-synth, zpwr-midi-fx. Private.
zpwr-hooks-editorShared stryke Hooks code editor (JS) — a Monaco editor (+ monaco-vim, monaco-emacs, thin stryke-LSP adapter) esbuild-bundled into vendored artifacts. Build-on-each-consumer; used by all four apps — Audio-Haxor, traderview, ztranslator (Tauri) and zpwr-daw (JUCE WebView). Private shared component.
zpwr-modal-editorShared 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.
zpwr-i18nShared i18n runtime (vanilla JS) — a portable JSON-catalog loader extracted from Audio-Haxor (not its SQLite/Tauri loader), 27 locales, runs in Tauri apps and JUCE WebViews. Used by all four apps. Private shared component.
zpwr-clip-engineShared DAW arranger/sequencer frontend (JS) — the canvas clip-grid + swappable domains (arranger, piano-roll, session launcher, automation lanes) extracted from zpwr-daw so every GUI app embeds one arranger via initClipSeq(). zpwr-daw supplies a native audio backend; synth / fx / midi-fx use the bundled non-audio JS backend. Private shared component.
zgui-coreShared 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.
zdsp-coreShared 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.
zpwr-themeCyberpunk editor theme — VS Code (5 color schemes × dark/light = 10 themes) plus a matching JetBrains UI theme + editor scheme, all generated from one palette/schemes.json. Palette shared with the app stack's cyberpunk HUD.
app-storeStatic storefront (HTML/CSS/JS) for the entire MenkeTechnologies catalog — paid Tauri/JUCE apps & plugins plus every free/OSS repo, with GitHub download links, Shopify-style checkout, search + category filters.
zpwr-licenseOffline-first software licensing for the paid catalog (private). Ed25519-signed keys, issuer CLI, optional activation server, offline node-locking, embedded anti-tamper. Rust workspace, no licensing SaaS.
MenkeTechnologiesPublicationsPaid publications (private) — companion books, reference manuals/PDFs, and the zpwr encyclopedia for strykelang / zshrs / zpwr, plus their pandoc + LaTeX build pipeline.
zgui-bridgeThe local-IPC host for the GUI Automation Bus — an app calls serve with its bus name and a Handler, and zgui-bridge opens a per-app endpoint (a Unix domain socket on macOS/Linux, a named pipe on Windows) so external tools can drive the GUI. Shared runtime component.
zpwr-accountAccounts + 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) 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 while 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.
Classic zsh utilities ported to native compiled cdylib zshrs plugins, installed via znative — no sourced functions, no per-keystroke re-eval.
zshrs-forgitThe forgit fuzzy git UI reimplemented as native zshrs builtins — git add, log, diff, stash driven from the shell runtime, not sourced functions.
zshrs-git-fuzzyA git-fuzzy port for zshrs — a self-reentrant fzf UI over git with no per-keystroke re-sourcing.
zshrs-git-reposFind every git repo, classify clean / dirty across threads, and fzf-jump to it — a zshrs-native repo switcher.
zshrs-revolverThe revolver spinner / progress library for zshrs — no fork, no statefile, just a thread.
zshrs-kubectl-completionkubectl completion for zshrs — delegates to kubectl __complete, so it stays in sync with the installed kubectl.
zshrs-zsh-zz <partial> — the frecency directory jump, reimplemented as a zshrs builtin in Rust.
zshrs-fasda, s, d, f, j — the whole filesystem ranked by frecency, reimplemented for zshrs in Rust.
All sites mirrored under https://menketechnologies.github.io/<repo>/ ·
github.com/MenkeTechnologies