// STRYKE — THE HOTTEST LANGUAGE EVER CREATED 🔥

Quickstart

Install from crates.io or source, then run scripts or one-liners with s (short for stryke):

# install
cargo install strykelang

# from source
git clone https://github.com/MenkeTechnologies/strykelang
cd strykelang && cargo build --release

# one-liners
s 'p "hello, world"'
s '1:20 |> fi even |> map { _ * _ } |> sum |> p'
s '~>1:20fi{even}map{_*_}sum p'
s 'qw(a b c) |> map uc |> join "," |> p'
s '~> qw(a,b,c) map{uc} join(",") p'

# parallel primitives
s '1:8 |> pmap expensive |> p'

# read + parse JSON
s 'read_json("data.json") |> to_yaml |> p'
s 'p to_yaml read_json "data.json"'

Full install + usage live in the README.

-e is optional. If the first argument isn't a file and looks like code, s runs it directly. s 'p 42' and s -e 'p 42' are equivalent.

Why stryke — One-Liner Comparison

Character count — real tasks

Overview

• Parser & compiler — recursive-descent parser in strykelang/parser.rs, producing an AST consumed by the bytecode Compiler (strykelang/compiler.rs) that feeds the VM (strykelang/vm.rs). 100% lowered to bytecode. Cranelift Block JIT kicks in for hot blocks (strykelang/jit.rs).
• Values — StrykeValue is a NaN-boxed u64: immediates (undef, i32, raw f64 bits) and tagged Arc<HeapObject> pointers for big ints, strings, arrays, hashes, refs, regexes, atomics, channels.
• Regex — three-tier engine: Rust regex → fancy-regex (backrefs) → pcre2 (PCRE-only verbs).
• Parallelism — every parallel builtin uses rayon work-stealing across all cores. See pmap, pflat_map, pgrep, pfor, psort, preduce, pcache, ppool, fan, pipeline, par_pipeline_stream, pchannel, pselect, par_walk, par_lines, par_sed.
• Stress testing — heat(60) pins ALL cores to 100% TDP. stryke agent + stryke controller for distributed fleet-wide load testing. The hottest language ever created.
• Binary size — ~44 MB stripped with LTO + O3.

Language reflection

Everything the parser and dispatcher know about is exposed as plain Perl hashes, populated from the source of truth at compile time. build.rs parses category-labeled section comments in is_perl5_core / stryke_extension_name, the try_builtin match arms, and LSP hover docs in doc_for_label_text. Nine hashes — every direct lookup is O(1). Plus per-package symbol-table stashes (%main::, %Foo::, …) and the live-binding view (%parameters).

Forward maps

Inverted indexes (O(1) reverse-query)

Live-binding view (zsh $parameters analogue)

%parameters is rebuilt on every read so it always reflects the current scope. Keys are sigil-prefixed names ($x, @a, %h, $Pkg::var); values are kind strings.

Package stashes (Perl-spec symbol table)

Per-package %Pkg:: hashes show what each package declares — populated from our declarations and sub definitions, exactly like Perl 5. Lexical my bindings never enter a stash. Refreshed lazily on every read so newly-defined subs appear immediately.

--compat boundary: the nine reflection hashes (%b / %k / %all / %pc / %e / %a / %d / %c / %p + their %stryke::* long names) and %parameters are stryke-only — --compat turns them off entirely so they don't collide with user-declared hashes of the same name. Package stashes (%main::) and %ENV / %INC / %SIG stay on in every mode (Perl 5 spec).

Examples

Diagnostics & tab-complete dump

~p> chunk-parallel — string sources

~p> chunk-parallel — corpus workloads

~p> chunk-parallel — top-N highlights

~d> distributed — same surface, chunks ship over ssh

par { BLOCK } — generic chunk wrapper

~s> per-item streaming — basics

~s> per-item streaming — real workloads

Notes

• Every $h{name} lookup is O(1). Inverted indexes (%c, %p) let you do reverse-queries in O(1) too; filters like grep { cond } keys %h are still O(n).
• Hash sigil namespace is separate from scalars/functions — the short-alias letters don't collide with $a/$b sort specials, the e extension function, or any other stryke name.
• %descriptions is sparse: exists $d{$name} doubles as "is this documented in the LSP?".
• A value of "uncategorized" in %builtins flags a name that's dispatched at runtime but missing a // ── category ── section comment in parser.rs.

Pipe-forward

The |> operator (F# / Elixir) threads a value into the first argument of the next call — parse-time only, zero runtime cost.

x |> f          # f(x)
x |> f(a, b)    # f(x, a, b)
x |> f |> g(2)  # g(f(x), 2)

# real pipeline — count words per file, top 10 longest:
f("*.txt") |> map { [_, slurp(_) |> split(/\s+/) |> scalar] }
            |> sort { $b->[1] <=> $a->[1] }
            |> take(10)
            |> dd

Precedence sits between ?: and ||, so x + 1 |> f || y parses as f(x + 1) || y.

Pipe-RHS sugar

• Thread macro — t EXPR s1 s2 s3 expands to EXPR |> s1 |> s2 |> s3. Stages like pow(_, 2) use bare _ (or _) as a placeholder, auto-wrapped in a coderef. Bare _ = _ in any expression — enables map{_*2}fi{_>5}.
• >{ BLOCK } — IIFE anywhere an expression is valid; also works as a pipe stage (lhs |> >{ body }).
• @[...] — sugar for @{[...]} (deref anonymous arrayref inline).
• %[k => v] — sugar for %{+{k => v}} (deref anonymous hashref inline, sidesteps the block-vs-hashref ambiguity).

Sketch algebra — operator overloads on probabilistic data structures (world-first)

Probabilistic data structures are first-class operands for + | & ^ -. No other language ships this as a syntactic primitive — Python/Ruby/Node/Java/Wolfram all require library function calls like bloom_union(a,b) or roaring.intersect(b). Operators are functional: a new sketch is returned, neither operand is mutated.

my $u = $bloom_a + $bloom_b;       # Bloom union (also: |)
my $u = $hll_a   + $hll_b;         # HyperLogLog union (also: |)
my $u = $cms_a   + $cms_b;         # Count-Min counter sum
my $u = $topk_a  + $topk_b;        # SpaceSaving heavy-hitter merge
my $u = $td_a    + $td_b;          # t-digest centroid merge
my $u = $rb_a | $rb_b;             # Roaring union
my $i = $rb_a & $rb_b;             # Roaring intersection
my $x = $rb_a ^ $rb_b;             # Roaring symmetric difference
my $d = $rb_a - $rb_b;             # Roaring andnot

Shape mismatch (HLL precision differs, Bloom capacity differs) falls back to the default numeric/bitwise operator path — no panic, no silent truncation.

rkyv KV store — zero-copy CRUD (world-first)

First-class CRUD store with rkyv as the on-disk codec. No other scripting language ships a zero-copy archive KV as core builtins — Python has shelve (pickle), Ruby has PStore (Marshal), Perl has DBM_File (BerkeleyDB), Node has level bindings. Every one pays a parse + allocate per read. Stryke's kv_get is mmap + validate + cast — the same primitive script_cache.rs already uses for cached bytecode.

my $db = kv_open("/tmp/cache.rkyv");
kv_put($db, "users:alice", { name => "Alice", age => 30 });
kv_put($db, "users:bob",   { name => "Bob",   age => 28 });
kv_commit($db);

for my $row (kv_scan($db, "users:")) {
    my ($key, $val) = @$row;
    say "$key -> $val->{name}";
}

SQLite-shaped API ergonomics, beats SQLite on reads for any store that fits comfortably in RAM. Atomic rewrite on commit (tmp + rename), versioned format header (STKV magic + format_version), all-or-nothing kv_batch. Phase 2 ships stryke kvd server + remote kv_connect client over the same archive bytes.

Surface: kv_open, kv_put, kv_get, kv_del, kv_exists, kv_keys, kv_scan, kv_len, kv_commit, kv_batch, kv_close, kv_stats.

String coordinates — bytes vs codepoints

Stryke runs string code in two coordinate systems. Perl 5 builtins stay byte-indexed for binary-protocol and .pm-source compat. Stryke extensions are codepoint-indexed so search positions and slice bounds line up. They are never auto-converted — pick one coordinate system per expression and keep it consistent.

# `─` is 3 bytes in UTF-8 / 1 codepoint
my $s = "hello ─ world"

length $s                    # 15  (bytes)
len    $s                    # 13  (codepoints)
index  $s, "world"           # 9   (byte position — past the 3-byte `─`)
cindex $s, "world"           # 7   (codepoint position)
$s[7]                        # "w" — codepoint index
substr $s, 9, 1              # "w" — byte index
$s[7:11]                     # "world" — codepoint slice
substr $s, 9, 5              # "world" — byte substr

Rule: never feed an index / pos / length result into a [$a:$b] slice, and never feed a cindex / crindex / len result into substr / index. The coordinate systems silently misalign on any string containing non-ASCII bytes.

--no-interop does not force this split — both systems remain available because Perl 5 binary-protocol code legitimately needs byte positions. The split is a coordinate-system choice, not a stylistic one.

Builtin categories

10,459 primaries in %b (11,191 keys in %all, including aliases and keywords). Query them via keys %stryke::builtins — the table below is a navigational overview, not a full index. Run s 'p scalar keys %b' for the live primary count.

🔥 KILLER FEATURE: Infrastructure Load Testing

stryke is the first language designed for server farms. Pin millions of servers to 100% TDP from a single REPL. The hottest language ever created. Literally.

Stress Testing Builtins

One-Liners That Melt Silicon

# Pin all cores for 10 seconds
s 'heat(10)'

# Stress test with metrics
s 'dd stress_test(60)'

# Allocate and touch 8GB RAM
s 'stress_mem(8e9)'

# Maximum parallel computation — billion iterations
s '~>1:1e9 pmaps{sha256 _} collect'

Distributed Agent/Controller Architecture

Deploy stryke agent across your fleet. Control from stryke controller REPL.

# On every server in your fleet
$ stryke agent --controller master.example.com:9999

# On your control node
$ stryke controller
[controller] Listening on 0.0.0.0:9999
[connected] node1 (18 cores, 64GB)
[connected] node2 (18 cores, 64GB)
[connected] node3 (18 cores, 64GB)

> status
  node1: idle (18 cores, 64GB)
  node2: idle (18 cores, 64GB)
  node3: idle (18 cores, 64GB)

> fire 60
[fire] 3 agents, duration=60s
🔥 All agents pinned to 100% TDP

> terminate
[terminate] All agents stopped

Scriptable Distributed Compute — 28-Verb Religious Vocab

The REPL above is for human-typed interactive sessions. Scripts drive the same TCP+bincode infrastructure via a 28-verb religious-themed builtin API — scatter work, gather results, manage worker state, all from inside a .stk file:

# Spawn 4 worker processes locally, scatter+gather, clean shutdown
my @workers = congregation(4)
my %results = harvest "render_frame()", @workers, 30_000
excommunicate(@workers)

# Or split scatter/gather, with a coderef closure body
my $div     = pray sub { 2 + $_ }, @workers
my %results = annex $div

# Continuous chant — fires at current AND future joiners (late-join auto-receive)
my $vigil = chant "our %config = (max_depth => 8)", @workers
# ... slaves can profess("renderfarm") and auto-receive the chant on join ...
amen $vigil

Full taxonomy: lifecycle (congregation, anoint, ordain, muster, welcome, excommunicate, bow, profess, apostatize, cathedral) • scatter/gather (pray, annex, harvest, chant, amen, pilgrimage) • state inspection (lick, peruse, interrogate) • state mutation (bestow, smite, recant) • persistence (enshrine, exhume, smother, martyr, resurrect) • security (cloister, divine).

Workers maintain our %soul (externally-visible state) and our %gift (master-pushed config). :cloistered ACL via the AGENT_AUTH wire frame (0x1B) restricts membership to anointed workers carrying a valid STRYKE_AGENT_TOKEN. interrogate($pid) polymorphs on its argument shape — a single scalar is an OS PID dump via sysinfo; an array is the agent-VM state path.

World-first claim: scriptable in-language single-keyword scatter-gather + distributed state harvest + secure-erase as language primitives does not exist anywhere — MPI is a C library requiring mpirun; Erlang has process groups but no destructive harvest or peek/commit pair; Spark/Hadoop require cluster bootstrap and JVM; nothing in shell-language space comes close. The lick/annex/smother triple and the chant/amen continuous-rescatter pair are genuinely empty territory.

13 demos under examples/: distributed_congregation.stk (minimum-viable Tier 0), congregation_100x_scale.stk (tested clean at 100 + 250 workers), distributed_prime_sieve.stk (verifies π(10000)=1229 across N worker shards), distributed_wordcount.stk, distributed_log_aggregation.stk, harvest_oneshot.stk, bestow_then_lick.stk, pilgrimage_barrier.stk, chant_late_joiners.stk, smite_state_reset.stk, enshrine_exhume_roundtrip.stk, cloistered_acl_demo.stk, interrogate_pids.stk, multi_congregation.stk. All CI-safe (loopback fork only, no network), all clean under --no-interop.

See README §0x10c for full taxonomy with effect descriptions, killer-features-brainstorm.md "Scriptable Master/Slave" for the design rationale.

What stryke Validates

• Cooling capacity — Can your data center handle 100% TDP across all blades?
• Power infrastructure — Wire gauge, UPS failover, generator switchover
• Hardware reliability — Thermal throttling, component failures under stress
• Operations response — Alert latency, escalation procedures, incident response
• BCP/DR exercises — Validate failover, switchover, disaster recovery

Enterprise Deployment

# Zero-install: single static binary
scp stryke server:/usr/local/bin/
ssh server 'stryke agent'

# Kubernetes DaemonSet: deploy to every node
kubectl apply -f stryke-daemonset.yaml

# AOT compile your test suite into one binary
stryke build load_test.stk -o load_test
scp load_test node{1:100}:/tmp/

Compliance Use Cases

See docs/STRESS_TESTING.md and RFCs for full documentation.

REPL — Shell-Grade Interactive Prompt

Type s and you're in a programming-language REPL and a Unix shell at the same time. Every coreutils-style command works as a bareword; every builtin is callable with or without parens; tab-completion sees every name in %all; history persists; directory stack and aliases match shell muscle-memory.

# Startup banner — reflection counts at-a-glance
$ s
 ███████╗████████╗██████╗ ██╗   ██╗██╗  ██╗███████╗
 ██╔════╝╚══██╔══╝██╔══██╗╚██╗ ██╔╝██║ ██╔╝██╔════╝
 ███████╗   ██║   ██████╔╝ ╚████╔╝ █████╔╝ █████╗
 ╚════██║   ██║   ██╔══██╗  ╚██╔╝  ██╔═██╗ ██╔══╝
 ███████║   ██║   ██║  ██║   ██║   ██║  ██╗███████╗
 ╚══════╝   ╚═╝   ╚═╝  ╚═╝   ╚═╝   ╚═╝  ╚═╝╚══════╝
 ┌────────────────────────────────────────────────────────────────┐
 │ SYSTEM  status: ONLINE // os: macos arch: aarch64 pid: 30386   │
 │ CORES   18    MEM  56.2 / 64.0 GiB available                   │
 ├────────────────────────────────────────────────────────────────┤
 │ %b  builtins   10431  %a  aliases    643    %all 11159         │
 │ %k  keywords   85     %o  operators  70     %v   97            │
 │ %pc perl5 core 186    %e  stryke ext 10245  %d   4360          │
 │ %c  categories 316    %p  primaries  8914                      │
 └────────────────────────────────────────────────────────────────┘
  >> PARALLEL PERL5 INTERPRETER // RUST-POWERED v0.16.31 <<

Shell-Like Builtins (no PATH walk, no fork)

These are all in-process Rust functions, not exec() calls to coreutils. No fork. No path resolution. No spawning. Each returns a stryke value usable in the very next pipeline stage.

Real REPL Session

stryke❯ ls
total 408
-rw-r--r--    1   501    20     6148 May  9 19:13 .DS_Store
drwxr-xr-x    4   501    20      128 May 14 13:57 .claude
drwxr-xr-x    3   501    20       96 Apr 18 23:49 .cursor

# Coreutils-shaped builtins compose with stryke pipelines:
stryke❯ ls() |> grep { /\.rs$/ } |> sort |> head 5

# pwd / pushd / popd dir stack — zsh-style:
stryke❯ pwd
/Users/wizard/code/strykelang
stryke❯ pushd "/tmp"
/private/tmp
stryke❯ dir_stack
(/Users/wizard/code/strykelang)
stryke❯ popd
/Users/wizard/code/strykelang

# REPL aliases (renamed from `alias` so Perl typeglob `*alias = \&sub` keeps working):
stryke❯ repl_alias("ll", "ls -la")
stryke❯ repl_alias("g=git")

# Identity + system info — libc-backed, no process spawn:
stryke❯ whoami
wizard
stryke❯ groups
(staff everyone admin _developer com.apple.access_ssh)
stryke❯ term_size
(204 53)

# HTTP without leaving the REPL:
stryke❯ curl_get("https://api.github.com/repos/MenkeTechnologies/strykelang") |> from_json |> { _->{stargazers_count} }

# Find the binary for a name:
stryke❯ whereis "git"
(/usr/bin/git /usr/share/man/man1/git.1)

# Recursive tree view:
stryke❯ tree(".", 2) |> p

# Built-in coreutils-style pipeline — no fork chain:
stryke❯ cat "/etc/passwd" |> grep { not /^#/ } |> map { (split /:/)[0] } |> sort |> uniq

# Open a URL in the system browser:
stryke❯ openurl "https://stryke.menketech.com"

# Terminal title for tmux/iTerm window:
stryke❯ set_title "stryke // 0x42"

What stryke REPL Has That zsh / bash Don't

• Composable pipelines — every shell-like builtin returns a stryke value, so ls() |> grep { /\.rs$/ } |> sort works without spawning subprocesses
• 10,459 builtins in scope at all times — math, crypto, AI, web, regex, parallel, codec — every primitive listed in %b is callable from the REPL with zero imports
• Perl 5 syntax for everything that isn't shell muscle-memory: $_, @ARGV, %ENV, here-docs, regex literals, captures, sub, my, local, our all work
• Reflection at the prompt — keys %b for the full builtin set, keys %a for aliases, keys %d for documented names, keys %p for primaries, keys %k for keywords, keys %c for category names
• Live doc browser — docs <name> drops into a TUI hover-doc reader (j/k nav, t for ToC, / search, ]/[ for next/prev chapter)
• Parallel primitives — 1..1_000 |> pmap { fetch "https://example.com/api/$_" } saturates all 18 cores immediately. No syntax change, no xargs -P
• Tab completion — backed by lsp_completion_words.txt (22,071 names + every alias + every keyword), routed through reedline
• Persistent history — reedline stores accepted lines; history() exposes them as a list usable in pipelines
• No PATH walk, no fork, no exec — every builtin is a Rust function call. grep in stryke is faster than /usr/bin/grep on stryke datasets because there's no process boundary

Coexisting With Perl 5 Semantics

The shell-like builtins don't shadow Perl. Renamed where conflicts existed:

• alias stays a free Perl typeglob name (*alias = \&original); REPL alias table is repl_alias / set_alias
• do FILE remains Perl's file-eval; shell-style source is not added (single-spelling rule per CLAUDE.md "no dups")
• Names like open, close, read, write, print remain Perl 5 file-IO builtins with full Perl semantics; shell-equivalents (cat, tee, spurt) sit alongside as stryke extensions

Cold-start cost: < 10 ms from s to first prompt. The banner with reflection counts is computed on-demand from the actual %b / %a / %all tables — not hard-coded — so it always shows the current build's numbers.

AI Primitives — ai is a builtin like print

Two letters, ubiquitous, unlimited power. Agent loop, MCP client+server, RAG memory, vector search — all native to the language.

# Single-shot
my $r = ai "summarize this", $document

# Auto-routes to agent loop when tool fns are in scope
tool fn weather($city: string) "Get weather" {
    fetch "https://api.weather.com/" . uri_encode($city)
}
ai "what's the weather in Tokyo?"

# Vision, structured output, PDFs — all via the same `ai` call
my $caption = ai "describe", image => "/photo.jpg"
my $user    = ai "extract", schema => +{ name => "string", age => "int" }
my $summary = ai "summarize", pdf => "/contract.pdf"

# Streaming as a real iterator
for my $chunk in stream_prompt("write a haiku") { print $chunk }

# Collection ops — single batched LLM call across the list
my @kept = @{ ai_filter(\@docs, "is about cooking") }
my @summaries = @{ ai_map(\@articles, "summarize in one sentence") }

# RAG memory backed by sqlite
ai_memory_save("doc-1", "Stryke is the fastest Perl-5 interpreter")
my $hits = ai_memory_recall("which language is fast", top_k => 3)

# MCP server in one block
mcp_server "filesystem" {
    tool read_file($path: string) "Read file" { slurp $path }
    tool list_dir($path: string) "List dir"   { join("\n", readdir $path) }
}

Surface

Providers: Anthropic (full surface incl. extended thinking, prompt caching, vision, PDF, batch), OpenAI (chat + tool-calls + streaming, Whisper, TTS), Voyage (embeddings, default), Ollama, OpenAI-compatible (openai_compat — LM Studio / vLLM / llama-server, configurable STRYKE_AI_BASE_URL), Google Gemini. Mock with ai_mock_install + STRYKE_AI_MODE=mock-only for deterministic CI.

Full reference: docs/AI_PRIMITIVES.md.

Web Framework — s_web

Rails-shaped scaffold. Generator emits .stk source files; framework runtime is web_* builtins. The whole framework + your entire app + SQLite ships as a single cargo build --release binary via s_web build.

# One command — full-stack app, ~70 resources, dark cyberpunk theme,
# auth + admin + Dockerfile + GitHub Actions + PWA + migrations.
$ s_web new mega --app everything --theme cyberpunk \
    --auth --admin --docker --ci --pwa --migrate
$ cd mega && bin/server
# http://localhost:3000 — signup, login, /admin browses every model,
# /health, /docs (Swagger UI), /openapi.json, ~490 CRUD routes.

Highlights

Full reference: docs/WEB_FRAMEWORK.md and stryke_web/README.md.

Expect — Interactive Automation

PTY-driven scripting; the modern Tcl/Expect successor with native cluster fanout.

my $h = pty_spawn("ssh user@host")
pty_expect($h, qr/password:/, 30)
pty_send($h, "$pw\n")
pty_expect($h, qr/\$ /, 30)
pty_send($h, "uptime\n")
my $output = pty_expect($h, qr/\$ /, 30)
pty_close($h)

# Table form (Tcl `expect { ... }` block)
my $tag = pty_expect_table($h, [
    +{ re => qr/password:/, do => fn { pty_send($h, "$pw\n"); "ok" } },
    +{ re => qr/yes\/no/,   do => fn { pty_send($h, "yes\n"); "confirmed" } },
    +{ re => qr/denied/,    do => fn { die "auth failed" } },
], 30)

# Method-form sugar
my $h = PtyHandle::spawn("ssh host")
$h->expect(qr/password:/, 30)
$h->send("$pw\n")
$h->interact()   # raw-mode handoff, Ctrl-] to detach

# Parallel SSH automation across N hosts
my $cluster = cluster(["host1:8", "host2:8", "host3:8"])
pmap_on $cluster @hosts -> $host {
    my $h = pty_spawn("ssh $host")
    pty_expect($h, qr/\$ /, 30)
    pty_send($h, "apt update && apt upgrade -y\n")
    pty_expect($h, qr/\$ /, 1800)
    pty_close($h)
}

Full design: docs/expect-feature-idea.md.

Package Manager

Cargo-shaped manifest + lockfile, hash-pinned reproducible builds, parallel resolver. Single binary surface — no separate cargo-style entry point.

$ stryke new myapp                  # scaffold project at ./myapp/
$ cd myapp
$ stryke add http@^1.0 json         # write deps to stryke.toml
$ stryke install                    # resolve + write stryke.lock
$ stryke update                     # re-resolve and rewrite stryke.lock
$ stryke outdated                   # report deps drifted from their lock pin
$ stryke audit                      # lockfile vs vulnerability advisory feed
$ stryke tree                       # resolved dep graph
$ stryke info http                  # lockfile entry for a dep
$ stryke vendor                     # snapshot store deps to ./vendor/
$ stryke clean                      # wipe target/
$ stryke run greet                  # npm-style task from [scripts]
$ stryke install -g ../mytool       # link [bin] launchers into ~/.stryke/bin/
$ stryke build --release            # AOT-compile to single static binary

Project layout

myapp/
├── stryke.toml         # manifest (name, deps, [scripts], [bin], [workspace])
├── stryke.lock         # exact versions + integrity hashes
├── main.stk            # entry point
├── lib/                # module sources (require/use)
├── bin/                # additional executables
├── t/                  # tests (`stryke test t/`)
├── benches/            # benchmarks (`stryke bench`)
└── target/             # build outputs (gitignored)
    └── release/myapp   # ← native machine code, scp-ready

Workspaces

# stryke.toml at workspace root
[workspace]
members = ["crates/*"]

[workspace.deps]
shared = { path = "../shared" }     # one version pinned for the whole monorepo

# In any member's stryke.toml
[deps]
shared = { workspace = true }       # inherit version + features

Deps live globally in ~/.stryke/store/name@version/. No node_modules-shaped per-project tree. Every dep hash-pinned in the lockfile (Nix-style reproducibility, Cargo-style ergonomics). Status: path deps + workspaces + full CLI surface (new/init/add/remove/install/update/outdated/audit/tree/info/vendor/clean/run/install -g) are wired and tested today; registry/git deps + PubGrub semver land when the registry endpoint is deployed (search/publish/yank stubs already return clear "registry not deployed yet" diagnostics). Full design: docs/PACKAGE_REGISTRY.md.

Parallel primitives (highlights)

Every p* primitive uses rayon work-stealing, saturates all cores by default, and takes three surface forms:

# block form   ($_ = element, bare _ is shorthand for $_)
pmap { _ * 2 } 1:1_000_000

# expression form
pmap _ * 2, 1:1_000_000

# bare-fn form   (fn double { _ * 2 })
pmap double, 1:1_000_000

fan / pchannel / ppool

# fan — run a block N times in parallel (_/_0 = index 0:N-1)
fan 16 { heavy_work(_) }

# pchannel — bounded MPMC queue
my ($tx, $rx) = pchannel(100)
async { $tx->send(_) for 1:1000; undef $tx }
while (defined(my $v = $rx->recv)) { p $v }

# ppool — persistent worker pool
my $pool = ppool 4, fn {
  while (defined(my $j = $rx->recv)) { process($j) }
}
$tx->send(_) for @jobs;  undef $tx
$pool->join

Pipelines

# sequential (each stage drains list before next)
pipeline(
  fn { map { _ * 2 } @_ },
  fn { grep { _ > 10 } @_ },
  fn { sum(@_) },
)->run(1:1000)

# streaming — bounded crossbeam channels, concurrent stages
par_pipeline_stream([\&stage1, \&stage2, \&stage3], \@input)

Mutex / semaphore — blocking sync primitives

Backed by parking_lot::Mutex + Condvar — blocking lock / acquire wait on the condvar (no busy-wait, no spin). Arc-shared via StrykeValue::Mutex / StrykeValue::Semaphore so closure capture across spawn / fan shares the same primitive without needing mysync on the handle. Compose with defer for RAII — there's no lock { BLOCK } sugar because the basic shape already does the job.

# Mutex — protect a shared counter across spawn / fan workers
my $m = mutex()
mysync $counter = 0
fan 10000 {
    mutex_lock($m)
    defer { mutex_unlock($m) }
    my $old = $counter; $counter = $old + 1   # genuine read-modify-write
}
p $counter   # exactly 10000

# Semaphore — bound concurrent expensive workers to N
my $s = semaphore(4)
fan 100 {
    sem_acquire($s)
    defer { sem_release($s) }
    do_expensive_work(_)   # at most 4 in flight at any moment
}

# try_lock / try_acquire — non-blocking probes
if (mutex_try_lock($m)) {
    defer { mutex_unlock($m) }
    # critical section — only one worker runs this branch
} else {
    # fall through fast path
}

flock — cross-process advisory locks

For locks that survive a single stryke process (multi-process coordination via a lockfile), flock wraps the POSIX flock(2) syscall directly:

open(my $fh, ">", "/tmp/job.lock") or die
flock($fh, 2)             # LOCK_EX — blocking exclusive
defer { flock($fh, 8) }   # LOCK_UN
# critical section across processes

# non-blocking probe
if (flock($fh, 4)) {      # LOCK_NB | LOCK_EX
    defer { flock($fh, 8) }
    # got it
} else {
    # someone else holds the lock; bail or retry
}

Op constants match Perl 5: LOCK_SH=1, LOCK_EX=2, LOCK_NB|LOCK_EX=4, LOCK_UN=8. The lock is released automatically when the file descriptor closes — process crashes don't leak locks.

AOP — before / after / around advice

Aspect-oriented advice on user subs. Glob pointcuts, three advice kinds, AspectJ-style around with proceed(). Same surface as zshrs's intercept, adapted as keyword statements instead of a CLI builtin.

# before — sees $INTERCEPT_NAME, @INTERCEPT_ARGS
before "fetch" { warn "calling fetch with @INTERCEPT_ARGS" }

# after  — sees $INTERCEPT_RESULT, $INTERCEPT_MS, $INTERCEPT_US
after "fetch" { warn "fetch returned $INTERCEPT_RESULT in ${INTERCEPT_MS}ms" }

# around — block's value is the call's return; proceed() runs original
around "expensive" {
    my $cached = cache_get($INTERCEPT_ARGS[0])
    return $cached if defined $cached
    my $r = proceed()
    cache_put($INTERCEPT_ARGS[0], $r)
    $r
}

# Glob pointcuts: *, ?
before "log_*" { ... }
before "*"     { trace($INTERCEPT_NAME) }

# Management
intercept_list();   # [[id, kind, pattern], ...]
intercept_remove($id);
intercept_clear();

The leading keyword only commits to advice parsing when followed by a string literal, so before(...) as a normal sub call still works. The first matching around wraps; before/after on the same name all fire in registration order. Re-entrancy guard prevents infinite loops when an advice body calls the advised sub. Coverage: user-defined subs only.

Reserved Words

These cannot be used as function names (they are lexer-level operators or language keywords):

Attempting fn y { } or fn goto { } produces: `y` is a reserved word and cannot be used as a function name

Topic-slot names are also rejected: fn _, fn _<, fn _0, fn _N, fn _N<+, plus the sigil-prefixed forms fn $_, fn @_, and the package-qualified forms fn Foo::_, fn Pkg::_0. A user-defined sub by any of these names would shadow the topic in expression position and silently break every _-aware builtin. Names like fn _foo, fn _NAME, fn my_helper still work — only EXACT topic-slot spellings reject.

Range literals

The : range operator (and the !!! separator for IPv6) recognize several built-in literal types as a single token. The runtime expansion dispatches on the surface form so each type gets the right step semantics.

Hex case preservation — uppercase iff EITHER endpoint has any uppercase letter. 0x00:0xFF:1 emits 0x00, 0x01, …, 0xFF (uppercase wins from TO). Outside range context, 0xFF is still the integer 255 — only range-context lookahead triggers the string-typed literal.

Why ~ for IPv6 — IPv6 uses : internally; reusing it as the range separator would be ambiguous. The universal ~ separator dodges the collision and works for all range types. ! can't be used because it's the paired char-index delimiter ($x!N!); inside paired ~…~ char-index/slice subscripts ($x~5~, $_~1:3~) the range op is suppressed so closing delimiters don't get eaten.

Topic chain — _< and the positional matrix

Inside a closure (map/grep/sort block, sub body, fan/fan_cap), _< reads the topic of the enclosing scope — the value _ held in the frame that called this closure. The chain extends up to five frames: _<<, _<<<, _<<<<, _<<<<<. Numeric positional slots get the same matrix: _0<, _1<<, …, _N<<<<<. Bareword and sigil forms ($_<) are equivalent.

Indexed-ascent _<N — past depth 2, counting chevrons gets error-prone. The lexer accepts _<N (where N is a positive integer) as syntactic sugar for N chevrons: _<3 ≡ _<<<, $_2<5 ≡ $_2<<<<<. The disambiguator preserves slice syntax: _<3> and _<3:5> remain string slices; _<3 (without trailing > or :) is the indexed-ascent form.

# Nested map — `_<` reaches the outer iter's `_`:
map { my @inner = (1, 2); map { _< + _ } @inner } (10, 20)
# 11, 12, 21, 22

# Inside a 3-arg fn, _0<5 (≡ _0<<<<<) reaches arg 0 five frames up:
fn deep($_0, $_1, $_2) {
  ~> 1:1 map { ~> 1:1 map { ~> 1:1 map { ~> 1:1 map { ~> 1:1 map {
    p _0<5, _1<5, _2<5      # preferred: indexed form
    p _0<<<<<, _1<<<<<     # equivalent: chevron form
  } } } } }
}

Iter re-entry — the chain shifts on the FIRST set_topic call in a given frame; subsequent iterations of the same loop only refresh _, so _< keeps pointing at the enclosing scope's topic instead of rolling to the previous iter's value. Bound-but-undef chain entries fall back to _ so $h->{_<} at the outermost iter reads the iteration key.

Mutation semantics — topic variants align with |param| block params

A user writing $_ = ... or $_< = ... inside a block mutates only the current frame. Topic variants follow the exact same rule as |$x| block params and inner my $x: writes do not leak outward, and the chain shift on the next frame entry is purely a function of the outer topic value, never the inner mutation.

Implementation: strykelang/scope.rs::Scope::set_scalar recognizes topic-variant names via is_topic_variant_name (regex ^_[0-9]*<*$) and routes the write through Frame::set_scalar_raw, which bypasses the CaptureCell write-through that named outer-scope my variables use. Result: $_< always reads the lexical outer-scope topic of the current closure, never an in-flight mutation from a sibling iteration.

Coderef-in-block-position

Wherever a { BLOCK } is accepted in a per-element list operator (grep, map, sort, first, any, all, none, take_while, drop_while, reject, partition, min_by, max_by, plus their pipe-forward variants), a coderef-shaped expression also works directly. Runtime check: if the EXPR evaluates to a code ref, it is called with the current element(s) as positional args; otherwise the value's truthiness drives filtering (or its result becomes the mapped value, comparator integer, etc.). Eliminates the { $f($_) } / { $f->($_) } boilerplate.

# grep / map — single coderef, no block:
my $is_big = fn ($x) { $x > 3 }
my @r = grep $is_big, @l                  # was: grep { $is_big->(_) } @l
my @r = @l |> grep $is_big                # pipe-forward variant
my @doubled = map fn { _ * 2 }, @l        # inline coderef

# Sort comparators receive ($a, $b) positionally — no $a/$b global magic:
my $cmp = fn ($a, $b) { $b <=> $a }       # or fn { _0 <=> _1 } using positional aliases
my @s = sort $cmp @l

# Tier-2 builtins — no parens, no block:
my $r = first $is_big, @l
my $a = any $is_big, @l
my @t = take_while $is_big, @l
my @r = reject $is_big, @l                # inverse of grep

Threading ~> excluded — whitespace-delimited stages can't disambiguate ~> @l grep $f from "two stages", so threading still requires { $f(_) }. Use |> for the bare-coderef form, or stay with { } blocks under ~>.

Under --compat: dispatch is skipped, restoring Perl's "evaluate EXPR per element, filter by truthiness" semantics. A coderef value is always truthy, so grep $f, @l keeps every element under --compat.

Implicit zero-arg coderef from bare positional

At module top level, a my $f = … declaration whose RHS contains a free bare positional alias (_, _0, _1, _<, …; no $ sigil) is auto-wrapped as a zero-arg coderef. "Free" means at brace-depth 0 inside the RHS: a bare _ inside a nested fn { _ < 4 }, hash literal, map/grep/sort block, or match arm is bound by that block and doesn't trigger the wrap. Inside any block-bodied declaration site, bare _ is the bound topic, so this sugar only fires where _ would otherwise be unbound.

# at top level — all of these auto-wrap into `fn { … }`:
my $sq  = _ * _                  # → fn { _ * _ }
my $up  = uc _                   # → fn { uc _ }
my $rev = ~> _ >{split //, _} rev join ""
my $add = _ + _1                 # multi-arg via _1, _2, …
$sq->(5)                         # 25
$add->(3, 4)                     # 7

# nested fn { } binds inner _ → outer `my` stays eager:
fn call($f, $n) = $f->($n)
my $r = call(fn { _ < 4 }, 5)    # 0  — call() runs eagerly

# inside a block, _ is the topic — NOT auto-wrapped:
fn dbl { my $x = _; $x * 2 }     # $x captures the first arg
map { my $i = _; $i * 2 } 1:3    # $i captures each element

Thread-macro RHS — only the input expression counts

When the RHS starts with a thread-macro intro token (~>, ->>, ~>>, ~p>, ~s>, ~d>, and their -Last variants), the macro itself binds _ for every stage expression. Only the input expression immediately after the arrow can trigger the wrap — bare _ tokens inside stage call arguments are the threaded placeholder, not free topic reads.

# input is concrete (10) → eager; the `_` in div(_, 2) is the
# thread-last placeholder, not a free topic:
fn Demo::div = _0 / _1
my $r = ->> 10 Demo::div(_, 2)   # 5     — eager call

# input is a free bare `_` → wraps so the call site supplies it:
my $up = ~> _ uc                 # → fn { ~> _ uc }
$up->("ya")                      # "YA"

# input is concrete (an array) → eager even with `_` in stages:
my @r = ~> @nums map { _ * _ } grep { _ > 10 }

Forcing eager evaluation — use the $_ sigil

To opt out of the wrap and evaluate the RHS against the current topic, use the sigil-prefixed form $_ / $_0 / $_1 / $_<. Sigil-prefixed topic reads are eager by definition and never trigger the coderef sugar.

# bare _ → coderef (deferred)
my $sq = _ * _
p $sq->(5)                       # 25

# $_ sigil → eager evaluation against the current topic
$_ = 7
my $sq2 = $_ * $_
p $sq2                           # 49

# mixed: free bare _ wins → the whole RHS wraps,
# and $_ inside the closure reads the topic at call time:
my $mix = $_ + _                 # → fn { $_ + _ }
$mix->(3)                        # 6    (both $_ and _ are the arg)

Rule: the wrap fires only when (a) we're at block_depth == 0, (b) the LHS is a single scalar, (c) the RHS contains a free (depth-0 within the RHS) bare positional token — match wildcards inside match { _ => … } arms sit at depth ≥ 1 so they don't false-trigger, and a thread-macro RHS only counts the input expression after the arrow — and (d) the RHS isn't already a coderef-shaped value (fn { … }, \&name, \&{…}). Disabled under --compat.

Hash-key power forms

Stryke extends Perl's bareword autoquoting in three ways:

• Topic-slot barewords — _, _<, _0, _0<, _N<+ resolve to the topic value, not the literal name. { _ => 1 } ≡ { $_ => 1 }; $h->{_<} reads the outer-scope topic.
• Operator keywords — eq, ne, lt, gt, le, ge, cmp, and, or, not, x autoquote inside {…} hash subscripts. $h->{ne}, $h{eq}, etc. read normally.
• +{ EXPR } force-hashref — block-vs-hashref disambiguation falls back to a code block when the body doesn't fit KEY => VAL. The + prefix forces hashref interpretation; a list-yielding body is paired up to produce a hash. +{ map { ($_, $_ * 2) } (1,2,3) } gives {1 => 2, 2 => 4, 3 => 6}.

s,/tr,/y, with comma delimiter

The s, tr, and y operators accept any non-alphanumeric delimiter, including ,. The lookahead heuristic gates the comma form on having three commas before the statement ends, so $obj->y method calls and struct Pt { x, y, z } field declarations stay barewords.

Perl-compat highlights

• OOP — @ISA, C3 MRO (live, not cached), $obj->SUPER::method, tie for scalars/arrays/hashes with TIESCALAR/TIEARRAY/TIEHASH, plus EXISTS/DELETE; use overload with full binary dispatch, nomethod, unary neg/bool/abs. Native class syntax with inheritance, traits, abstract/final, visibility, static fields, operator overloading, and reflection — see OOP section below.
• Specials — $? packed POSIX status, $| autoflush, $. line count (undef until first read), @ARGV, %ENV, %SIG (SIGINT/SIGTERM/SIGALRM/SIGCHLD), format/write (partial).
• Phases — BEGIN / UNITCHECK / CHECK / INIT / END run in Perl order; ${^GLOBAL_PHASE} matches Perl.
• Interpolation — $var, #{expr}, $h{k}, $a[i], @a, @a[slice], $#a, $0, $1..$n; \x{hex} and unbraced \x.
• Strict / modules — per-mode use strict 'refs' etc., @INC built from -I, vendor/perl, system Perl's @INC, script dir, STRYKE_INC. List::Util is native Rust.

Full list in the README §0x08.

Object-Oriented Programming

Stryke supports both Perl 5 OOP (bless, @ISA, tie, use overload) and a native class syntax with inheritance, traits, visibility, static fields, operator overloading, and full reflection.

Class basics

Declare classes with typed fields, defaults, and instance methods. Fields get auto-generated getters/setters. $self is implicit in methods.

class Dog {
    name: Str
    breed: Str = "Mixed"
    fn bark { "Woof from " . $self->name }
}

my $d = Dog(name => "Rex")           # named construction
my $d = Dog("Rex", "Lab")             # positional construction
p $d->name                            # getter → "Rex"
$d->name("Max")                       # setter
p $d->bark()                          # "Woof from Max"

Methods with parameters

class Calculator {
    value: Int = 0
    fn add($n) { $self->value + $n }
}
my $c = Calculator(value => 10)
p $c->add(5)                          # 15

Static methods

class Math {
    fn Self.add($a, $b) { $a + $b }
    fn Self.pi { 3.14159 }
}
p Math::add(3, 4)                      # 7
p Math::pi()                           # 3.14159

Inheritance (extends)

Single and multiple inheritance. Parent fields and methods are inherited. C3 MRO for diamond resolution.

class Animal {
    name: Str
    fn speak { "Animal: " . $self->name }
}
class Dog extends Animal {
    fn speak { "Woof from " . $self->name }  # override
}
my $d = Dog(name => "Rex")
p $d->speak()                         # "Woof from Rex"

# multiple inheritance
class A { a: Int = 1 }
class B { b: Int = 2 }
class C extends A, B { c: Int = 3 }
my $c = C()
p $c->a . "," . $c->b . "," . $c->c  # "1,2,3"

Abstract classes

Cannot be instantiated directly. Subclasses must implement abstract methods.

abstract class Shape {
    name: Str
    fn describe { "Shape: " . $self->name }
}

# Shape(name => "x")  → ERROR: cannot instantiate abstract class

class Circle extends Shape { radius: Int }
my $c = Circle(name => "ring", radius => 5)
p $c->describe()                      # "Shape: ring"

Final classes and methods

final class prevents subclassing. final fn prevents method override in subclasses. Both checked at declaration time.

final class Config { value: Int = 42 }
# class Bad extends Config { }  → ERROR: cannot extend final class

class Base {
    final fn id { 42 }
    fn label { "base" }                # can be overridden
}
class Child extends Base { }
my $c = Child()
p $c->id()                            # 42 (inherited, cannot override)

Visibility (pub / prot / priv)

Applies to both fields and methods. Runtime enforcement on access.

class Secret {
    pub visible: Int = 1               # public (default)
    priv hidden: Int = 42              # own class only
    prot internal: Int = 99            # class + subclasses

    fn get_hidden { $self->hidden }    # internal access ok
}
class Child extends Secret {
    fn get_internal { $self->internal } # prot: ok from subclass
}
my $s = Secret()
p $s->get_hidden()                    # 42
# $s->hidden  → ERROR: private field

my $c = Child()
p $c->get_internal()                  # 99
# $c->internal  → ERROR: protected field (outside class hierarchy)

Static fields

Shared across all instances. Access via ClassName::field() (getter) / ClassName::field(value) (setter).

class Tracker {
    static total: Int = 0
    name: Str
    fn BUILD { Tracker::total(Tracker::total() + 1) }
}
my $a = Tracker(name => "a")
my $b = Tracker(name => "b")
p Tracker::total()                     # 2

BUILD / DESTROY hooks (custom constructor / destructor)

fn BUILD is the custom-constructor hook — runs automatically after field init, parent first then child. Use it for invariant checks, default-injection of computed fields, or post-init wiring. fn DESTROY is the destructor — runs automatically when the object is reaped, child first then parent. Both are method-name conventions the runtime auto-dispatches; no caller-side init step.

class Connection {
    host: Str
    port: Int = 5432
    socket: Any = undef
    connected_at: Float = 0

    # Custom constructor — auto-called after fields populate. Open the
    # socket, stamp the connect time, validate inputs.
    fn BUILD {
        die "host required" unless length $self->host
        $self->socket(open_tcp($self->host, $self->port))
        $self->connected_at(time())
    }

    # Destructor — auto-called on object reap. Close the socket.
    fn DESTROY {
        close_tcp($self->socket) if defined $self->socket
    }
}

my $c = Connection(host => "db.example.com")   # BUILD fires
# ... use $c ...
# DESTROY fires when $c goes out of scope

Inheritance ordering — parent BUILD first so child code can see parent invariants; child DESTROY first so subclass state unwinds before parent state:

class Base {
    log: Str = ""
    fn BUILD   { $self->log("base") }
    fn DESTROY { Base::audit(Base::audit() . "base,") }
    static audit: Str = ""
}
class Child extends Base {
    fn BUILD   { $self->log($self->log . "+child") }
    fn DESTROY { Base::audit(Base::audit() . "child,") }
}

my $c = Child()
p $c->log                             # "base+child"   (parent BUILD ran first)
$c->destroy()
p Base::audit()                       # "child,base,"  (child DESTROY ran first)

Runnable demo: examples/build_destroy.stk.

Traits

Interface contracts with required and default methods. Enforced at class declaration.

trait Loggable {
    fn log_prefix { "LOG" }            # default (optional to implement)
    fn log_msg                         # required (no body)
}

class Event impl Loggable {
    msg: Str
    fn log_msg { $self->msg }
}
my $e = Event(msg => "hello")
p $e->log_msg()                       # "hello"
p $e->does("Loggable")               # 1

# Missing required method → compile-time error
# class Bad impl Loggable { }  → ERROR: missing required method 'log_msg'

Late static binding (static::)

Resolves to the runtime class of $self, unlike SUPER:: which is compile-time.

class Base {
    fn class_name { static::identify() }
    fn identify { "Base" }
}
class Child extends Base {
    fn identify { "Child" }
}
my $c = Child()
p $c->class_name()                    # "Child" (not "Base")

Operator overloading

Define op_add, op_sub, op_mul, op_div, op_mod, op_pow, op_eq, op_ne, op_lt, op_gt, op_le, op_ge, op_spaceship, op_neg, op_bool, op_abs, op_concat, stringify, and more.

class Vec2 {
    x: Int
    y: Int
    fn op_add($other) {
        Vec2(x => $self->x + $other->x, y => $self->y + $other->y)
    }
    fn op_neg { Vec2(x => -$self->x, y => -$self->y) }
    fn stringify { "(" . $self->x . "," . $self->y . ")" }
}
my $a = Vec2(x => 1, y => 2)
my $b = Vec2(x => 3, y => 4)
my $c = $a + $b
p "$c"                                 # "(4,6)"
my $d = -$a
p "$d"                                 # "(-1,-2)"

Reflection / introspection

class Animal { name: Str; fn speak { "..." }; fn eat { "nom" } }
class Dog extends Animal { breed: Str }
my $d = Dog(name => "Rex", breed => "Lab")

p join(",", $d->fields())             # "name,breed"
p join(",", $d->methods())            # "speak,eat"  (inherited)
p join(",", $d->superclass())         # "Animal"
p $d->isa("Dog")                      # 1
p $d->isa("Animal")                   # 1  (inherited)
p $d->isa("Cat")                      # ""  (false)

Built-in instance methods

Field types

Runtime validation on setter. Float accepts both int and float. Custom types (struct/enum names) also work.

class Typed {
    count: Int               # integer
    name: Str                # string
    ratio: Float             # int or float
    items: Array             # array reference
    map: Hash                # hash reference
    any_val                  # untyped (Any)
}

Extensions beyond stock Perl 5

• Native data — CSV (csv_read/csv_write), columnar dataframe, embedded sqlite, TOML/YAML helpers.
• HTTP — fetch / fetch_json / fetch_async / par_fetch.
• Crypto / compression — sha256, hmac_sha256, jwt_encode/decode, gzip / gunzip / zstd.
• Standalone binaries — s build SCRIPT -o OUT bakes a script into a self-contained executable.
• Inline Rust FFI — rust { pub extern "C" fn ... } blocks compile to a cdylib on first run, dlopen + register as Perl-callable subs.
• Bytecode cache — single rkyv shard at ~/.stryke/scripts.rkyv, mmap + zero-copy ArchivedHashMap lookup, skips lex/parse/compile on warm starts. 11x faster per-process than the old SQLite cache. stryke test FILE participates in the same cache so test reruns skip compile too. Disable with STRYKE_CACHE=0. Migration story & benchmarks →
• Interactive REPL — reedline-based, line history at ~/.stryke/history, columnar tab completion for keywords / lexicals / sub names / arrow methods on blessed objects. Edit mode (emacs/vi) configured via ~/.stryke/config.toml [repl] mode = "vi" or per-session via STRYKE_REPL_MODE=vi. The config file is auto-seeded on first launch with all keys commented (documents the schema; default behavior unchanged until you uncomment).
• Distributed compute — cluster([...]) builds an SSH worker pool; pmap_on $cluster { } @list fans an element-wise map across persistent remote workers; ~d> on $cluster SRC stages ships chunks of SRC to remote slots and runs the full stage chain per chunk (the ~p> surface, distributed). Both share the same dispatcher: ssh-per-slot handshake once, JOB frames per item, per-job retry, order-preserving collect.
• Shared state — mysync declares atomic variables safe to mutate from parallel workers.
• Mutex / semaphore primitives — mutex() and semaphore($n) return blocking sync primitives backed by parking_lot::Mutex + Condvar (no busy-wait). Pair with defer { mutex_unlock($m) } for RAII across spawn / fan / ~p> workers. Surface: mutex_lock, mutex_unlock, mutex_try_lock, mutex_is_locked; semaphore_acquire, semaphore_release, semaphore_try_acquire, semaphore_permits, semaphore_limit (all with sem_* aliases). For cross-process locking, flock($fh, OP) calls the POSIX advisory-lock syscall directly (LOCK_SH=1, LOCK_EX=2, LOCK_NB|LOCK_EX=4, LOCK_UN=8).
• Language server — s lsp (or s --lsp) runs an LSP server over stdio with diagnostics, hover, completion. The nine reflection hashes above are part of the completion surface.

Language server (stryke --lsp)

One binary, two roles: stryke runs scripts AND speaks LSP over stdio. Wire it into any LSP-aware editor — VS Code, JetBrains, Neovim, Helix — by pointing the client at stryke --lsp. No separate stryke-lsp binary to maintain.

Diagnostics

Strict-vars is on by default in the IDE (CLI stryke check stays lenient — gated on explicit use strict;), so undefined $scalar / @array / %hash typos surface inline without per-file opt-in. Sensible exemptions baked in:

• Bare sigil-vars inside double-quoted string interpolations ("got $fh ..." is template/description text — no false positives on test descriptions).
• Perl $^X / $^O / $^V / $^W family special vars, plus bare $$ (process id).
• AOP advice-body context vars: $INTERCEPT_NAME, @INTERCEPT_ARGS, $INTERCEPT_RESULT, $INTERCEPT_MS, $INTERCEPT_US.
• The full block-param grammar: _, _N, _<, _<N, _<<<<<, _N<<<<<, _N<M, plus all sigiled forms ($_, $_<3, $_<<<<<, …).
• $#arr last-index references resolve via @arr (inside strings too — "got $#arr items" is OK).
• open(my $fh, ...) lexical filehandle declarations register $fh in scope.
• exists(&Pkg::sub) introspection skips the sub-defined check — the point is to ask whether the sub exists.
• Parser-internal _thread_par_run desugaring targets emitted by ~p> / ~s> thread macros.

OOP-aware checks

• Constructor key validation. Class(field => v, ...) and Class->new(...) validate keys against declared fields. Walks extends parents and impl traits — Dog extends Animal accepts Dog(name => "Rex", breed => "Lab") where name is on Animal.
• Positional vs keyed auto-detection. Task(1, "title", Priority::High) is recognized as positional (first arg isn't a field name) and skipped — only fat-comma-style calls get the key check.
• Method lookup walks the inheritance chain. $self->method / $obj->method resolve via the full extends + impl graph, BFS-style, cycle-guarded. class Person impl Greetable with fn greeting on the trait resolves $p->greeting() correctly.
• Universal-method whitelist — isa, can, DOES, does, VERSION, new, BUILD, DESTROY, clone, with, to_hash, to_hash_rec, to_hash_deep, fields, methods, superclass never flag (runtime provides them on every instance).
• Match-arm enum-variant typos flagged. Sig::Term2 => when Sig has variants Hup, Int, Term, Kill emits "no variant Term2 on Sig; available: Hup, Int, Kill, Term".

Cross-file require

require "./lib/Foo/Bar.stk" walks up from the source file looking for the project root (any ancestor with a sibling lib/ directory) — the classic Perl/CPAN layout. Subs, classes, traits, enums, constants declared in required files all join the active completion + diagnostics index. Falls back to the source file's own directory for simple sibling-script cases.

Completion

Every identifier category the editor expects:

• Sigil variables — declared via my / our / state / local / mysync / oursync, foreach my $x, sub signature params, open(my $fh, …) filehandle decls.
• Subs — bare and qualified, with suffix-only insertText for qualified completions (typing Demo::│ produces Demo::handle, not Demo::Demo::handle).
• User-declared Types — classes (CompletionItemKind::CLASS), structs (STRUCT), enums (ENUM), traits (INTERFACE), plus every enum variant as a qualified EnumName::Variant.
• Constants from use constant NAME => … and the use constant { A => 1, B => 2 } hash form.
• Loop labels for last LOOP / next LOOP / redo LOOP.
• Hash-key completion driven by builtin return schemas. my $info = pool_info(); $info->{cursor} lists the actual keys pool_info returns (cpus, rayon_threads, arch, os, perf_cores, eff_cores). Same registry covers par_bench, stress_test, cache_stats, uname, audio_info, id3_read, git_log, git_show, git_status, git_branches, git_blame, git_authors, du_tree, process_list, net_interfaces, perfview, mounts, html_parse, css_select, xml_parse, xpath. foreach my $row (git_log()) { $row->{cursor} } also resolves through the loop-var binding.
• Stryke keywords (fn, class, struct, enum, trait, match, mysync, frozen, …) and ~10k builtins from %all.
• In-progress parse recovery — cursor inside a fragment that breaks the parse (Demo::│) retries with the cursor's line blanked so the rest of the file still indexes.
• Trigger characters include { so $h->{ / $h{ auto-popup the relevant key set.

Hover

Full markdown cards for every builtin, special variable, AOP keyword, phase block, and reflection-hash alias. Hash-returning builtins ship full key tables — pool_info()'s hover lists every key with type + meaning. Hover is suppressed inside string literals ("length" in a string doesn't pop the length builtin doc) but still fires inside #{ EXPR } interpolations (real code).

Refactor

Goto / References / Rename — package-aware. Rename of struct/class/enum/trait fields and methods is AST-based with no textual fallback, so my %h = (width => 1) is never mistaken for a field reference when renaming width. The server defensively strips a :: qualifier from newName so clients that send the full prefilled identifier still produce the correct bare replacement. Cross-file rename walks the require graph BFS-style.

Extract Variable / Constant / Parameter / Function (Cmd-Opt-V / -C / -P / -M), Wrap-in-p, toggle line comment. Extract works on caret-only (no manual selection needed) and inside double-quoted strings / backticks.

JetBrains plugin (editors/intellij/)

First-class plugin for RustRover, IDEA Ultimate, GoLand, PyCharm Pro, WebStorm, RubyMine, PhpStorm, CLion, Rider, DataGrip, Aqua. .stk file association, 48-slot color scheme, hand-rolled lexer with finer-grained token categories (declaration vs control keywords, sigil variants, topic / block-param / special-var splits, pipe / arrow / range / regex-bind operators). The lexer correctly handles:

• Every Perl regex-operator form as one atomic REGEX token — s/PATTERN/REPL/FLAGS, tr/.../.../, y/.../.../, m/.../, qr/.../ — including embedded quote chars (s/"/""/g), paired-bracket delimiters (s{foo}{bar}), and mixed delimiters.
• Keyword spellings used as method names (fn state, fn transition) tokenize as FUNCTION_DECL, not the matching control/decl keyword.
• Keyword spellings used as hash keys ($h->{state}, state => 1) tokenize as IDENTIFIER.
• Perl-style @{[ EXPR ]} array-ref interpolations inside double-quoted strings tokenize the interior as code.
• The full block-param grammar (_, _<, _<2, _<<<<<, $_<3, $_2<<<) lexes as single BLOCK_PARAM tokens.
• <<TAG heredocs after a closing } (block close) correctly tokenize as HereDoc, not ShiftLeft. Numeric/sigil RHS still hits ShiftLeft so 1 << 4 and $x << $shift still work.

LSP client wired to stryke --lsp — completion, hover, goto / refs / rename, semantic tokens, signature help, code actions, folding ranges, document formatting (Cmd-Opt-L), diagnostics. Rename dialog prefills with the bare segment (no ::-walking) so editing Red → Redgg doesn't accidentally qualify the result as TrafficLight::Redgg. Run configurations with --no-interop / --disasm / --profile / --flame / -d toggles. Debugger over DAP. Reflection tool window with searchable trees of every reflection hash. Build with ./gradlew buildPlugin and install the zip from editors/intellij/build/distributions/.

CLI flags (common)

-e CODE                // one-line program (multiple -e's allowed)
-E CODE                // like -e, but enables all optional features
-c                     // syntax check only
--lint / --check       // parse + compile bytecode without running
--disasm               // print bytecode disassembly before VM run
--ast                  // dump parsed AST as JSON and exit
--fmt                  // pretty-print parsed Perl to stdout and exit
--profile              // wall-clock profile stderr (flamegraph-ready)
--flame                // flamegraph: terminal bars (TTY) or SVG
--no-jit               // disable Cranelift JIT (bytecode interpreter only)
--compat               // Perl 5 strict-compat: disable all stryke extensions
-n / -p / -i           // stdin line-mode + in-place edit
-j N                   // parallel threads for multi-file execution
--script               // force script lookup when name conflicts with builtin
-d -- SCRIPT           // TTY debugger (perl -d style REPL on stdin/stderr)
--dap                  // DAP server over stdio (Debug Adapter Protocol)
--dap HOST:PORT        // DAP server over TCP (JetBrains plugin transport)
--lsp                  // LSP server over stdio (semantic tokens, hover, ...)

// Subcommands
s build SCRIPT -o OUT  // AOT compile to standalone binary
s build --project DIR  // bundle project (main.stk + lib/) into binary
s check FILE...        // parse + compile without executing (CI/editor)
s disasm FILE          // disassemble bytecode
s profile FILE         // run with profiling (--flame for SVG)
s fmt -i FILE...       // format source files in place
s bench                // run benchmarks from bench/ or benches/
s test                 // run tests from t/
s init NAME            // scaffold new project (lib/, bench/, t/)
s repl --load FILE     // REPL with pre-loaded file
s lsp                  // language server over stdio
s completions zsh      // emit shell completions
s ast FILE             // dump AST as JSON
s prun FILE...         // run multiple files in parallel
s convert FILE...      // convert Perl to stryke syntax
s deconvert FILE...    // convert stryke back to Perl
s --remote-worker      // worker process for distributed cluster

Command Resolution Hierarchy

When you run stryke ARG, resolution follows this order:

1. Subcommand — build, docs, fmt, test, bench, init, repl, run, serve, check, disasm, profile, lsp, ast, prun, convert, deconvert, completions, agent, controller
2. Builtin function — if ARG is a known builtin AND no file named ARG exists, call ARG(@ARGV) and print result
3. Script file — if file exists, run as script
4. Inline code — if ARG looks like code (contains operators, parens, etc.), execute as one-liner

Use --script to force script lookup when a builtin name conflicts with a script file.

# Call builtins directly from CLI
s pin                       # calls pin() — 100% TDP forever
s heat 60                   # calls heat(60) — 100% TDP for 60s
s basename /foo/bar/baz.txt # calls basename(@ARGV) → "baz.txt"
s dirname /foo/bar/baz.txt  # calls dirname(@ARGV) → "/foo/bar"
s gethostname               # calls gethostname() → hostname
s avg 1 2 3 4 5             # calls avg(@ARGV) → 3

# Aliases work too
s bn /foo/bar/baz.txt       # basename alias
s dn /foo/bar/baz.txt       # dirname alias
s hn                        # gethostname alias
s faf                       # fire_and_forget alias (same as pin)

# Force script when name conflicts
s --script basename         # run ./basename script, not builtin

Editor tooling — LSP, DAP debugger, JetBrains plugin

The same stryke binary that runs scripts also serves Language Server Protocol and Debug Adapter Protocol — no separate stryke-lsp / stryke-dap binaries to install. Editors point their LSP/DAP clients at stryke --lsp / stryke --dap and get hover docs, completion, semantic tokens, line breakpoints, step over/into/out, and recursive variable drill-down.

LSP — stryke --lsp

• Hover over any builtin → category + signature + description from %stryke::descriptions / %stryke::categories (4,255 documented names)
• Completion with full builtin set (every spelling in %all — 11,191 keys including 643 aliases)
• Semantic tokens — keywords, builtins, sigils, types, regex flags get distinct token categories so themes can paint them independently
• Signature help on function-call cursor
• Code actions — server-side fix suggestions for common diagnostics
• Go-to-definition for user subs + classes + structs + enums

DAP debugger — stryke --dap

Standard Debug Adapter Protocol over stdio or TCP. Same Debugger state machine the TTY REPL (stryke -d) uses — breakpoints, step modes, scope inspection, call-stack tracking all shared. Just two front-ends on one core.

• Line breakpoints — gutter clicks fire on the exact source line; lexer-line drift fixed so class declarations don't poison subsequent BPs
• Function breakpoints — stop on entry to any named sub
• Step over / step into / step out — depth-tracking on every UDF entry/exit so step-over stays in the current frame instead of diving into call sites
• Pause / Continue / Run-to-Cursor
• Recursive Variables panel — every hash, array, struct, enum variant, class instance, and sketch (TDigestSketch, BloomFilter, HllSketch, CmsSketch, TopKSketch) expands inline. Class fields show visibility markers (+pub, #protected, -priv) plus the __class / __isa chain
• Magic-block-param sort — user my $foo vars first, then topic family ($_, $_0, $_1, …), then $a/$b, then runtime builtins. Compiler-synthetic __foreach_i__ etc. hidden
• Evaluate dialog with scalar prelude injection so $a * $b returns the right value from the paused frame
• Console output — p / print / say stream into the IDE Console in real-time (forced $| = 1 autoflush in DAP mode)

JetBrains plugin — editors/intellij/

First-class JVM plugin for the entire JetBrains paid lineup: RustRover, IDEA Ultimate, GoLand, PyCharm Pro, WebStorm, RubyMine, PhpStorm, CLion, Rider, DataGrip, Aqua. Built on the IntelliJ Platform Gradle Plugin 2.16.0, Kotlin 2.0.21, JDK 17, SDK 2024.2.4 against builds 242..261.*. Community editions don't have the LSP API and won't load the plugin. Talks to the in-tree strykelang/lsp_extras.rs + strykelang/dap.rs over JSON-RPC; no upstream lsp-server / dap-types crates anywhere on the Rust side. JetBrains' own LspServerSupportProvider is the only LSP4J consumer. Compiled build/distributions/stryke-intellij-<v>.zip is self-contained: only Kotlin stdlib + IntelliJ Platform classes at runtime. Full source-of-truth feature list lives in editors/intellij/README.md.

Install

# Settings → Plugins → ⚙ → Install Plugin from Disk…
editors/intellij/build/distributions/stryke-intellij-<version>.zip

After install: restart the IDE → open any .stk file → the LSP starts automatically → the debugger activates the first time you click Debug. The stryke (or st) binary must be on $PATH, or configured under Settings → Tools → Stryke → Stryke executable. The plugin tries st first, then stryke.

Editor surfaces

Lexer token coverage

LSP capabilities

The LSP server is in-process inside the stryke binary — stryke --lsp (or st --lsp) spawns it over stdio with Content-Length-framed JSON-RPC. Hand-rolled framer on top of serde_json — no lsp-server / lsp-types crates. Plugin side starts it via StrykeLspServerSupportProvider.kt; descriptor in StrykeLspServerDescriptor.kt. Optional STRYKE_LSP_LOG=<path> env var dumps every request/response for debugging.

Completion snippets (60 templates)

Tab walks the ${1:...} placeholders to the final ${0} cursor:

Code actions

Surfaced under Alt-Enter (intentions popup). The IntelliJ Refactor menu (Ctrl-T) is reserved for native PSI-based refactorings; LSP-driven extract / inline / rewrite kinds show up in the intentions popup, not under that menu. All three Extract actions use kind: "refactor.extract" (parent kind), so they match refactor.extract.method / .variable / .constant queries via prefix.

Reflection tool window (9 tabs)

View → Tool Windows → Stryke (right edge). Fed live from stryke -e 'p tj({%stryke::*})' on first open (≈25k entries):

Each tab is a tree grouped by category, with a per-tab search field filtering across name + category.

Run configurations

DAP debugger

DAP-backed, over a loopback TCP socket. Plugin spawns st --dap 127.0.0.1:<port>; stryke connects back. TCP transport keeps OSProcessHandler stdout/stderr free for the program's own p/print output.

DAP protocol — plugin and server flow

Plugin side (com.menketechnologies.stryke.dap):

1. StrykeDebugRunner.doExecute opens a ServerSocket(0) on 127.0.0.1, captures the port.
2. Spawns st --dap 127.0.0.1:<port> via KillableColoredProcessHandler — OSProcessHandler keeps the process's stdio for Console output, exclusively.
3. Waits up to 10 s for stryke to connect back, then runs DAP over that socket.
4. Creates an XDebugSession via XDebuggerManager.startSession and returns the descriptor via getMockRunContentDescriptorIfInitialized reflection — bypasses the platform's split-debugger Logger.error("[Split debugger] …") toast that the deprecated runContentDescriptor getter fires.
5. StrykeDebugProcess.createConsole builds a ConsoleView and attachToProcess(processHandler) so program stdout streams in real time.
6. StrykeDapClient reads Content-Length-framed JSON-RPC from the socket — byte-based, not char-based — so multi-byte UTF-8 in variable reprs doesn't desync framing.
7. On stopped event, onStopped synchronously fetches stackTrace + scopes + variables, builds StrykeStackFrame objects with pre-populated children, calls session.positionReached. No async expansion on the UI thread — IntelliJ 2026.1's split-debugger drops those.
8. StrykeEvaluator sends evaluate requests for the Evaluate dialog; stryke does scalar-prelude injection so $a * $b returns the right value from the paused frame.

Stryke side (strykelang/dap.rs + strykelang/debugger.rs):

• Debugger state machine (breakpoints, step modes, call depth) shared between TTY and DAP front-ends. Step-over depends on enter_sub / leave_sub being called at every VM call dispatch site so call_depth matches the program's logical call stack — without these hooks step-over drops into UDFs instead of skipping them.
• Same-line guard tracks both last_stop_line and last_stop_depth. Without the depth half, step-in fires on the same source line as the call site (first opcode of the call setup has the same line as my $r = foo()), requiring two clicks to actually enter foo.
• set_topic for implicit for (@arr) { … } loops so $_ / $_0 / _ / _0 all alias.
• Snapshot capture (capture_locals_with_map) walks the scope, builds per-variable refs for hashes / arrays / structs / classes / enums / sets / sketches, recursively expanding their children into a var_ref_map (depth 12, count 2000) so the DAP variables request resolves any ref to its rows.
• stdout/stderr autoflush + flush on every pause so output lands in the Console before the suspend UI takes over.

Refactor / Rename

Shift-F6 on any of these identifiers renames it across the workspace via textDocument/rename:

• Scalar / array / hash variables ($x, @xs, %h) — the sigil is included in the identifier extraction, so $pass and the pass builtin no longer collide.
• my / state / our declarations (and the frozen my constant form).
• Subroutine / function declarations (fn, sub).
• Struct / class / enum / trait names and their constructor / method call sites (Point->new, Color::Red).
• Package names declared via package Foo::Bar;.

Cross-file rename fires when the symbol is package-scoped (sub, type, our, package). The server scans every other open document, finds exact-name matches in its SymbolTable, and falls back to a textual qualified-name scan for files that reference the symbol without re-declaring it. Locally-scoped my / state decls and sub parameters are file-scoped and never cross files. Rename of struct/class/enum/trait fields and methods is AST-based with no textual fallback, so my %h = (width => 1) is never mistaken for a field reference when renaming width. The server defensively strips a :: qualifier from newName so clients that send the full prefilled identifier still produce the correct bare replacement. Hovering on the format key in $opts{format} or the exec selector in $db->exec does NOT show the format / exec builtin card — those are hash keys / method selectors, not builtin references. Implementation: StrykeRenameHandler.kt + strykelang/lsp_extras.rs::rename.

Configuration — Settings → Tools → Stryke

Logs

Two append-only logs, both under ~/.stryke/ (or $STRYKE_HOME/ when set):

Tail both with tail -f ~/.stryke/stryke.log ~/.stryke/stryke-plugin.log. Server-side level controlled by $STRYKE_LOG_LEVEL (trace / debug / info default / warn / error, case-insensitive). Rotation: STRYKE_LOG_MAX_BYTES (default 5242880 = 5 MiB; 0 disables) + STRYKE_LOG_MAX_FILES (default 5). When the active log hits the cap, stryke.log.N-1 shifts to stryke.log.N (eldest overwritten), then active moves to stryke.log.1. Default bounds the log dir at ≈(N+1) × MAX_BYTES = ~30 MiB. $STRYKE_LOG_FILE=/abs/path/to.log overrides the resolved path entirely (used by tests + sandbox runs). Per-IDE chatter still goes to idea.log via Logger.getInstance(...).

Building

cd editors/intellij
./gradlew buildPlugin             # → build/distributions/stryke-intellij-<v>.zip
./gradlew runIde                  # launches a sandbox IDE with the plugin installed
./gradlew verifyPlugin            # plugin verifier against recommended IDE matrix
./gradlew test                    # StrykeLexerTest + StrykeColorSettingsPageTest + StrykeSmartEnterProcessorTest

First build downloads the IntelliJ Platform SDK (~1 GB), takes a few minutes, and is cached under editors/intellij/.intellijPlatform/ (gitignored).

Plugin architecture

editors/intellij/
├── build.gradle.kts                   # IntelliJ Platform Gradle Plugin 2.16
├── gradle.properties                  # platform version, plugin version, JVM
├── settings.gradle.kts
└── src/main/
    ├── kotlin/com/menketechnologies/stryke/
    │   ├── StrykeLanguage.kt          # Language singleton
    │   ├── StrykeFileType.kt          # .stk → Stryke
    │   ├── StrykeIcons.kt             # icon loader
    │   ├── StrykeColors.kt            # 48 STRYKE_* TextAttributesKey constants
    │   ├── StrykeTokenTypes.kt        # token type enum
    │   ├── StrykeLexer.kt             # hand-rolled lexer
    │   ├── StrykeSyntaxHighlighter.kt # token → color mapping
    │   ├── StrykeColorSettingsPage.kt # IDE color-scheme entries
    │   ├── StrykeBraceMatcher.kt      # {} () []
    │   ├── StrykeCommenter.kt         # `#` line comments
    │   ├── StrykeQuoteHandler.kt      # " ' ` / m{} qr// auto-pair
    │   ├── StrykeSmartEnterProcessor.kt # indent + auto-close blocks
    │   ├── StrykeParserDefinition.kt
    │   ├── StrykeSettings.kt          # persistent settings
    │   ├── StrykeSettingsConfigurable.kt
    │   ├── StrykeDebugLog.kt          # plugin-side log writer
    │   ├── lsp/
    │   │   ├── StrykeLspServerSupportProvider.kt
    │   │   └── StrykeLspServerDescriptor.kt
    │   ├── refactor/
    │   │   ├── StrykeRefactoringSupportProvider.kt   # Extract Method/Var/Const routing
    │   │   └── StrykeRenameHandler.kt
    │   ├── navigate/
    │   │   └── StrykeGotoDeclarationHandler.kt       # Cmd-click + Cmd-B
    │   ├── actions/
    │   │   ├── RunStrykeFileAction.kt
    │   │   └── CreateStrykeFileAction.kt              # File → New → Stryke File
    │   ├── run/
    │   │   ├── StrykeRunConfigurationType.kt
    │   │   ├── StrykeRunConfigurationOptions.kt
    │   │   ├── StrykeRunConfiguration.kt
    │   │   ├── StrykeRunConfigurationEditor.kt
    │   │   ├── StrykeRunConfigurationProducer.kt
    │   │   ├── StrykeProgramRunner.kt    # Run executor
    │   │   └── StrykeDebugRunner.kt      # Debug executor (DAP)
    │   ├── dap/
    │   │   ├── StrykeDapClient.kt        # byte-based DAP protocol client
    │   │   ├── StrykeDebugProcess.kt     # XDebugProcess
    │   │   ├── StrykeDebuggerEditorsProvider.kt
    │   │   ├── StrykeBreakpointType.kt   # xdebugger.breakpointType
    │   │   ├── StrykeBreakpointHandler.kt
    │   │   ├── StrykeStackFrame.kt
    │   │   ├── StrykeSuspendContext.kt
    │   │   ├── StrykeValue.kt            # XValue with recursive children
    │   │   └── StrykeEvaluator.kt        # Evaluate dialog backend
    │   └── toolwindow/
    │       └── StrykeReflectionToolWindow.kt
    └── resources/
        ├── META-INF/plugin.xml
        └── icons/stryke.svg

Rust-side counterparts:

Version compatibility

Plugin version tracks the strykelang Cargo version. gradle.properties controls the supported IDE range via pluginSinceBuild / pluginUntilBuild. Currently targets 2024.2.4 SDK against builds 242..261.* — every paid JetBrains IDE on 2024.2 + loads it (RustRover, IDEA Ultimate, GoLand, PyCharm Pro, WebStorm, RubyMine, PhpStorm, CLion, Rider, DataGrip, Aqua). Community editions don't have the LSP API and won't load the plugin.

Limitations

• No PSI tree or structural navigation — relies entirely on the LSP for symbol navigation. Disabling the LSP under Settings disables them all.
• Debugger v1: no conditional or hit-count breakpoints, no exception breakpoints, no watch expressions, no Set Value, single-thread only. Step-into across used modules works only if the called sub has line mapping in the same compilation unit.
• Evaluator injects only scalars from the current frame. Expressions referencing user-defined @arr / %hash see them as empty in the subprocess. Builtins / globals (@INC, %ENV, etc.) work.
• Lexer is a regex-class scanner; complex constructs (heredocs, qw(), nested string interpolation) are not fully tokenized — they fall back to "string". Server-side semantic tokens fill in where the lexer is approximate.
• [Split debugger] toast on Debug start — the IDE's deprecated XDebugSession.runContentDescriptor accessor fires Logger.error even when bypassed via reflection if any third-party code touches it during session bring-up. JetBrains' own debug runners suffer the same noise in 2024.3+. Cosmetic only; the debugger works.
• Reflection hashes (%stryke::*) populate lazily on first user access in DAP mode (eager ensure_reflection_hashes triggers a VM stack overflow that's still TBD). The standalone Stryke tool window fetches them via st -e and is unaffected.

Other editors

• Neovim — editors/stryke.lua + ALE / vim-lsp / coc.nvim integration via stryke --lsp
• Vim — editors/stryke.vim
• Helix — editors/helix-languages.toml
• VS Code — coc + editors/vscode-settings.json bridge

Bytecode Cache (rkyv)

stryke caches compiled bytecode in a single rkyv-archived shard at ~/.stryke/scripts.rkyv. First run of a script parses + compiles + persists into the shard. Every subsequent run mmaps the shard, validates the archived root once, looks up the entry by canonical path in a zero-copy ArchivedHashMap, and skips lex/parse/compile entirely.

stryke my_app.stk    # cold: parse + compile + write to shard
stryke my_app.stk    # warm: mmap shard + lookup + dispatch

Why rkyv (and not SQLite, like before)?

The original cache was a SQLite database — port of an early zshrs design. We migrated to rkyv shards in v0.10.3. Apples-to-apples bench (strykelang/cache_bench.rs, 100 scripts, M-series, OS page cache warm):

The per-process number is the one that matters for s test t — each test file spawns a fresh process that opens the cache, does one lookup, exits. SQLite pays its full Connection::open + WAL pragmas + statement prepare cost on every process; rkyv pays one mmap + one check_archived_root validation, then ArchivedHashMap::get.

The 3.2× size growth is the zstd compression we dropped on the inner blobs (kept bincode for now — phase 2 will derive Archive directly on Chunk/Program for true zero-copy load). Disk size is acceptable: 1000+ scripts cached in ~15 MB.

Cache invalidation

Four conditions evict an entry — no stale bytecode is ever served:

• Source mtime mismatch — edit a .stk file → cache miss → recompile.
• stryke_version mismatch — Cargo version bump.
• Pointer-width mismatch — cross-build between 32- and 64-bit targets.
• Binary mtime newer than cached entry — any cargo build advances the binary's mtime → every cached script invalidates automatically. Catches edits to compiler.rs / parser.rs / vm.rs that don't bump CARGO_PKG_VERSION.

Inspection & tuning

cacheview()                    # list all cached scripts
cacheview("pattern")           # filter by path
cacheview("--count")           # just the count
cache_stats()                  # {count, bytes, path, enabled}
cache_exists("script.stk")     # 1 if cached, 0 if not
cache_clear()                  # wipe the cache

STRYKE_CACHE=0 stryke app.stk  # disable caching for this run

Bypassed for -e / -E one-liners, -n / -p, --lint, --check, --ast, --fmt, --profile modes. Cache is enabled by default for file-based scripts.

Aligned with zshrs

Same rkyv shard pattern as zshrs/src/daemon/shard.rs — mmap + check_archived_root + zero-copy ArchivedHashMap lookup. zshrs uses per-source-tree shards driven by a daemon; stryke uses a single global shard since scripts are individually invoked. Same crate (rkyv = "0.7" with validation, archive_le, size_32 features), same crash-safety story (flock on scripts.rkyv.lock, atomic-rename writes via tmp file + fsync), same versioning fields (magic: u32 + format_version: u32).

Full migration rationale, file-by-file diff, and reproducible bench harness at docs/CACHE_RKYV_MIGRATION.md.

Threading macros vs Racket / Clojure

Every other language with arrow-threading treats the arrow as pure compile-time syntax: a macroexpansion-time AST rewrite into nested calls. Concurrency, when wanted, is a separate primitive (pmap, future, core.async, racket places). Stryke is the first language to bake execution semantics directly into the threading-arrow family — same surface grammar, distinct runtime models.

What's structurally novel

• Pure-syntax tradition: Clojure / Racket / Elixir / F# / OCaml / R / Hack / JS treat threading as compile-time AST rewrite. To get parallelism you call a separate function (Clojure pmap, Racket future, Elixir Task.async, OCaml Domain.spawn) — never via the arrow.
• Stryke axis-2 — execution model: ~s> and ~p> use the same surface grammar as ~> but emit different bytecode. One-token swap changes "evaluate sequentially" to "spawn a per-stage worker pool with channels" or "split into chunks and reduce in a tree." No re-plumbing required.
• Boundary markers: ||> / |then| are the world's-first operator that changes the threading mode mid-chain. Lets a single declaration mix parallel chunked extraction with sequential terminal stages without breaking the macro.
• Auto-merger for parallel chunks: par_reduce { extract } picks a merge strategy by inspecting the first chunk's result type (hash → key-wise add, scalar → sum, array → concat, string → concat). Canonical histogram merge in one stage; no plumbing.
• Compatibility floor: ~> / ~>> / |> behave exactly like Racket ~> / Clojure ->> / Elixir |>. Polyglots get the familiar semantics for free; the parallel forms are pure addition.

Equivalent rewrite vs. one-token swap

To get the equivalent of ~p> @data map { _ * 2 } sum in Clojure today, you write:

(->> data
     (partition-all (chunk-size))
     (pmap (fn [chunk] (->> chunk
                            (map #(* 2 %))
                            (reduce +))))
     (reduce +))

Five lines, three nested operations, two manual reduces, and an explicit chunk size. Stryke compresses the same shape to:

~p> @data map { _ * 2 } sum

Same input, same output, same parallelism — different operator. The chunk split, worker dispatch, and tree-merge are the operator's job.

Inventions

Designs that originated in stryke. Other languages are invited to absorb, adapt, or build on any of these under MIT — see CREATORS.md § Porting stryke ideas for the attribution norm. The list also doubles as the canonical reference porters cite.

When a port lands in another language, a one-sentence credit in that language's docs (feature reference / release notes / “Influences” section) referring to stryke as the invention source is the asked attribution form. See CREATORS.md for the exact wording.

Demo gallery — runnable feature tours

Every demo runs clean under stryke --no-interop (idiomatic stryke, no Perl 5 shortcuts). Each is pinned by a behavior test in tests/suite/demos_pin.rs so regressions trip CI.

rkyv KV store

• kvstore_basics.stk — open / put / get / del / keys / commit / reopen
• kvstore_cache.stk — persistent memoization across process restarts (cold 1.01s → warm 0.00s)
• kvstore_namespace.stk — prefix-namespaced "tables", batch atomicity, rollback

Sketches & probabilistic data structures

• sketch_algebra.stk — world-first operator overloads + | & ^ - on Bloom / HLL / CMS / TopK / t-digest / Roaring
• sketches_tier2.stk — rate limiter, hash ring, SimHash, MinHash, interval tree, BK-tree, rope, diff

Numerical & modern IDs

• numerical_ids.stk — ULID (sortable + monotonic), Kahan compensated summation, Welford online stats

Language fundamentals

• pipe_forward.stk — |> F#/Elixir-style threading
• thread_macro.stk — ~> chain, partial application, block stages
• implicit_params.stk — world-first _0/_1/_N + outer-topic chain _</_<<
• algebraic_match.stk — enum + exhaustive match
• string_coordinates.stk — bytes vs codepoints, length vs len, index vs cindex

Parallelism & concurrency

• parallel_primitives.stk — pmap (0.05s vs 0.40s serial), pgrep, pfor, psort, preduce, pmap_reduce, fan
• async_tasks.stk — async { } + await, spawn alias, racing tasks, async ingestors → sketch

OOP, AOP, regex, glob

• oop_classes.stk — typed fields, BUILD hook, extends, method dispatch
• aop_intercepts.stk — before/after/around, proceed(), glob-pattern intercepts
• regex_three_tier.stk — regex / fancy-regex / pcre2 auto-tier escalation, named captures
• glob_qualifiers.stk — world-first zsh-style qualifiers (N) (.) (/) (D) (oL) (Lk+1) in a scripting language

Practical I/O

• iterator_ops.stk — enumerate, dedup, nth, range, flatten, zip, colon-range 0:9
• file_streams.stk — slurp/spurt, glob recursive, find, file metadata
• crypto.stk — SHA-2 / SHA-3 / BLAKE3 / MD5, HMAC, Argon2, JWT
• codecs.stk — JSON / YAML / TOML / CSV roundtrips, cross-format conversion
• datetime.stk — strftime, ISO 8601, RFC 2822, time arithmetic, ISO keys sort chronologically

Shell & reflection

• shell_repl.stk — whoami, pushd/popd, strftime, tac, tree, mktemp
• run_source.stk — run(target, ...args) spawns isolated subprocess; source(path) loads stryke definitions into the current REPL
• reflection_hashes.stk — %b / %a / %k / %all / %c / %d queries, alias inversion

Worked end-to-end programs

Full multi-stage programs (not snippets) that exercise stryke's parallel, AOP, parser, and AI primitives together. Each ships with embedded assertions and passes under stryke --no-interop.

• tfidf_search_engine.stk — TF-IDF inverted index + cosine ranking; ~>-threaded tokenize and parallel scoring pipeline
• mini_sql_executor.stk — tokenizer + recursive-descent parser + executor for SELECT cols FROM t [WHERE ...] [ORDER BY ...] [LIMIT N]
• kalman_filter_tracking.stk — 1D Kalman filter, hand-rolled 2×2 matrix algebra, Box-Muller Gaussian noise
• gradient_descent_linreg.stk — mini-batch SGD for linear regression with pmap_reduce parallel gradient sum
• webhook_signature_verifier.stk — HMAC-SHA256 webhook receiver with replay-set, max-age window, constant-time compare
• pubsub_message_bus.stk — topic-filtered fan-out broker over pchannel + spawn, multiple subscriber workers
• csv_etl_parallel.stk — full ETL: parse → enrich → chunk-parallel aggregate with pmap_reduce, region ranking
• raft_election_simulator.stk — discrete-time Raft leader election (timeouts, RequestVote, majority rule, heartbeats)
• http_router_middleware.stk — Express-style router with path params, composable middleware (logger / auth / rate-limit)

Repository & links

• Source — GitHub repo
• Crate — crates.io (cargo install strykelang)
• Rust API docs — docs.rs
• Issues — issue tracker
• Full README — README on GitHub (install, parallel primitives, mysync, CLI flags, architecture, benchmarks, standalone binaries, inline Rust, bytecode cache, distributed pmap_on, LSP).
• Parity — parity/cases/*.pl holds 20k+ Perl-vs-s test cases run by parity/run_parity.sh.