CPANscan

Timer::Wheel is a lightweight, high-performance timer scheduler for Perl that lets you schedule one-shot or recurring callbacks by absolute epoch or relative delay and then fire them by calling tick, making it easy to run stand-alone or integrate with an event loop by invoking tick periodically. It supports grouping timers for bulk cancellation, pausing and resuming individual timers or the entire wheel, and provides helpers to inspect the next deadline and number of pending timers. The implementation uses a priority heap for efficient inserts and peeks and is optimized for fast object construction, so it is a good choice when you want a simple, dependency-light timing facility rather than a full async framework. The current 0.02 release fixes packaging pax headers and the module is distributed under the Artistic License 2.0.

App::karr is the core module behind the karr command line tool that implements a Git-native kanban board kept entirely in Git refs under refs/karr, with task cards stored as Markdown plus YAML frontmatter and board configuration kept in refs rather than in checked-in files. Commands build a temporary board view, let you create, list and update tasks, then serialize changes back into refs and push them, which keeps your repository free of a persistent board tree and avoids usual file-level merge conflicts for shared task state. The distribution includes Docker images for running karr without installing Perl and exposes lower-level modules like App::karr::Git, App::karr::BoardStore and App::karr::Task for programmatic automation, including loading tasks, allocating ids, saving tasks and taking snapshots. The CLI auto-discovers a repository by walking upward from your current directory and shows a quick board summary when run with no subcommand, making it a practical choice if you want task tracking that treats Git as the transport and single source of truth.

Heap::PQ is a compact, C-backed binary heap for Perl that gives you fast min or max priority queues with three ways to use it: an OO API, a functional API that uses custom ops for compile-time speedups, and a raw array API for maximum performance. It supports normal values, a numeric-native variant that stores doubles without SV overhead, custom comparator callbacks for complex objects, and a special dot-separated key-path option that extracts numeric keys at push time so comparisons stay in C and run very quickly. Typical uses are task scheduling, leaderboards, top-k selection and any scenario that needs efficient push, pop, peek and peek_n operations. The module is tuned for speed in benchmarks and recent releases have focused on Perl compatibility fixes and comparator optimizations and bug fixes to improve stability across Perl versions.

EBook::Ishmael is the core Perl module behind the ishmael ebook dumper, providing a programmatic interface to initialize and run the tool and to extract ebook contents and metadata in a variety of forms. You can create an instance with init (which reads @ARGV), then call run or use methods to dump formatted text, raw text, HTML, cover images, identify file formats, or export metadata as ishmael, JSON or XML. It supports many common ebook formats and falls back to external formatters when needed, includes heuristics to guess encodings, and is designed for embedding ishmael functionality in scripts or extending it. This is developer-level documentation, so consult the ishmael manual for user-facing options. Recent updates improve HTML cleanup and namespace handling for EPUB and FictionBook2 files so the module produces cleaner HTML output from namespaced formats.

Date::Holidays::GB is a Perl module that provides UK public and bank holiday dates (data current through 2028) and simple routines to query them. It exports holidays, is_holiday and next_holiday so you can list holidays for a given year or set of regions, check whether a specific date is a holiday (accepting year/month/day or a YYYY-MM-DD string), and find the next holiday for one or more regions. Queries can be limited to England & Wales (EAW), Scotland (SCT) or Northern Ireland (NIR), or you can use region-specific subclasses for convenience. Results come back as hashrefs keyed by MMDD with human readable names and region tags, and the dataset is generated from the official UK government JSON files with a date_generated stamp, although published future dates can occasionally change after release.

PDF::Make is a comprehensive Perl toolkit for creating, reading, and editing PDF files. It offers a recommended high-level, chainable Builder API that handles page layout, coordinate translation, word wrap, fonts, images, tables of contents, and common shapes so you can assemble reports and forms with minimal fuss. For cases that need full control it also exposes a low-level XS API that maps directly to PDF objects, content streams, and page structure. The distribution includes parsers and extractors for text, annotations and tables, support for standard and TrueType fonts, image embedding, interactive features and forms, layers and attachments, redaction and metadata sanitisation, color spaces, encryption and digital signatures, and optional linearisation for fast web view. It has minimal runtime dependencies and is actively maintained; the recent 0.06 release fixes PDF real-number formatting and addresses an XS allocation/compile issue to improve portability on Windows and other builds.

File::Raw is a performance-focused file utility for Perl that bypasses PerlIO and uses direct system calls to read, write, copy, memory-map and inspect files with minimal overhead. It exposes convenient helpers like slurp/spew, append, atomic_spew, efficient line streaming via each_line, a memory-efficient line iterator, head/tail/range access, and a cached stat API to avoid repeated syscalls. The module also includes an extensible plugin system so you can register format or transform plugins in Perl or C and chain byte-level filters like gzip with record-level parsers like CSV, with an XS API for native plugins when you need per-call performance. Platform-specific optimizations such as sendfile on Linux and copyfile on macOS are used where available and the module provides atomic writes and zero-copy mmap reads for large files. Note that plugin-backed iterators are eager and each_line is the recommended streaming path for memory-bounded processing, and you can clear the internal stat cache if external processes change files. If your work involves high-throughput file IO, large or compressed files, or custom format pipelines, File::Raw is a relevant choice. The most recent release fixes a Perl 5.12 build incompatibility to improve compatibility on older Perls.

DBI is the de facto database interface for Perl that gives you a single, consistent API for connecting to and talking to many different databases via driver modules (DBD::*) so your code can be portable across engines. It does not implement database engines itself but dispatches calls to DBD drivers and supplies conveniences for common tasks like connect/connect_cached, prepare/prepare_cached, execute, fetching rows as arrays or hashes, bulk operations, quoting and identifier quoting, transaction control with AutoCommit/commit/rollback, and utilities such as last_insert_id and selectrow_hashref. It also supports placeholders to help avoid SQL injection, attributes and callbacks to control error handling and tracing, and helpers for performance and debugging like execute_array and built in trace/profile hooks. If you write Perl programs that access SQL databases DBI is essential and you should use it together with the specific DBD driver for your database and consult the driver documentation for engine specific behavior.

Bijection::XS is a tiny, fast Perl extension for turning integers into short, human-friendly strings and converting those strings back to the original integers. It exposes simple functions named biject and inverse, and lets you customize the character alphabet with bijection_set and add an integer offset with offset_set for basic obfuscation or namespace shifting. The module ships with a URL-friendly alphanumeric default set and benchmarks show it is several times faster than the pure-Perl equivalent, so it is well suited for high-throughput tasks like generating short IDs, compact database keys, or URL shorteners. Documentation is available via perldoc and the distribution is on CPAN with standard bug reporting.

Bijection is a compact Perl module that turns integers into short, reversible strings and back again, exporting biject to produce a bijected string and inverse to recover the original integer. It lets you customize the symbol set with bijection_set and apply a numeric offset with offset_set, and it ships with a predefined list of letters and digits by default. Because the mapping is a true bijection it is deterministic and invertible, making this module handy for creating compact identifiers, human-friendly codes, or simple obfuscation of numeric IDs for use in URLs, logs, or short tokens.

Font::FreeType is a Perl wrapper around the FreeType2 library that makes it easy to load font files, inspect metrics and outlines, and render individual glyphs as bitmap images or scalable outlines. You create a Font::FreeType object, open a face from a font file, set a size and resolution, then fetch glyphs by character or code point and obtain bitmaps, metrics, SVG paths and other information. The API is designed to be more Perl-friendly than the raw C interface and supports many font formats that FreeType understands, which makes the module useful for generating text images, exporting glyph outlines to vector formats, building typographic tools, or extracting font metadata. The distribution has been actively maintained with bug fixes, test updates, and added helpers like glyph iteration and load-flag control, but the original author warned the module began life in beta so some values or behaviors can still vary with FreeType versions. If you need programmatic access to fonts from Perl and want high-quality rendering plus outline extraction, this module is likely relevant.

App::PDFUtils is a small collection of command-line helpers that simplify common PDF tasks by wrapping standard tools like qpdf, GhostScript and pdftotext, so you can add or remove passwords, check for protection, compress files, split large documents, extract or grep text, and run batch operations with convenience features such as configuration-file support, multiple-file handling, automatic output naming, and optional backups. The utilities are designed for day-to-day workflows where you want quick, scriptable actions rather than low-level PDF programming, and they expose sensible defaults while letting you pass options like page ranges, overwrite behavior, and multiple password attempts. Because the programs are thin wrappers, they rely on those external command-line tools being available on your system, and the project notes plans to add OCR-based text extraction in the future.

List::Compare is a small, well tested Perl module that makes common list-set operations simple to use by wrapping intersections, unions, differences, symmetric differences and multisets (bags) in an object-oriented API and a parallel functional interface. It works with two or many lists and accepts either array references or seen-hash references, returns results as arrays or array references, and also supplies Boolean queries such as subset, equivalence and disjointness plus simple pretty-printed charts. There is an accelerated mode that defers computation for a single requested comparison and an unsorted option to avoid the cost of sorting when you do not need human-friendly output. The module is mature and actively maintained; recent updates prepared for future Perl strictness and modernized the test suite to use Capture::Tiny.

OPCUA::Open62541 is a Perl XS wrapper for the open62541 C library that lets Perl programs act as OPC UA clients or servers. It exposes objects for Server, Client, Variant, ServerConfig, ClientConfig and a Logger so you can create and configure servers, connect clients, read and write node values, browse address spaces, create subscriptions and monitored items, and register callbacks for asynchronous operations and lifecycle events. The module maps most open62541 functionality into Perl method calls and relies on the open62541 documentation for semantic details. Note that the interface is not yet complete and 64 bit Perl builds are required for 64 bit UA integer types.

Data::NestedKey is an object-oriented Perl helper for easily inspecting and modifying deeply nested hash and array structures using simple dot-separated path strings with optional [n] array subscripts. It lets you read, delete and check for deeply nested values without manual traversal and supports convenient set semantics such as a + prefix to append or merge and a - prefix to remove keys or array elements. Array subscripts are supported for get, exists_key and delete but not for set, and you cannot set directly against an array-rooted structure so arrays must be retrieved and edited directly when needed. The object can also serialize its contents to JSON, YAML, Data::Dumper or Storable and includes options for pretty JSON output, making it handy for manipulating configuration files and API responses.

App::Test::Generator is a toolset for automatically creating black‑box tests for Perl code by turning compact input/output schemas into runnable Test::Most test harnesses that combine randomized fuzzing, deterministic edge cases, optional static corpora, and property‑based tests. It reads YAML or programmatic schemas that describe a routine's parameters and return types and emits reproducible fuzz tests with semantic generators (emails, UUIDs, timestamps, etc.), boundary checks, and optional Test::LectroTest properties, and it can be driven from the command line or used from Perl. The distribution also bundles mutation testing, LCSAJ path metrics, a test-quality dashboard that aggregates Devel::Cover and CPAN Testers data, schema extraction from Perl sources, benchmark script generation, and helpers to deploy GitHub Actions workflows so you can run scheduled fuzzing and collect CI-driven improvements. A recent 0.42 release added corpus minimization to keep fuzz corpora small while preserving coverage, a pod-example tester to turn POD examples into round‑trip tests, a benchmark-generator, and a deploy-workflows command plus better CPAN Testers reproduction scripts, making it especially useful for CPAN authors who want to harden their modules against edge cases and automate continuous fuzz and mutation-driven quality improvement.

Mojolicious::Plugin::BarefootJS is a small plugin that integrates the BarefootJS server runtime into a Mojolicious application. It registers a helper named "bf" that lazily provides a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo and lets you render compiled marked templates as native Mojolicious templates. Install it with $self->plugin('BarefootJS') to expose the helper in controllers and templates, and use BarefootJS::Backend::Xslate if you need the same runtime outside Mojolicious. The module is actively maintained and is released under the MIT license.

BarefootJS::Backend::Xslate is a small adapter that lets the BarefootJS runtime render Kolon-format Text::Xslate templates. It either accepts a ready-made Text::Xslate object or builds one from a list of template paths and options, configures HTML auto-escaping, and provides the runtime hooks BarefootJS expects such as render_named which binds the runtime as the bf object, mark_raw for raw HTML, and a customizable JSON encoder. The module is framework-agnostic so it runs under PSGI/Plack or in plain scripts, and it is intended to be used with the @barefootjs/xslate compile-time adapter that emits .tx templates calling runtime helpers as bf methods. If you use BarefootJS and prefer Kolon/Text::Xslate templates this backend connects the two with minimal configuration.

BarefootJS provides a server-side runtime for templates compiled from JSX/TSX so you can render marked templates and produce client JavaScript from Perl without locking into a particular template engine or web framework. Compiled templates call the runtime for helpers, while backend plugins handle engine-specific tasks like JSON marshalling, raw-string marking, JSX children materialization and named-template rendering. The core uses only Perl core modules and you add a backend when you need one; shipping backends include Text::Xslate for PSGI/Plack and a Mojolicious integration. If you want to generate and render JSX/TSX-based templates from Perl while keeping the freedom to choose your rendering stack, BarefootJS is a lightweight, backend-driven option and it has seen active development with multiple releases through July 2026.

Imager::File::TIFF is the TIFF read/write plugin for the Imager image toolkit, letting Perl programs load and save TIFF images and query available TIFF compression codecs. It integrates libtiff so you can pick compression by numeric code or libtiff name and it exposes helper methods to report the libtiff build and runtime versions used by the module. The code aims for robust handling across multiple libtiff releases and includes fixes for warnings handling and memory leaks introduced by libtiff interactions. A few edge cases remain, for example mixed SampleFormat values may not always be handled perfectly because libtiff can expose only the first value, but most common TIFFs are supported and recent releases have improved compatibility and stability. If you use Imager and need reliable TIFF support or want to enumerate compression options, this module is the relevant interface.

Imager::File::JPEG is the JPEG plugin for the Imager image toolkit that lets you read and write JPEG files and also query the underlying libjpeg implementation used at build time. You use it through Imager for normal image IO and you can call its helpers to get the libjpeg type and version and to detect whether it was built with libjpeg-turbo or mozjpeg. The module also reports support for arithmetic coding and whether encoding or decoding of arithmetic coding is available. This is useful when you need to know which JPEG features and performance characteristics are available on your system.

Imager is a mature, full-featured Perl library for creating, reading, writing and manipulating bitmap images across many common formats. You can draw primitives, render text with font metrics, apply filters and effects, blend and composite images, and perform transformations like scale, crop and rotate, with fine control over color, palettes and alpha channels. It is well suited to generating thumbnails, server-side image processing, simple graphics generation and batch image workflows where you want a Perl-native API rather than calling external tools. The module is actively maintained and recent releases include important security and robustness fixes, for example Imager 1.033 resolves an EXIF parsing issue and fixes several memory leaks, so keep installations current for production use.

Devel-Cover-Report-Codecovbash is a small Perl reporter that converts Devel::Cover output into a codecov.json file you can upload with the Codecov bash uploader. It runs as a Devel::Cover report plugin and writes cover_db/codecov.json by default so you can run cover -report codecovbash and then invoke the Codecov bash script to submit your coverage results. The module is lightweight, MIT licensed, and largely derived from an earlier Devel::Cover Codecov reporter, and recent releases improve robustness by avoiding crashes when statements are missing and by correctly marking lines that contain any covered statement as covered. Use it when you want a quick, compatible way to push Perl test coverage to Codecov.

MojoX::MojoDbWrap is a small, practical adapter that normalizes the common parts of Mojo::Pg, Mojo::SQLite and similar database objects and adds a few handy helpers so you can treat different backends the same way. It forwards basic calls like select to the underlying DB handle, exposes the wrapped object and its class, and provides convenience routines id_of and id_or_insert for finding a record id by condition or creating the row and returning its id when missing, with support for custom id column names. It also integrates optional migrations via a migrations_for mapping and is extensible through a wrappers or inserter_for mechanism so you can plug in custom creation and insert logic or pass an existing DB object. The module is aimed at Mojolicious users or any Perl app that needs a lightweight, uniform DB interface across Pg, SQLite or custom drivers, requires Perl 5.24 or later, and was formally released as an official distribution in version 0.002.

HTTP::Validate is a Perl utility for validating and cleaning HTTP request parameters against reusable, human-readable rulesets so your web routes, forms and APIs only receive well-formed input. You define named rulesets composed of parameter rules (mandatory, optional, multiple, split, aliases, defaults, cleaners) and inclusion rules (allow, require, require_any, require_one, etc.) then call either the procedural check_params or an OO validator to get a result object that contains cleaned values, errors, warnings and convenience accessors. The module ships a set of common validators for integers, decimals, enums, booleans and flags, lets you write or parametrize custom validators, and can auto-generate Pod documentation from the rules so your docs stay in sync with validation logic. It works with Dancer, Mojolicious, Catalyst and similar frameworks and can be used with CGI when combined with a persistent handler. The 1.0 release adds list_rulesets, list_rules and value_list methods and fixes a number of bugs to improve reliability and test coverage.

Tree::DAG_Node provides a simple, battle-tested object for building and manipulating N-ary trees by treating each node as an object you can name, attach attributes to, and link into a parent/children structure. It can be used directly or extended as a base class and protects you from invalid linkages like cycles or multiple parents while offering a rich set of convenience methods for adding, removing and replacing children and siblings, traversing depth first, copying subtrees or whole trees, serializing to and from list-of-lists notation, and rendering ASCII diagrams of your tree. The module also includes utilities for reading and writing tree text with UTF-8, for producing test networks, and for explicit tree destruction via delete_tree to break Perl reference cycles and free memory. The API is large and featureful, so it can feel heavyweight for tiny tasks but is efficient for simple use and flexible when you need advanced tree operations or to subclass it for domain-specific behavior. Note that a couple of helpers such as random_network were written for testing and may not be suitable for production randomization without review. If you need a straightforward, well proven way to represent parse trees, syntax trees, game trees or other hierarchical structures in Perl, this module is likely relevant.

Tree::Cladogram renders phylogenetic trees (cladograms) into image files using either Imager or Image::Magick, reading a plain tab-separated text format that lists parent, placement (above/below) and node names. It ships command-line scripts and sample .clad inputs so you can generate publication or web-ready diagrams quickly and tune appearance with options for branch color and width, margins, title and leaf fonts, font sizes, and spacing; the output image type is chosen by the output filename suffix and Image::Magick in particular supports a very large range of formats. The module builds the tree with Tree::DAG_Node, handles overlap of leaf labels, and provides methods to adjust most drawing parameters programmatically, so it fits easily into scripts or batch workflows. Be aware that font support can vary by renderer and platform so TrueType rendering may require the appropriate backend in Imager or use of Image::Magick, a limitation the author documents and accounted for in testing. Recent updates modernize the packaging and licensing files and add an AI_POLICY.md alongside a refreshed LICENSE.

Crypt::PasswdMD5 is a compact Perl module for creating MD5-based password hashes that interoperate with Unix MD5-crypt implementations and Apache .htpasswd files. It provides unix_md5_crypt and apache_md5_crypt to produce compatible hashed password strings and a utility random_md5_salt to generate salts when you do not supply one. The implementation follows the common FreeBSD-style MD5-crypt so hashes can be used with existing systems that expect that format. Use this module when you need to generate or validate legacy MD5-crypt password entries for authentication, but not as a general-purpose encryption tool.

Dist::Mgr is a practical toolkit and command line helper for automating the full lifecycle of a Perl distribution from creation to release. It scaffolds a Module::Starter-based skeleton, wires up Makefile.PL/ExtUtils::MakeMaker metadata, integrates with Git/GitHub and GitHub Actions for CI, manages version numbers and Changes files, updates copyright years, builds testable dists and can upload tarballs to PAUSE/CPAN. The module is designed as a set of utilities invoked from the provided distmgr script and assumes GitHub and Module::Starter for many workflows. Recent releases improved compatibility with newer Module::Starter and modern Perls and fixed a bug that could mis-handle nested module directories when moving generated files after initialization.