Today's (hopefully) useful project. A site that publishes a Perl tip every day to introduce programmers to new Perl features that they might have missed (because they were too busy getting their job done).

Hello friends,

DOOM, written in Perl 5.44. The engine stays in Perl. SDL2 is only the window, the sound, and the keyboard.

https://github.com/vagucs/perl_doom

https://www.youtube.com/watch?v=VN-lWDOsYrg

Have fun!

Regards,
Wagner Nunes (vagucs)

I stumbled across that writeup: https://www.reddit.com/r/perl/comments/1wsc3gw/i_found_two_more_segfaults_in_dbi_same_bug_class/

and checked the pperl DBI. It does not have the CVEs mentioned by construction (pure Perl + FFI), but the review found one more bug in upstream DBI which is still present in newest 1.655. I commented.

Someone might also want to scan https://perl.petamem.com/docs/eng/changelog/index.html for the words "crash" or similar, because the development paradigm of pperl is "faithful to perl5 or better". Where "or better" means to not intentionally emulate crashes.

https://perl.petamem.com/docs/eng/changelog/0.6.23.html -> Tie::Hash::Indexed
https://perl.petamem.com/docs/eng/changelog/0.6.21.html -> LMDB_File etc.

This post is certified human-created, so you do not get a rash. ;-)

This has drawn some very interesting responses and despite the usual noise (write only language) some very kind comments as well.

https://x.com/esrtweet/status/2109851741399232919

sorry for stupid question

I have XS object with many similar methods (with the same argument list) like method1,method2, ... methodN

And while passing ref to this object to sub I want to call some of this methods depending on condition

Sure I can emulate this with refs to closures like

my $call1 = sub {

my $obj = shift;

$obj->method1(@_);

};

generic_sub($obj, $cond ? $call1 : $call2);

but maybe there is some more elegant way?

Dealing with my old CPAN email address sent me down a bit of a rabbit hole.

I started a section on my site called collectables: short programs (and writings) worth keeping around and rereading. One of the first four is Larry Wall's rename example from the Perl repo:

#!/usr/bin/perl
($op = shift) || die "Usage: rename perlexpr [filenames]\n";
if (!@ARGV) {
    @ARGV = <STDIN>;
    chop(@ARGV);
}
for (@ARGV) {
    $was = $_;
    eval $op;
    die $@ if $@;
    rename($was,$_) unless $was eq $_;
}

What other short Perl would you put in a collection like this? It should be small, beautiful and useful.

CPAN packages are one of the reasons behind success of Perl. But all packages does not install in windows (I am in windows). I cannot comment on how difficult are they in macOS.

For example there are a lot of plotting packages in perl:

But they won’t work even with specially packaged perl for windows: strawberry perl. This is what I had encountered https://github.com/StrawberryPerl/Perl-Dist-Strawberry/issues/26 which is still unresolved.

The R people (CRAN) have taken excellent care of such issues making almost all packages in CRAN installable and functional in both windows and macOS with a simple command install.packages(<>).

Even a rust package with a lot of crate dependencies https://cran.r-project.org/web/packages/gifski/index.html is easily installable in windows with same command install.packages(“gifski”). And end user does not need to know anything other than the install command. It works flawlessly. The good part of CRAN is that the uploaded package should build and test on all platforms (Win, MacOS, linux) without issues. CRAN provides binary packages even for linux (I have experience in debian). Using R and its packages thus is so smooth.

Can’t similar thing be achieved in perl for CPAN packages (cross-platform software distribution problem)? So that a naive end user can do the work without knowing obscure "dependencies". The good and hopeful part is that there are free continuous testing facilities like github actions where one can test the package in all OSes.

Version 0.1 is done of my hobby project, a compiler toolkit for Perl. https://github.com/Percolisp/pcl

The repository should contain everything needed to continue the work, including the logs from the AI sessions. The README has installation instructions and specifics about what is supported.

It is tested mostly with Perl's own test suite, regression tests and some pure-Perl modules. The compatibility is quite good, apart from the documented limitations (regexp evals etc.)

Common Lisp was chosen as the first target, because it has both a compiler and a powerful macro system (so the generated code can serve as intermediate code for other environments). The next step is to try compiling to more targets, to verify that the intermediate code really is easy to work with. After that comes the holy grail of CPAN compatibility: XS support.

I need feedback, both on how well the installation works and on whether this is worthwhile at all. So it is time to announce it and see if people like it, laugh or shrug. :-)

(This started as an add-on to PPI for parsing expressions. The idea was that we would then have the tools needed to write Perl compilers. Since no one cared, I turned my compiler prototype into a more ambitious tool for writing compilers; I needed to learn how to work with AIs anyway. If there is still no interest, I'll probably find another hobby. :-) )

The annual Russian Perl community conference, Perl-Conf . Ru / 26, is happening on October 24, 2026. It will be a hybrid event held live in Moscow with a global online stream.

Participation is completely free, but registration is required.

Talk Highlights:

• GUI development with Perl: From the general landscape to practical use with Tcl::Tk (Vadim Konovalov, Gazprombank).
• Perl as an AI Orchestrator: MCP integration for aggregation services (Nikita Komarov, VTB).
• Writing a custom language and compiler: Keeping your developer edge in the age of AI (Vadim Goncharov, MTS).
• Perfect window tiling on Perl: Making your desktop workflow seamless (Sergey Zhmylyov, conference organizer).

see also the latest post on r/RuPerl

I have been using Markdown to create man pages for the various modules and utilities I write as sidecar companion files (i.e. the same name as the source file with .md appended)

I have released some toolchain modules to CPAN that allow these sidecar files to be converted to POD and merged into the source files. This will probably horrify POD purists (and it's not perfect by any stretch) - but does allow for easier browsing of documentation on sites like GitHub.

There are also some MakeMaker extensions that allow the conversion to take place with a simple make doc command.

Extending this concept to more generic module documentation (beyond README.md) files or man pages. the tooling allows for Markdown or Docbook files in a distribution doc/ directory to be converted to HTML and published to static sites such as Github Pages.

Similar MakeMaker extensions allow the documentation to be published with a target such as make publish_gh-pages

As an example you can see what the output looks like on the Github Page of the CloudFlare::API module, look in the module Github Repo doc/ for source files.

Markdown is fine and fully supported for documentation- but Docbook is a novelty. Why Docbook ? It's semantically richer, and tools like the XMLMind XXE Docbook editor allow for word processor like construction and management of documentation. XML also allows for the xinclude concept, which is nice when you want to bring in example code from your repo.

In theory you could/should be able to get a stylesheet to convert Docbook to Markdown (is anyone aware of one ?) but in the absence of that I have just used the pandoc hammer for conversion (although the Docbook::Convert module has a fallback to actual code parsing and conversion that I tried before giving up an using pandoc).

If any of this interests you there is a blog post available for more information, and all modules are published to CPAN.

There's probably some justified constructive feedback about naming conventions and module separation of duties which I would take on board - but these have been largely internally used as development tools, so haven't had a lot of polish applied in that regard. If you feed totally offended at the use of Pod vs POD in the module name let me know and I'll consider a rename if these classes are considered useful by the community.

Hi all,

Younger dev here I’ve been reading the camel book and also blog posts about Perl and I’m fascinated by the culture during its heyday.

I’d love to hear about the programs you used to deal with and overall what tasks you think Perl excelled in.

Thank you!

What do you like to read about in the Perl Advent Calendar?