# pperl 0.6.13

*2026-08-15 to 2026-08-18, 35 commits.*

## JIT and parallelization

- **Element increments** compile: `$h{$key}++` and `$a[$i]--` in a loop
  no longer keep it from compiling, also when the hash key is a computed
  string, as in `$h{substr($seq, $i, $k)}++`. The first increment of a
  new element creates it as an integer, as perl5 does. The Benchmarks
  Game's k-nucleotide at its official input runs in 74.1 s instead of
  99.2 s, 1.30 times as fast as perl5.
- **`@_` element reads** compile: `$_[$j]` and `$_[0]` inside a sub no
  longer keep its loops from compiling. The Benchmarks Game's
  spectral-norm, whose inner loops read `$_[$j]`, compiles them and at
  N=5,500 runs in 17.8 s instead of 61.8 s; perl5 takes 64.6 s.
- **Inlined subroutines**: a loop that calls a short sub by name, one
  without branches or recursion that takes its arguments through
  `my (...) = @_`, `my $x = shift` or `$_[k]`, compiles with the sub's
  body in place of the call. A sub that only reads a lexical of its file,
  such as `sub f { $g }`, is inlined too, and redefining an inlined sub
  takes effect as on perl5. A loop calling a three-argument sub runs
  18.1 times as fast as on perl5, and one using the return value of a
  two-argument sub 17.7 times.
- **Loops that call subroutines** compile when the calls are the only
  part of the loop the JIT cannot compile: the calls run in the
  interpreter between stretches of compiled code, and hot loops inside
  the called sub still run compiled. A `die`, a `last` that leaves the
  sub, and recursion behave as on perl5.
- **`use integer`**: integer addition, subtraction, multiplication,
  division and modulus, the six numeric comparisons and the shift
  operators compile under the pragma, with perl5's wrapping integer
  results; before, they were left to the interpreter.
  Benchmark loops under `use integer` run 3.7 to 4.4 times as fast as on
  perl5.
- **Foreach over arrays**: `for my $x (@a)` and `for my $x (@$ref)`
  compile, where only loops over a range did before; reversed and
  indexed forms stay in the interpreter. A benchmark loop over an array
  runs 4.94 times as fast as on perl5, against 0.74 times before.
- **Lexical array reads** with a variable or constant index, `$a[$j]` and
  `$a[3]`, compile in a loop, also inside an inlined sub reading an array
  of its file.

## Modules

- **Storable** freezes faster: a benchmark freezing an array, which ran
  at 0.895 times perl5's speed, runs about 1.2 times as fast as perl5.
- **Digest::MD5** computes digests in 2.2% more cycles than perl5's
  Digest::MD5, down from 13.4% more.
- **Math::GMP** reads a tied or otherwise magical argument before
  converting it, as perl5 does, and `_gmp_lib_version` returns a
  v-string.

## Documentation

- **Peta::FFI::Cairo reference**: its pages are translated into 41
  languages, where their prose was untranslated before. They were
  corrected against the module, among them the description of reference
  counting, and `Context::get_matrix` and `get_font_matrix` are
  documented for the first time.
- **Command-line options page**: the page built from `pperl --help`
  lost every wrapped line of an option's description, 11 lines across
  `--cpan`, `--cpan --system`, `--via-daemon`, `--via-daemon=trunk` and
  `--interactive`, and did not list `--native-manifest=DIR` at all. It
  now shows the complete text.