PERLDELTA(1perl)

📦

version 5.44.0 · 2 versions

5.44.0 · arch rolling (latest)
5.42.3 · arch rolling

✨👑 perldelta — what's new for perl v5.44.0 👑✨

💖 NAME

perldelta — bestie, this is the tea: everything that's new for perl v5.44.0 🫖💅

🌸 DESCRIPTION

Okay so this doc is the glow-up report — it's all about the differences between the 5.42.0 release and the 5.44.0 release. Sit down, hydrate, and let's go 🧚

🌈 Core Enhancements 🌈

🎀 Named Parameters in Signatures

Not me about to tell you signatures got a major new ability: now callers can pass parameters by name/value pairs instead of by position. Obsessed. 💅

sub f ($x, $y, :$alpha, :$beta = undef) { ... }

f( 123, 456, alpha => 789 );

This was originally specified in PPC0024 — the receipts live at https://github.com/Perl/PPCs/blob/main/ppcs/ppc0024-signature-named-parameters.md.

Heads up bestie: this feature is currently considered experimental ✨ and it's described in more detail in "Signatures" in perlsub.

🦋 Multi-variable `foreach` can now use aliased references

Story time 📖 Perl version 5.22 introduced reference aliases, which let a foreach loop iteration variable create new aliases to references. Then Perl version 5.36 introduced foreach loops with multiple variables, consuming more than one input list item on each iteration. And new in this version: those two features can finally be used together, so you can have multiple iteration variables where any of them are permitted to be reference aliases. Main character energy fr fr. 🌟

use v5.44;
use feature qw( refaliasing declared_refs );

my %hash = (
    one => [1],
    two => [2, 2],
);

foreach my ( $key, \@items ) ( %hash ) {
    say "The $key array contains: @items";
}

Currently both the refaliasing and declared_refs features remain experimental. 🙈

🌟 Enhanced operation of regular expression patterns under `/xx`

Sooo experimentally, the /xx pattern modifier can allow bracketed character classes (like e.g. [a-zA-Z]) to extend across multiple lines and to contain comments, and to warn you about potential cases where a portion of a pattern inadvertently got treated as a comment instead of what you actually intended. 😭 This behavior is enabled by use feature "enhanced_xx". See "/x and /xx" in perlre.

💜 Unicode 17.0 is supported

See https://www.unicode.org/versions/Unicode17.0.0/. Periodt. 👑

🔥 New source of entropy for PRNG seeding

Perl now uses the getentropy() system call to fetch random bytes suitable for seeding the internal PRNG. Previously Perl would read raw bytes from the /dev/urandom device. Now Perl seeds itself in this order (and falls through upon failure):

getentropy() on systems that support this call (Linux, BSD, MacOS)
/dev/urandom on systems that have it
Hash of internal state variables: Unix time, process ID, and pointer value

Note that the internal PRNG is still unsuitable for security applications. 😬 See "rand EXPR" in perlfunc for a discussion of security.

🔒 Security 🔒

🚨 CVE-2026-8376 — Buffer overflow in Perl_study_chunk

Perl_study_chunk in regcomp_study.c checked the size of the joined substring buffer in characters rather than bytes. On 32-bit builds, this can lead to an integer overflow of the size of the buffer, which leads to out-of-bounds writes. 💀 Not the vibe.

🚨 CVE-2026-57432 — Buffer overflow in S_measure_struct

If you call pack or unpack to operate on a structure whose computed size is too large to fit in memory, an integer overflow could happen that would result in a buffer overflow. This usually happens as a result of embedding a large number as the repeat count for an item. 😭

🚨 CVE-2026-13221 — Regex trie 16-bit field overflow

The trie optimization in the regex engine could overflow in an alternation with more than ~65k branches. This could cause both false positives and false negatives on such regular expressions. Both?? At the same time?? 🙈

💥 Incompatible Changes 💥

😤 Unicode rules are now fully enforced on identifier and regular expression group names.

Okay so back in the day, before Unicode, Perl accepted any \w character in an identifier or other name — except the first character couldn't be a digit. Later, Unicode created two properties that described this. Even later, they found those properties to be insufficient, and created two new similar properties. These are the ones that perl has intended to use since: \p{XID_Start} and \p{XID_Continue}. (The X stands for "eXtended" 💫 and indicates these are the more modern versions.)

(And even later, long after Perl identifier rules were formed using the above properties, Unicode added recommendations to further restrict legal identifier names. These were added to counter cases where, for example, programmers snuck code past reviewers using characters that look like other ones. 👀 The two properties are Identifier_Status and Identifier_Type. See https://www.unicode.org/reports/tr39/. Perl currently doesn't do anything with these, except to furnish you the ability to use them in regular expressions.)

We soon discovered that there were 14 characters that match XID_Start and XID_Continue that don't also match \w. To avoid breaking code that had long relied on \w, we chose to not add those to the list of acceptable identifier characters. 🤝

It turns out that there are about 160 characters that match \w but not the Unicode XID properties. Thus they are illegal according to Unicode. Those are now explicitly forbidden in both Perl identifiers and regular expression group names. Previously, it was likely that their use in identifiers wouldn't work anyway; they could be accepted initially as legal, but other code would later reject them, but with a message that had nothing to do with the underlying problem. 😵‍💫 However group names in regular expression patterns could contain illegal continuation characters and have a higher probability of not being caught. That is now changed.

Only programs that do use utf8 can be affected, and then only characters that appear in the 2nd or later positions of the name. The characters that an identifier name can begin with are unchanged. ✅

130 of the now unacceptable characters are 5 sets of 26 Latin letters that are enclosed by some shape, such as CIRCLED LATIN CAPITAL LETTER N. Another 8 are generic modifiers that add shapes around other characters; 5 are modifiers to Cyrillic numbers; and 16 are Arabic ligatures and isolated forms. The other two are GREEK YPOGEGRAMMENI and VERTICAL TILDE. 💅

🫠 Deprecations 🫠

Deprecated since 5.12, using goto to jump into the body of a loop or other block construct from outside is no longer permitted. [GH #23618 https://github.com/Perl/perl5/issues/23618]
m/...[...].../xx has new restrictions 😳

Using an unescaped # or literal vertical space is now deprecated in a regular expression bracketed character class that is compiled with the /xx modifier. These still work, but deprecation warnings will be generated unless turned off or the constructs are cured as follows.

Escape a # by preceding it with a backslash, like in

m/ [ % \# ( ) ] /xx

Use constructs like \n instead of literal vertical space.

🚀 Performance Enhancements 🚀

Simple (non-overflowing) addition (+), subtraction (-) and multiplication (*) of integers are slightly sped up, as long as sufficient underlying C compiler support is available. Speed? We love her. 🏎️
Populating a hash from a list of key/value pairs when the keys are constant string operands known at compile time is commonly now faster. [GH #24228 https://github.com/Perl/perl5/issues/24228] 🔥
Processing of signatures at the start of a subroutine under the signatures feature is now more efficient at runtime. ✨

🎀 Modules and Pragmata 🎀

📦 Updated Modules and Pragmata

Bestie, get comfy, this list is long but every single one of these glowed up, no skips:

Archive::Tar — upgraded from 3.04 to 3.12.
- This fixes CVE-2026-9538, CVE-2026-42496, and CVE-2026-42497. 💅
attributes — upgraded from 0.36 to 0.37.
B — upgraded from 1.89 to 1.92.
B::Concise — upgraded from 1.007 to 1.012.
B::Deparse — upgraded from 1.85 to 1.89.
charnames — upgraded from 1.50 to 1.51.
Compress::Raw::Bzip2 — upgraded from 2.213 to 2.218.
Compress::Raw::Zlib — upgraded from 2.213 to 2.222.
Config::Perl::V — upgraded from 0.38 to 0.39.
CPAN::Meta — upgraded from 2.150010 to 2.150013.
CPAN::Meta::Requirements — upgraded from 2.143 to 2.145.
DB_File — upgraded from 1.859 to 1.860.
Encode — upgraded from 3.21 to 3.24.
English — upgraded from 1.11 to 1.12.
Errno — upgraded from 1.38 to 1.39.
experimental — upgraded from 0.035 to 0.036.
ExtUtils::CBuilder — upgraded from 0.280242 to 0.280243.
ExtUtils::MakeMaker — upgraded from 7.76 to 7.78.
ExtUtils::Miniperl — upgraded from 1.14 to 1.15.
ExtUtils::ParseXS — upgraded from 3.57 to 3.63.
ExtUtils::Typemaps — upgraded from 3.57 to 3.63.
feature — upgraded from 1.97 to 2.02.
File::Copy — upgraded from 2.41 to 2.43.
File::Fetch — upgraded from 1.04 to 1.08.
File::Glob — upgraded from 1.42 to 1.44.
File::Spec — upgraded from 3.94 to 3.95.
File::stat — upgraded from 1.14 to 1.15.
File::Temp — upgraded from 0.2311 to 0.2312.
Filter::Simple — upgraded from 0.96 to 0.97.
Filter::Util::Call — upgraded from 1.64 to 1.65.
Getopt::Std — upgraded from 1.14 to 1.15.
HTTP::Tiny — upgraded from 0.090 to 0.096.
- This fixes CVE-2026-7010 and CVE-2026-7017. 🔥
IO — upgraded from 1.55 to 1.56.
IO::Compress — upgraded from 2.213 to 2.223.
- This fixes CVE-2025-15649, CVE-2026-48961, CVE-2026-48962, and CVE-2026-48959. 🛡️
IO::Socket::IP — upgraded from 0.43 to 0.44.
Math::BigInt — upgraded from 2.005002 to 2.005003.
Module::CoreList — upgraded from 5.20250702 to 5.20260708.
Module::Metadata — upgraded from 1.000038 to 1.000039.
mro — upgraded from 1.29 to 1.30.
Net::Ping — upgraded from 2.76 to 2.77.
Opcode — upgraded from 1.69 to 1.71.
overloading — upgraded from 0.02 to 0.03.
PerlIO::via — upgraded from 0.19 to 0.21.
Pod::Html — upgraded from 1.35 to 1.36.
Pod::Simple — upgraded from 3.45 to 3.48.
POSIX — upgraded from 2.23 to 2.26.
Scalar::Util — upgraded from 1.68_01 to 1.70.
SelectSaver — upgraded from 1.02 to 1.03.
SelfLoader — upgraded from 1.28 to 1.29.
Socket — upgraded from 2.038 to 2.041.
- This fixes CVE-2026-12087. ✨
Storable — upgraded from 3.37 to 3.41.
- This fixes CVE-2026-57433. 🫶
Term::Table — upgraded from 0.024 to 0.028.
Test::Harness — upgraded from 3.50 to 3.52.
Test::Simple — upgraded from 1.302210 to 1.302219.
Text::Balanced — upgraded from 2.06 to 2.07.
threads — upgraded from 2.43 to 2.45.
threads::shared — upgraded from 1.70 to 1.73.
Time::HiRes — upgraded from 1.9778 to 1.9780.
Time::Piece — upgraded from 1.36 to 1.41.
Unicode::UCD — upgraded from 0.81 to 0.83.
UNIVERSAL — upgraded from 1.17 to 1.18.
utf8 — upgraded from 1.27 to 1.29.
version — upgraded from 0.9933 to 0.9934.
warnings — upgraded from 1.74 to 1.78.
XS::APItest — upgraded from 1.43 to 1.50.
XS::Typemap — upgraded from 0.20 to 0.22.

📖 Documentation

✍️ Changes to Existing Documentation

We tried our absolute best to update the docs so they actually match all the changes listed in this document. If you spot one we missed, be a dear and open an issue at <https://github.com/Perl/perl5/issues>. (Not me being the one asking for help 😭 we literally wrote it down.)

And on top of that, here are the selected changes that got made:

`perlapi`

Auto-generation of this document now includes the line number of the source code, as well as its documentation. ✨
It now contains information about how to find what release of Perl first contained an API element.

`perlexperiment`

New entry for "New object system and "class" syntax".

`perlxs`

The reference manual for writing Perl XS code has been completely rewritten and modernized. It is about twice the size of the old file, and promotes more modern XS syntax, such as ANSI signatures. She ate, honestly. 👑

🩺 Diagnostics

The following additions or changes have been made to diagnostic output, including warnings and fatal error messages. For the complete list of diagnostic messages, see perldiag.

🔧 Changes to Existing Diagnostics

Use of uninitialized value%s

This warning was issued in the reverse order (right-to-left) when both operands of a binary operator are uninitialized values. This is now fixed to be consistent with evaluation order of operands. No more cursed backwards energy bestie.

Certain diagnostics about byte sequences that are supposed to comprise a UTF-8 encoded character, but that are invalid in some way, now don't include bytes irrelevant to that determination. An example is

old message

Malformed UTF-8 character: "\xc1\x27" (any UTF-8 sequence that
starts with "\xc1" is overlong which can and should be
represented with a different, shorter sequence)

new message

Malformed UTF-8 character: "\xc1" (any UTF-8 sequence that
starts with "\xc1" is overlong which can and should be
represented with a different, shorter sequence)

In this case the "\xc1" is all that is needed to make the sequence invalid. Whatever comes after it is irrelevant (in this case, "\x27"), and including it in the message might lead the reader to think that it somehow does matter. Like no babe, that part is not the problem 💀

The error Unrecognised parameters for "%s" constructor: %s has been changed to Unrecognized parameters for "%s" constructor: %s. (Spelling glowup, iconic.)
Variables whose name started with ^_ were incorrectly shown in diagnostics with a literal "Ctrl-_" (which is an invisible ASCII character) in their name.

The names of variables whose names begin with a caret and are longer than two characters are now wrapped in braces, just as they have to be in the source code.

Therefore, using an undefined "${^_FOO}" will now correctly warn with Use of uninitialized value ${^_FOO}, instead of the earlier Use of uninitialized value $FOO (with a literal "Ctrl-_" after the dollar sign).

[GH #24135 <https://github.com/Perl/perl5/issues/24135>]

Calling the "import" method on a package with no "import" method now produces a regular warning rather than a deprecation warning or error.

Since Perl 5.39.1, calling "import" with arguments on a package without such a method has triggered a deprecation warning. In Perl 5.43.6, this deprecation was promoted into an error. This broke a significant amount of code while providing very little advantage over the warning. This fatal error has been converted back to a warning, with its deprecation status removed. There are no longer any plans to make this fatal in the future. The category for this warning is "missing_import" and it is enabled by default.

🚨 New Diagnostics

New Errors

Can't redeclare catch variable as "%s"

(F) A "my", "our" or "state" keyword was used with the exception variable in a "catch" block:

try { ... }
catch (my $e) { ... }
# or catch (our $e) { ... }
# or catch (state $e) { ... }

This is not valid syntax. "catch" takes a bare variable name, which is automatically lexically declared. [GH #23222 <https://github.com/Perl/perl5/issues/23222>]

Use of "goto" to jump into a construct is no longer permitted

(F) You have used "goto LABEL;" or "goto EXPR;" in an attempt to jump into the body of a loop or other block construct from the outside. As of Perl 5.44, this throws an exception. 🚫 Bestie do NOT try to jump in from outside, the construct does not want you there.

\x{%X} is a \w char that isn't valid in a name "%s"

In most cases where this message now appears, an error would have occurred anyway, but the text would not have been helpful in finding the problem.

New Warnings

Possible attempt to escape whitespace in qw() list

(W qw) qw() lists contain items separated by whitespace; contrary to what some might expect, backslash characters cannot be used to "protect" whitespace from being split, but are instead treated as literal data.

Note that this warning is only emitted when the backslash is followed by actual whitespace (that "qw" splits on). 🙈

⚙️ Configuration and Compilation

C23 <stdckdint.h> and associated macros are now used if available. ✨
It is now possible to pass to Configure the values dealing with POSIX locale categories, overriding its automatic calculation of these. This enables cross-compilation to work. The easiest way to do this is to extract the C program that does the calculation from Configure and then run it on the target machine, and then pass the values it outputs to Configure on the other machine. Porting/Glossary has examples. [GH #22992 <https://github.com/Perl/perl5/issues/22992>]
The "PERL_CREATE_GVSV" configuration macro has been removed. It was almost undocumented and it has been disabled by default since Perl 5.10.0. Its purpose was to force all GVs to initialize their SV slot on creation. [GH #24177 <https://github.com/Perl/perl5/issues/24177>] — it's giving retired, and we're not bringing it back. 💅

🌸 TESTING 🌸

bestie, tests got added and changed to keep up with literally every other addition and change in this release okurrr. and on top of that, these specific glow-ups happened:

Karl Williamson gave a talk at TPRC 2025 asking people to contribute tests to find old issues that are no longer a problem, and todo tests to reflect reproduction cases for known outstanding bugs. (video link: https://www.youtube.com/watch?v=CwX4Xsf5y5E) It gained renewed interest this year, leading to an uptick in test submissions from new authors, for which we are extremely grateful. 🥹💖 like genuinely, thank you new test authors, you ate.
When testing embedding, add a sanity check to ensure the libperl we link against matches the perl we are building. [GH #22125 https://github.com/Perl/perl5/issues/22125]

🌈 PLATFORM SUPPORT 🌈

🧚 PLATFORM-SPECIFIC NOTES 🧚

🪟 Windows

Fix builds with USE_IMP_SYS defined but USE_ITHREADS not defined. 💅

🐡 OpenBSD

When testing embedding, ensure we link against the correct static libperl. [GH #22125 https://github.com/Perl/perl5/issues/22125]

👑 AIX

Thread-safe locale handling has been turned off on all releases due to apparent bugs in the underlying operating system support. no cap, that's just how it is 😭
The ibm-clang/ibm-clang_r IBM Open XL C/C++ compiler is now supported for AIX 7.2 and 7.3. This is the recommended compiler to use when compiling Perl on these versions of AIX. ✨

🦋 z/OS

clang is now the only supported compiler. periodt.
A single test failure remains for the core Perl test suite 🔥

It is for a misleading warning message in an edge case for reading malformed UTF-8 in XS-APItest/t/utf8_warn00.t. (Several instances of the same failure occur.)

Some cpan modules shipped with core have known problems:
- Encode
- ExtUtils-MakeMaker
- HTTP-Tiny
- IO-Compress
- JSON-PP
- libnet
- MIME-Base64
- PerlIO-via-QuotedPrint
- Pod-Checker
- podlators
- Pod-Simple

Check for updates to these on cpan. 🫶

You can get a perl that works in ASCII mode 🌈

An open source project has been created to modify the official perl to work on z/OS in ASCII mode. See https://github.com/zopencommunity/perlport.

The XS parser, ExtUtils::ParseXS, got a glow-up internally ✨ like it's been restructured extensively. Most of this is behind the scenes so you shouldn't notice anything, bestie, but it might mess with XS code that was leaning on invalid or unsupported syntax (which, like, stop that 💅). Also several minor bug-fixes got tucked in there too.
Removed the deprecated (since 5.32) functions sv_locking() and "sv_unlocking". They've been on the way out since forever, so this is just the final goodbye 🫶
"Perl_expected_size" has been added as an experimental stub macro. The plan is to build on it so you can pass it a size in bytes, and it returns the interpreter's best informed guess of what actual usable allocation size the malloc implementation in use would hand back. Think of it as asking your allocator "okay but really, how much am I getting?" 😭

This helps with sizing allocations so SvLEN is more accurate, instead of trying to shrink string buffers to save size when the saving you're chasing is, like, delulu and unrealistic.

"SvPV_shrink_to_cur" got revised to include a byte for copy-on-write (COW) 🐄, so the resulting string could be COWed in the future. It also now uses "Perl_expected_size", compared against the current buffer size, and it does not try to do a reallocation if the requested memory saving is unrealistic. Protecting you from yourself, periodt.
sv_vcatpvfn_flags() now substitutes the Unicode REPLACEMENT CHARACTER for malformed input 🌈. Previously it used the NUL character. Glow-up behavior honestly.
For core Perl maintainers (iykyk 👑), the syntax of embed.fnc has been extended. Every function, foo(), named in that file has generated for it a macro named "PERL_ARGS_ASSERT_FOO". That macro expands to assert() calls that do basic sanity checking for each argument to foo() that we currently deem as being appropriate to have such checking. (Which means — and stay with me — many arguments are not checked, and the generated macro may currently expand to literally nothing 💀.) With this release, you can add your own assert() statements to embed.fnc that will be incorporated into the generated macro, beyond the system-generated ones. Comments and examples in embed.fnc give you the details.
A new function "valid_utf8_to_uv" has been added 🎀. It's synonymous with "valid_utf8_to_uvchr" — its whole reason for existing is so you get consistent spelling with the names of the other functions that translate from UTF-8, so you don't have to remember a different spelling. Your memory is safe bestie.
""newSVsv_flags_NN"" in perlapi is a new function for creating a new SV and assigning the value(s) of an existing SV to it 🌸.

Historically, "Perl_newSVsv_flags" and "Perl_sv_mortalcopy_flags" would pass a new SV head and the original SV to "Perl_sv_setsv_flags". But the latter contains so many branches that have nothing to do with a fresh SV, so they now make use of the new function to streamline the process. Efficiency slay 💅

"Perl_newSVsv_flags" is now essentially a NULL pointer check and a wrapper around the new function, so it's been moved into sv_inline.h.

""STATIC_ASSERT_DECL"" in perlapi and "STATIC_ASSERT_STMT" are like assert(), but they're evaluated at compile time ⭐. That means their argument must be a constant expression that the compiler can verify, and so they effectively have no cost — they don't even appear in the code that gets executed. These were added back in v5.28, but not until now have we opened their use up to XS writers. At the same time, a new variant has been added, "STATIC_ASSERT_EXPR", which is suitable for use in an expression, like a comma expression in a C macro.
"Perl_sv_backoff", which undoes the "OOK" string offset mechanism, now only moves the string buffer contents to the start of the buffer if SvOK(sv) is true. Historically, the buffer contents were always moved, but if the buffer contents are defunct and no longer required, doing that incurs an unnecessary cost proportional to the size of the shifted contents 🙈 (paying for something you don't even need, the way that's giving ✨wasteful✨).

(The assumption in this change is that SvOK(sv) is a valid indicator of whether the string buffer contents are "live" or not.)

See [GH #23967 <https://github.com/Perl/perl5/issues/23967>] for an example of where such a copy was noticeable.

Fixed a bug in the "sv_numeq" in perlapi API where values with numeric (0+) overloading but not equality or numeric comparison overloading would always be compared as floating point values 😭. This could lead to large integers being reported as equal when they weren't. Not the vibe.
Fixed a bug in "sv_numeq" in perlapi where the SV_SKIP_OVERLOAD flag would skip operator overloading, but would still honor numeric (0+) overloading. Rude behavior, fixed.
Added "sv_numne" in perlapi, sv_numle, sv_numlt, sv_numge, sv_numgt and "sv_numcmp" in perlapi APIs that perform numeric comparison in the same way perl does, including overloading 👑. Separate APIs for each comparison are needed so they can invoke their corresponding overload when needed. Inspired by [GH #23918 <https://github.com/Perl/perl5/issues/23918>]

This also extends the sv_numeq API to support SV_FORCE_OVERLOAD.

Added the AMGf_force_scalar flag to the ""amagic_call"" in perlapi API to force scalar context for overload calls 🎯.
Added the AMGf_force_overload flag to the ""amagic_call"" in perlapi API to allow forcing overloading to be honored even in the context of no overloading; 💪.
The "SvFLAGS" bits used by SvPCS_IMPORTED() and SvOOK() have now been merged into the same position, thus freeing up a flags bit for possible future purposes 🌈. This merge is distinguished by the fact that the "PCS_IMPORTED" behaviour is only used on references (when "SvROK" is true), whereas the "OOK" only applies to string buffers (when "SvROK" is false).

This change shouldn't affect any "XS" module code that is using the test macros correctly, though it might cause confusion to code that attempts to analyse "SvFLAGS" bits directly outside of the helper macros 💀 (looking at you, cowboy coders).

An upper limit has been applied to the multiplier operand of the repetition operator. Constant folding will not be attempted if the operand is a numerical constant above PERL_FOLD_REPEAT_LIMIT 🛑. See [GH #20586 <https://github.com/Perl/perl5/issues/20586>] and [GH #23561 <https://github.com/Perl/perl5/issues/23561>] for background.
Dedicated check functions Perl_ck_anonhash and Perl_ck_aassign have been added and are used to hekify some OP_CONST hash keys at compile time ✨. [GH #24228 <https://github.com/Perl/perl5/issues/24228>]
The macro ""fromCTRL"" in perlapi has been added to be the inverse of the existing ""toCTRL"" in perlapi 🔄. toCTRL('A') yields 1 (the control character "SOH" on all platforms Perl works on); fromCTRL(1) yields 'A'. Iconic symmetry, we love to see it.
"Perl_check_hash_fields_and_hekify", partly called as a compile-time optimization, no longer preemptively converts an NV to a HEK if the compile time and run time locales could differ 🌍. [GH #24252 <https://github.com/Perl/perl5/issues/24252>]
When a UTF-8 constant string was used as the hash key in an insert operation, such as "$hash{'über maus'} = 1;", and the string could be converted into a single byte representation, the flag noting the original encoding ("HVhek_WASUTF8") was not always retained 😭.

When this occurred, the relevant scalars returned by "keys %hash" would not be in the original, expected UTF-8 encoding. Encodings getting lost in the sauce, not on our watch.

The original encoding is now captured and propagated 💖. [GH #24266 <https://github.com/Perl/perl5/issues/24266>] [GH #24290 <https://github.com/Perl/perl5/pull/24290>]

When a constant IV or NV was used as a hash key, such as in "my %hash = ( 42 => 0 );", and was preemptively stringified into a hash key, the fact that the numerical value came first was lost 🫠. This unintentionally modified deparse output for such keys.

The numerical values are now carried across, and flags on the key variable reflect the original data type. Glow-up for your deparse output ✨

Note: This now preserves the form of constant keys supplied to tied hashes in list assignments. [GH #24302 <https://github.com/Perl/perl5/issues/24302>]

A new function, "defer_error" in perlapi, has been added to report errors in compiling a perl program 🎀. "qerror" in perlapi is a deprecated alias for it. Previously, "qerror" existed but was undocumented (a whole mystery, fr fr).

[GH #23676 <https://github.com/Perl/perl5/issues/23676>]

"op_clear" in perlapi is now part of the API 👑.

[GH #23676 <https://github.com/Perl/perl5/issues/23676>]

🐛 Selected Bug Fixes 🐛

okay besties, this is the part where we list all the glow-ups 💅 every one of these was broken and now it's not. iconic behavior.

Method signature arg counts finally count $self 😭

so back in the day, when a method subroutine with a signature got an exception thrown at it because it didn't get the right number of arguments to match its declared parameters, the message was lying to you — it wasn't counting the implied $self parameter, so every number in the message was 1 fewer than it should've been. rude.

this is fixed now 💖 so the messages report the correct number of arguments, object invocant included. slay.

Overloaded arithmetic operands + use integer 🧮

when both operands of arithmetic operators (+, -, etc.) are overloaded objects that have no method for that operator, but do have a 0+ method and the fallback option set to TRUE, perl will normally call the 0+ method for the left operand first and then call one for the right operand — i.e. in the same order as operand evaluation. correct order, we love to see it.

but if use integer; is in effect, those 0+ methods used to get called in the wrong (reverse) order. oops.

Two-variable for loops that crashed the compiler in v5.42.0 💀

certain constructs involving a two-variable for loop would literally crash the perl compiler in v5.42.0:

# Two-variable for loop over a list returned from a method call:
for my ($x, $y) (Some::Class->foo()) { ... }
for my ($x, $y) ($object->foo()) { ... }

and

# Two-variable for loop over a list returned from a call to a
# lexical(ly imported) subroutine, all inside a lexically scoped
# or anonymous subroutine:
my sub foo { ... }
my $fn = sub {
    for my ($x, $y) (foo()) { ... }
};

use builtin qw(indexed);  # lexical import!
my sub bar {
    for my ($x, $y) (indexed(...)) { ... }
}

these have been fixed. [GH #23405 — https://github.com/Perl/perl5/issues/23405]

pack and unpack error conditions 📦

several error conditions in the pack and unpack operations were just... not detected. they are now. caught. handled. periodt.

INTERFACE keyword in XS 🔧

INTERFACE is now compatible with ISO/IEC 9899:2024 (C23), which is the default language version used by GCC 15. previously, it generated code that failed to compile as C23. tragic.

secondly, INTERFACE now supports Perl package names as C types (i.e. Foo::Bar gets auto-converted to Foo__Bar). cute!

[GH #23192 — https://github.com/Perl/perl5/issues/23192]

&CORE::__CLASS__ no longer returns invalid results 🙈

CORE::__CLASS__ would work as expected when used as a bareword or aliased:

use feature qw(class);
class Foo {
    BEGIN { *cls = \&CORE::__CLASS__; }
    method bar() {
        my $class1 = CORE::__CLASS__;  # ok
        my $class2 = cls;              # ok
    }
}

but when called with an ampersand (&CORE::__CLASS__()) or through a reference (my $ref = \&CORE::__CLASS__; $ref->()), it would return unrelated strings. literally just making stuff up. 😭

these runtime calls have been fixed to throw an error of the form &CORE::__CLASS__ cannot be called directly instead of silently returning incorrect results. much better than a mystery string, ngl.

[GH #23737 — https://github.com/Perl/perl5/issues/23737]

parse_subsignature() handles empty signatures now 📝

previously, calling the parse_subsignature() API function with an empty signature would cause a Syntax error failure, which meant code that calls it had to detect the special case and take appropriate steps. annoying.

this is now fixed, and it returns the same optree that the parser would yield for a regular empty signature during normal parse time. ✨

[GH #17689 — https://github.com/Perl/perl5/issues/17689]

-CA and the -s option's globals 🌈

the -CA flag (or equivalently, the PERL_UNICODE=A environment setting) tells perl to treat command-line arguments as UTF-8 strings. (see perlrun for details.) however, this did not extend to the global variables implicitly created by the -s option:

$ perl -CA -s -e 'printf "%vx\n", $_ for $foo, $ARGV[0]' -- -foo=é é
c3.a9
e9

here $foo would end up containing the two-byte UTF-8 representation of LATIN SMALL LETTER E WITH ACUTE, but $ARGV[0] would contain a single codepoint corresponding to U+00E9. inconsistent much?? 🙄

this has been fixed: if -CA is in effect, options parsed by -s are treated as UTF-8, too. in the example above, $foo and $ARGV[0] now both contain chr(0xE9). [GH #23377 — https://github.com/Perl/perl5/issues/23377]

Long identifiers in non-ASCII languages 🀄

we have long claimed to support identifiers up to about 255 characters long. however this was actually true only for identifiers that consisted of only ASCII characters. the real upper limit was as few as 64 characters for identifiers written in languages using non-ASCII characters, for example, Chinese or Osage. lowkey embarrassing.

now an identifier in any language may contain at least 255 characters. 💅

Array names starting with a digit 🔢

fixed parsing of array names starting with a digit in double-quotish context under use utf8;.

use 5.42 and source encoding ⭐

use 5.42 now turns on use source::encoding "ascii" for the remainder of the line (besides subsequent lines). [GH #23881 — https://github.com/Perl/perl5/issues/23881]

Ternary second branch autovivification 🔀

since 5.32.0, the second branch of a ternary condition operator wasn't getting the correct autovivification context applied. for example in something like

@{ $cond ? $h{foo} : $h{bar} } = ...;

the first branch would correctly autovivify $h{foo} to an array ref, but the second branch might incorrectly autovivify $h{bar} to a hash ref. [GH #18669 — https://github.com/Perl/perl5/issues/18669]

No jump-into-construct warning while DIE-ing 🚫

don't warn about jumping into a construct if we're DIE-ing. [GH #23922 — https://github.com/Perl/perl5/pull/23922]

Regexes with a sub-pattern and a cut 🎭

regexes which include both a sub-pattern (e.g. (??{...}) or (?&FOO)) and a cut (i.e. (?>...)) could sometimes cause a premature scope exit in other code during a match. for example, in something like (?{ local $x = ... }), the local might have been unwound before the pattern has finished matching. [GH #16197 — https://github.com/Perl/perl5/issues/16197]

DB::sub and overloaded subs 🔍

DB::sub is not meant to be called for sub calls from the DB package, but calls to overloaded subs for overloaded values used in the DB package would result in calls to DB::sub. fixed the check for the current package in amagic_call(). [GH #24001 — https://github.com/Perl/perl5/issues/24001].

Hex float significands that are too big 🔬

fix parsing of hexadecimal floating-point numbers whose significand (aka mantissa) values are too large to fit in UV range. such literals (for example, 0x1234567890.1p+0 for 32-bit IV/UV platform, or 0x1234567890_1234567890.1p+0 for 64-bit IV/UV) used to be parsed incorrectly.

Daylight savings time, bestie ⏰

Perl 5.42.0 did not handle the transition to/from daylight savings time properly, fixed in 5.42.1. the time and/or timezone could be off by an hour in the intervals surrounding such transitions. this was a regression from earlier releases. this bug was evident from perl space in the strftime in POSIX function, and in XS code with any of my_strftime in perlapi, sv_strftime_ints in perlapi, or sv_strftime_tm in perlapi.

sort() overloaded numeric comparison precision 📊

sort() optimizes common comparisons from calling the OP tree for a comparison block into a call to a C function. the C function used for overloaded numeric comparisons did not handle the case where there was no comparison overload but there was a numeric (0+) overload correctly, losing precision for large overloaded integer arguments that are not exactly representable as a Perl floating point value (NV). [GH #23956 — https://github.com/Perl/perl5/issues/23956]

undefing a scalar filehandle target mid-output 🗑️

when a scalar variable used as the target of a filehandle is undef'ed while being output, garbage bytes would be left in that scalar. [GH #24008 — https://github.com/Perl/perl5/issues/24008]

Filehandle target outputting onto itself 😵

when a scalar variable was used as the target of a filehandle and also was output onto itself, garbage could result, or even trigger a segmentation fault (as in open $fh, '>', \$str; print $fh $str;). [GH #24199 — https://github.com/Perl/perl5/issues/24199]

close(STDOUT) on a pipe, Windows edition 🪟

close(STDOUT) when STDOUT has been opened as a pipe will now properly wait for the child to exit on Windows. [GH #4106 — https://github.com/Perl/perl5/issues/4106]

XSUB via goto in scalar context 🌀

calling an XSUB via goto in scalar context, where the XSUB didn't return exactly one value, could result in the return of the wrong number of items, leading to potential stack corruption. for example:

sub wrap { goto \&an_xsub_which_returns_no_values }
$ret = wrap();

[GH #24212 — https://github.com/Perl/perl5/issues/24212]

Empty initializer list on an array field (debugging perls) 💥

on debugging perls, instantiating a class with an array field with an empty initializer list would abort with an error:

class Foo {
    field @bar = ();
}
Foo->new();

error message:

perl: inline.h:194: Perl_av_new_alloc: Assertion `size > 0' failed.

this has been fixed. [GH #24246 — https://github.com/Perl/perl5/issues/24246]

Refassigning to a class field in a method 🫠

refassigning to a class field in a method could result in the SV for that field being released when the method exited. the next access to that field could result in a crash or an assertion, or if the freed SV had been re-used, random data. discussed in [GH #24187 — https://github.com/Perl/perl5/issues/24187]

🧐 Known Problems 🧐

None

like genuinely none. we're so back. 👑

🕊️ Obituary 🕊️

WELL VOLUNTEERED! echoed across conference rooms and IRC channels. Matt S. Trout's battle cry that transformed reluctant volunteers into community leaders.

with profound sadness, we announce Matt's passing. since the early 2000s, Matt shaped Perl through sheer force of will: IRC operator, PAUSE administrator, Shadowcat Systems co-founder, architect of DBIx::Class. his opinions came wrapped in profanity and delivered at maximum volume. he suffered no fools and grew to sometimes realize he should apologize. yet this same abrasive exterior protected fierce dedication to mentoring — developers he harangued into volunteering now lead the community themselves. Matt's deliberately mind-bending code pushed Perl forward. every modern Perl developer touches his legacy daily.

well volunteered, Matt. rest in peace. 🫶

💖 Acknowledgements 💖

okay so before ANYTHING else, we gotta give credit where credit is due, because Perl 5.44.0 is literally the result of approximately 12 months of development since Perl 5.42.0, and it contains approximately 270,000 lines of changes across 1,300 files from 71 authors. bestie that is a LOT of typing 😭💅

And excluding auto-generated files, documentation and release tools, there were approximately 110,000 lines of changes to 860 .pm, .t, .c and .h files. slay.

Perl continues to flourish into its fourth decade thanks to a vibrant community of users and developers. The following people are known to have contributed the improvements that became Perl 5.44.0 — no cap, these are the icons 👑:

Alexander Karelas
Aristotle Pagaltzis
Arne Johannessen
Bartosz Jarzyna
Branislav Zahradník
brian d foy
Chad Granum
Chris 'BinGOs' Williams
Chris Prather
Christian Hansen
Craig A. Berry
Dagfinn Ilmari Mannsåker
Dan Book
Dan Church
Daniel Dragan
Daniel Laügt
Daniel Tang
Dan Kogai
Dave Cross
David Mitchell
Dmitrii Kuvaiskii
E. Choroba
Ed J
Elvin Aslanov
Eric Herman
Eugen Konkov
Graham Knop
Harald Jörg
H.Merijn Brand
Igor Todorovski
James Cook
James E Keenan
James Raspass
Jörg Thomas
Karen Etheridge
Karl Williamson
Leon Timmermans
Lukas Mai
Marc Reisner
Masahiro Iuchi
Matthew Horsfall
Maxim Vuets
Max Maischein
Nicolas R
Olaf Alders
Paul Evans
Paul Marquess
Peter John Acklam
Philippe Bruhat (BooK)
Ricardo Signes
Richard Leach
Robert Rothenberg
Ryan Carsten Schmidt
Samuel Smith
Samuel Young
Scott Baker
Sevan Janiyan
Shirakata Kentaro
Sisyphus
Stan Ulbrych
Stefan Adams
Štěpán Němec
Steve Hay
TAKAI Kousuke
Thibault Duponchelle
Toby Inkster
Tomasz Konojacki
Tom Wyant
Tony Cook
Unicode Consortium
Yitzchak Scott-Thoennes

ngl though, that list above is almost certainly incomplete, because it's automatically generated from version control history. in particular, it doesn't include the names of the (very much appreciated 🫶) contributors who reported issues to the Perl bug tracker. so if you're not on there and you helped — you're still iconic to us.

Many of the changes included in this version originated in the CPAN modules included in Perl's core. We're grateful to the entire CPAN community for helping Perl to flourish. 💜

For a more complete list of all of Perl's historical contributors, please see the AUTHORS file in the Perl source distribution. go look, it's giving legendary lineage.

🐛 Reporting Bugs (tell us bestie) 🐛

If you find what you think is a bug, you might check the perl bug database at <https://github.com/Perl/perl5/issues>. There may also be information at <https://www.perl.org/>, the Perl Home Page. do a lil vibe check over there first ✨

If you believe you have an unreported bug, please open an issue at <https://github.com/Perl/perl5/issues>. Be sure to trim your bug down to a tiny but sufficient test case. fr fr, the smaller the repro the faster we can help — nobody wants a 4000-line paste 😭

If the bug you are reporting has security implications which make it inappropriate to send to a public issue tracker, then see "SECURITY VULNERABILITY CONTACT INFORMATION" in perlsec for details of how to report the issue. please do NOT drop a CVE in the public issues, i am begging 🙈

🎀 Give Thanks 🎀

If you wish to thank the Perl 5 Porters for the work we had done in Perl 5, you can do so by running the perlthanks program:

perlthanks

This will send an email to the Perl 5 Porters list with your show of thanks. that's it. that's the whole thing. one command, so much love 💖 go be the reason someone smiles in the porter channel today.

📚 SEE ALSO 📚

The Changes file for an explanation of how to view exhaustive details on what changed. (iykyk, it's a whole journey.)
The INSTALL file for how to build Perl.
The README file for general stuff.
The Artistic and Copying files for copyright information.

and that's the whole page bestie 🦋 this was perl v5.44.0, dated 2026-10-17, from the PERLDELTA(1perl) manual — go forth, upgrade, and slay 💅✨🌸

📦 where this page comes from

arch rolling: perl 5.44.0-1 · Artistic-1.0-Perl AND GPL-1.0-or-later
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-11-03: a language model's rewrite of the original, under its terms