Perl mit AI

The classified stuff

Some things are better left unspoken.

What I can show you today is roughly half of what happened.

→ moving on

PV & Energy Systems

Designed, built, automated

Experimental J1 · Prague

3.4 kWp · 64 kWh · 66% off-grid

Reference W1 · Saxony

20+ kWp · 40 kWh · 85% off-grid

Victron ecosystem  ·  Perl monitoring & control

PV & Energy Systems

Reference S1 · Nuremberg

~24 kWp · 45 kWh · 80+% off-grid · feed-in

Reference J2 · Prague

40 kWp · 120 kWh · 100% off-grid

Villa-A

A technocrat's house — 2050s standard

Villa-A — Construction

Villa-A — Construction

Villa-A — Construction

Villa-A — Construction

Villa-A — Construction

Villa-A — Construction

Villa-A — Construction

Villa-A — Construction

Villa-A — Systems

• Erdwärmekörbe, WP — heizen, kühlen (passiv)
• "Klimamatten" — Deckenheizung, Kühlung (BEKA → Berlin)
• Luftbrunnen, KWL
• Privatkraftwerk (Offgrid)
• Wasserwerk / Wasseraufbereitung
• Digitale Lichtsteuerung, DALI "Full-Stack DC" (DALI-SELV)
• ... und haste nicht gesehen

...and it all needs to be controlled.

A house this complex needs an automation system
that doesn't exist yet.

→

PV — Perl Integration

First tools: Victron Modbus + ECS BMS — all in Perl

$ ecs_bms_tool -range 1-16          # query all battery modules
$ ecs_bms_tool -get cell_voltage -get cell_temperature
$ ecs_bms_tool -otype json           # JSON for pipeline integration

$ Wmodbus discover 192.168.2.0/24    # find Modbus devices on network
$ Wmodbus --host 192.168.2.201 --unit 2 read holding 0-10
$ Wmodbus --host 192.168.2.201 --profile vents-dbe900l monitor

ecs_bms_tool — ECS LiPro BMS management (SoC, cell voltage, balancing)
Wmodbus — Modbus TCP/RTU: discovery, read/write, device profiles, monitoring
Wcli — solar irradiance & PV power calculator
Wthermal — physics-based house thermal model

Scripts work. But a house is more than solar panels.

Looking for a Smarthome

Preferably in Perl, obviously.

MisterHouse — Perl. v4.2 released 03/08/2017. Dead.

FHEM — Perl. Active. Tried it. Suffered.

Home Assistant — Python. Popular. Not Perl. Not 21st century enough.

WHIP — "I'll build my own."

The FHEM Experience

svn.fhem.de/trac/browser/trunk/fhem

(FHEM people: no offense. Well, maybe a little.)

Nice idea. Wrong execution.

✓ Open-source, DIY, community-driven

✓ Tree topology with auto-routing & self-healing

✓ Up to 254 nodes × 254 sensors — decent scale

✗ Arduino — ATmega328? For a house? In 2020?

✗ Arduino software model — Endless loop with stuff in it.

✗ RS485 / nRF24L01+ — Master-Slave Architecture

✗ Text protocol — semicolon-delimited ASCII over serial. In 2020.

✗ No autonomous operation — nodes depend on gateway/controller

I felt there had to be something better.

Birth of a Node

CAN bus instead of RS485

Multi-master · Inherent collision resolution · Resilient
Good enough for cars for decades. Industrial standard.

1 MBit instead of EIB/KNX 9600 baud

Good for 20–30m runs. Plenty for a house.

STM32F103 instead of ATmega328

72 MHz ARM Cortex-M3 · 7× faster than Arduino
CAN peripheral built-in · $1.50 in 2020

FreeRTOS + libopencm3 instead of endless loops

Real tasks · Priorities · Preemption · Hardware abstraction

RobotDyn Black Pill · STM32F103C8T6

Birth of a Node

CAN bus instead of RS485

Multi-master · Inherent collision resolution · Resilient
Good enough for cars for decades. Industrial standard.

1 MBit instead of EIB/KNX 9600 baud

Good for 20–30m runs. Plenty for a house.

STM32F103 instead of ATmega328

72 MHz ARM Cortex-M3 · 7× faster than Arduino
CAN peripheral built-in · $15 in 2020 (COVID!)

FreeRTOS + libopencm3 instead of endless loops

Real tasks · Priorities · Preemption · Hardware abstraction

Blue Pill · STM32F103C8T6

Birth of a Node

CAN bus instead of RS485

Multi-master · Inherent collision resolution · Resilient
Good enough for cars for decades. Industrial standard.

1 MBit instead of EIB/KNX 9600 baud

Good for 20–30m runs. Plenty for a house.

STM32F103 instead of ATmega328

72 MHz ARM Cortex-M3 · 7× faster than Arduino
CAN peripheral built-in · no stock! → DIY

FreeRTOS + libopencm3 instead of endless loops

Real tasks · Priorities · Preemption · Hardware abstraction

Green Pill · STM32F103C8T6 · DIY

Why CAN?

Birth of a Hub

So you have 20 nodes — now what?

Hub assembly · DIN rail mount

Waveshare 2-CH CAN HAT

WHIP Architecture

Higher layers are always a supplement, never a requirement.

Nodes — STM32 + FreeRTOS

Ganglion

Ganglion — In Action

DEF LightTimeout = 300       # 5 minutes

# Motion detected: light on, start timer
IF motion:detected THEN lights:on; SET $T_0 = LightTimeout

# Timer expired: light off
IF !$T_0 THEN lights:off

# Cross-node: kitchen smoke → alarm everywhere
DEF Kitchen = 42
IF Kitchen:smoke:detected THEN buzzer:alarm(1)

Hubs — a Pantheon

Specialized RasPi hubs. Named by function, not by accident.

No hub is a single point of failure. Each domain runs independently.

SELV-DALI — Lighting without mains

Inverters fail? Lights stay on — they bypass AC entirely.

Switch next to the bathtub? No problem. No electrician needed.

🇬🇧 English

🇩🇪 Deutsch

WHIP — Protocols & Integrations

All protocol handlers in Perl · Mojolicious async I/O

WHIP — In production

Invisible when it works. Competent when it matters. Built for decades, not warranties.

AI contributed...

"Small" side projects

The CPAN Situation

SNMP & MIBs — quick primer

SNMP::MIB::Compiler

2 days with AI · CPAN module was 93% working · targeted fixes, no rewrite

4740 MIBs · 301 fixes · 52 fewer failures than Go

github.com/petajoulecorp/SNMP-MIB-Compiler

Grpc::FFI

Wanted gRPC in Perl. Everything on CPAN: dormant, dead, or broken.

So we built it. From scratch. FFI::Platypus bindings to the gRPC C API.

And yet — this was a prelude
for something bigger.

What if FFI wasn't just a tailored library connector...
...but more integrated and automatic?

Navigator / Orchestrator

AI doesn't do this on its own.

Without the navigator — the AI builds impressive things that go nowhere.
Without the AI — the navigator doesn't have enough hours in the day.

So... AI is quite good at Coding.

But how far can this actually go?

pperl

PetaPerl  /  ParallelPerl

A Perl 5 interpreter — designed by humans.

Written in Rust — by many AI agents.

Serious — no toy or academic exercise.

pperl

PetaPerl  /  ParallelPerl

A Perl 5 interpreter Platform — designed by humans.

Written in Rust — by many AI agents.

Serious — no toy or academic exercise.

pperl — Not the first attempt

Common failure mode: underestimating Perl 5's complexity

pperl — Scope

pperl — Status

~61–400 failures — give or take

Performance: good, bad and ugly

Quotes from the AI

pperl — Benchmarks

Native Rust implementations — not XS, not C

pperl — Beyond Perl5

Maximum compatibility. But more.

Autoparallelization

Powered by Rayon — Rust's data-parallelism library

# This just works. In parallel.
my @results = map { expensive_computation($_) } @large_list;

# No threads. No MCE. No forks.
# pperl detects safe loops → Rayon handles the rest.

--parallel flag · list ≥ 1000 items · no shared mutation

JIT Compilation

Just-In-Time — compile to machine code while running

# pperl detects this as a hot loop pattern
my $sum = 0;
for my $i (1 .. 1_000_000) {
    $sum += $i;
}
# → Cranelift compiles to native machine code

JIT — First Win

Inner loop JIT — single hot loop compiled to native code

Good. But only the innermost loop is compiled. What about nested loops?

JIT — Full Nested

All 3 loop levels compiled as one native function

Perl. With JIT. That's a sentence nobody expected.

Autoparallel JIT — Full Win

JIT + Rayon: compile to native, then split across cores

Demo Time!

✓ Auto-FFI

No XS. No Inline::C. No compilation. Just call C.

# Layer 0 — Raw: any library, you provide type signatures
use Peta::FFI qw(dlopen call);
my $lib = dlopen("libz.so.1");
my $ver = call($lib, "zlibVersion", "()p");
say "zlib: $ver";    # 1.3.1

# Layer 1 — Pre-baked: curated signatures, zero ceremony
use Peta::FFI::Libc qw(getpid strlen strerror uname);
say strlen("hello");           # 5
my @info = uname();
say "$info[0] $info[2]";      # Linux 6.18.6-arch1-1

Pack-style type codes: (p)L = strlen(const char*) → size_t
50+ native Rust modules already built in — Auto-FFI extends to everything else

Auto-FFI — Details

Powered by libffi — any signature works, no pre-generated stubs

# Layer 2 — What's on this system?
use Peta::FFI qw(scan dlopen call);
my $libs = scan();
say scalar(keys %$libs), " libraries found";
if (exists $libs->{"libz.so.1"}) {
    my $z = dlopen("libz.so.1");
    say "zlib: ", call($z, "zlibVersion", "()p");
}

Libc: ~30 functions (process, strings, env, math, file, time)
UUID: 6 functions via dlopen — dies with install hint if missing

✓ Bytecode Cache (.plc)

Like Python's .pyc — but for Perl. Opt-in.

# Default: no caching (safe for development)
$ pperl script.pl

# Enable: compile once, load from cache on subsequent runs
$ pperl --cache script.pl

# Invalidate all caches
$ pperl --flush

Bytecode Cache — Details

Storable-model: bincode deserializes directly to final runtime types. Zero intermediate conversion.

Net module-loading cost: 33–37% faster with cache. Biggest win on fallback modules. Native Rust modules already near-zero cost.

SHA-256 keyed · mtime + version validation · aggressive format versioning

✓ Daemonize

Emacs-style daemon/client model

$ pperl --daemon script.pl   # compile, warm up, listen
$ pperl --client script.pl   # connect → fork → run → respond
$ pperl --stop   script.pl   # clean shutdown

Daemonize — Details

Eliminates both startup costs: process creation (~3-4ms) + module compilation (0-15ms)
Faster than bytecode cache — no deserialization, arenas are already in memory

Unix domain socket · JSON wire protocol · copy-on-write pages via fork()

Daemonize — Prior Art

All prior solutions: same interpreter across requests — state leakage by design
pperl: fresh child per request via fork() — compiled arenas via COW, clean runtime state

Future pperl

When to use pperl

Rule of thumb: the longer and more complex the script,
the more likely you hit a corner case. If you don't want to touch the code — use perl5.

Correctness Case Study

How serious is "maximum compatibility"?

if (SvGMAGICAL(ofs) || SvOK(ofs))

if (PL_ors_sv && SvOK(PL_ors_sv))

// Same mask for both — SVS_GMG included for ORS. Wrong.
if flags & (SVF_IOK | SVF_NOK | SVF_POK | SVF_ROK | SVS_GMG) != 0

I have been doing
AI with Perl
for a few decades. Now it is time to let
AI do Perl.

Get it here:

perl.petamem.com

Danke.

Richard Jelinek  ·  rj@petamem.com
PetaMem s.r.o.  ·  petamem.com

One more thing.

psh

An interactive Perl shell

ls "-la";                    # it's just a sub call
cd "/tmp";                   # chdir wrapper
ps "aux";                    # system command

# But you're already in a scripting language:
for my $f (glob("*.log")) {
    if (-M $f > 7) {
        rm $f;
        say "cleaned $f";
    }
}

ps() | grep { $_->{mem} > 100_000 }
     | sort { $b->{cpu} <=> $a->{cpu} };

PowerShell's philosophy · Perl's text power · pperl's JIT speed