// STRYKE — PARALLEL PERL5 INTERPRETER

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 src/parser.rs, producing an AST consumed by both a tree-walking Interpreter and a bytecode Compiler (src/compiler.rs) that feeds the VM (src/vm.rs). Cranelift JIT kicks in for hot blocks and linear subs (src/jit.rs).
• Values — PerlValue 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.
• Binary size — ~21 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. Eight hashes — every direct lookup is O(1).

Forward maps

Inverted indexes (O(1) reverse-query)

Examples

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).

Builtin categories

3200+ operations across 3700+ spellings. 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 count.

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 { $_0 * 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)

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 in both tree-walker and VM.
• 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

BUILD runs after field init (parent first, then child). DESTROY runs in reverse (child first, then parent).

class Base {
    log: Str = ""
    fn BUILD { $self->log("base") }
}
class Child extends Base {
    fn BUILD { $self->log($self->log . "+child") }
}
my $c = Child()
p $c->log                             # "base+child"

# DESTROY — child runs first
class Base {
    static log: Str = ""
    fn DESTROY { Base::log(Base::log() . "base,") }
}
class Child extends Base {
    fn DESTROY { Base::log(Base::log() . "child,") }
}
my $c = Child()
$c->destroy()
p Base::log()                          # "child,base,"

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 — STRYKE_BC_CACHE=1 skips parse + compile on warm starts via on-disk .pec bundles.
• Distributed compute — cluster([...]) builds an SSH worker pool; pmap_on $cluster { } @list fans a map across persistent remote workers with fault tolerance.
• Shared state — mysync declares atomic variables safe to mutate from parallel workers.
• Language server — s lsp (or s --lsp) runs an LSP server over stdio with diagnostics, hover, completion. The five reflection hashes above are part of the completion surface.

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

// 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

zshrs — The Most Powerful Shell Ever Created

zshrs is a drop-in zsh replacement written in Rust. Full bash/zsh/fish compatibility, SQLite-indexed completions, and native stryke parallel operations.

Why zshrs?

Core features

Build options

Usage

zshrs                       # interactive shell
zshrs -c 'echo hello'       # execute command
zshrs script.sh             # run script file
zshrs --dump-zwc file.zwc   # inspect compiled zsh files

# In interactive mode, @ enters stryke (fat build only):
$ @ 1:100 |> sum |> p
5050
$ @ fetch_json("https://api.github.com/users/octocat") |> dd
$ @ ls |> pmap { stat(_)->{size} } |> sum |> p     # parallel file sizes
$ @ glob("**/*.rs") |> pgrep { slurp(_) =~ /TODO/ } |> p

Default abbreviations (fish-style)

Abbreviations expand inline when you press space — type gs<space> and it becomes git status .

Full feature reference

See the full zshrs documentation in README for complete reference with examples.

Repository & links

• Source — github.com/MenkeTechnologies/stryke
• Crate — crates.io/crates/stryke (cargo install strykelang)
• Rust API docs — docs.rs/stryke
• Issues — github.com/MenkeTechnologies/stryke/issues
• 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.