# pperl 0.6.15

*2026-08-21 to 2026-08-29, 125 commits.*

## JIT and parallelization

- **The previous JIT engine is removed.** It had been off by default
  and was chosen with `PPERL_JIT2=0`; that setting now runs pperl
  without a JIT, and the engine that was already the default is the
  only one. `--jit-stats` no longer prints the old engine's counters,
  which were always zero, and reports how many compiled regions were
  installed and how many loops were tracked.
- **List assignments in compiled loops** keep all their elements.
  `@w = ($i, "$str$i")` in a compiled loop assigned only the string,
  and `@out = ($c ? $x : $y, $i)` in a rarely taken branch of a
  compiled loop lost its first element.
- **Compiled loops** give perl5's results in three more cases. A sub
  call that is the last statement of a sub could lose its return value
  when compiled into a loop; `$x = chr($n)` into a tied variable did
  not call the tie's `STORE`; and `pop(@$r) + $#$r` in one statement
  read the array's last index from before the `pop`.
- **Calls to two-argument subs**: a sub that reads `$_[0]` and `$_[1]`
  directly and keeps a `my` variable, as `eval_A` in the Benchmarks
  Game's spectral-norm does, is compiled and called from the compiled
  loop that uses it, where before the loop made a regular Perl call.
  spectral-norm at N=500 runs 11.7% fewer instructions.
- **Long-running loops**: a counted `for` loop that averages at least
  256 iterations each time it is entered is compiled a second time.
  The new version checks the types of the loop's floating-point
  variables and arrays in a first iteration, then runs the remaining
  iterations in a copy of the body without those checks and with the
  loop counter in a register; a loop that leaves this copy too often
  goes back to the first version. spectral-norm at N=500 runs 17.9%
  fewer instructions from this, and with the previous entry's change
  792.4 million in all, against 1,099.9 million before.
- **Array slices and element stores**: swapping two elements with a
  slice, `@p[$i, $j] = @p[$j, $i]`, and storing into an element,
  `$p[$j] = $p[$j + 1]` or `$count[$k]++`, compile in a loop over a
  lexical array. The Benchmarks Game's fannkuch-redux at n=9 runs 22.5% fewer
  instructions from the slice alone. It needed more instructions than
  perl5 before; now perl5 needs 1.12 times as many.
- **Compound assignment to array elements**, such as
  `$vxs[$i] -= $dx * $mm2`, no longer keeps a loop from compiling: the
  element is fetched by the interpreter and the arithmetic around it is
  compiled. The Benchmarks Game's nbody at 200,000 steps runs 8.61
  billion instructions instead of 13.46 billion. It needed more
  instructions than perl5 before; now perl5 needs 1.31 times as many.
- **Counted loops without a loop variable**, such as `for (1 .. 50)`,
  keep their counter in a register, and a compiled loop updates less
  interpreter bookkeeping at each statement, while `die` and `warn`
  still report the right line. Further specialised versions of a loop
  are compiled only once the loop has run long enough to repay them.
  The Benchmarks Game's mandelbrot at its official size of 16,000 runs
  25.8% fewer instructions, 1,541 billion against 2,077 billion.
- **Compiled loops that keep falling back** to the interpreter are
  noticed in every case and handed back to it; before, a loop could
  take its slow path on 99,936 of 100,000 iterations indefinitely. A
  loop whose called sub is redefined is compiled again instead of
  staying interpreted for the rest of the run.
- **`$#array` and `$#_`** compile inside a loop, as `$#$ref` already
  did; before, either kept the statement using it from compiling.

## Modules

- **List::Util**: `first`, `any`, `all`, `none` and `notall` with a
  block, and `reduce`, run their block as compiled code when the list
  has at least 64 elements. Against perl5 with its own List::Util,
  `first` is 1.61 times as fast, `any`, `all` and `none` 1.88 to 1.90
  times and `reduce` 1.10 times, where before they ran at 0.82 to 0.86
  times perl5's speed. `min` and `max` return the element itself, call
  overloaded `>` and tied values' `FETCH`, and compare numbers above
  2**53 as perl5 does.