CPANscan

Test::Most is a convenience wrapper for Perl testing that bundles the most commonly used testing modules so you can write tests with far less boilerplate while automatically enabling strict and warnings by default. It imports Test::More plus Test::Exception, Test::Differences, Test::Deep and Test::Warn and adds handy utilities such as die_on_fail and bail_on_fail to stop a suite on the first failure, set_failure_handler to customize that behavior, explain and show for nicely dumping data structures and trying to display lexical variable names, and an optional timeit helper for simple timing of code. You can selectively exclude problematic modules or individual symbols from the bundle and you can restore normal failure behavior at runtime. A few legacy features like deferred plans and all_done are deprecated in favor of Test::More's done_testing, and recent maintenance releases improved compatibility with Test::Builder and stopped permanently altering Test::More's export list so it plays nicely with other test tooling. If you want a one-stop way to get a rich set of test helpers without managing many separate imports, Test::Most is likely relevant to your Perl test suites.

Atomic::Pipe lets multiple processes or threads write discrete messages into a POSIX pipe without their outputs getting mangled by splitting each message into atomic chunks that fit under PIPE_BUF and reassembling them on the read side so readers always receive complete messages. It exposes reader and writer objects you can create from a new pipe, an existing filehandle, fd, or FIFO and supports blocking or nonblocking I/O, one-shot atomic bursts for short writes, a mixed-data mode that interleaves framed messages with ordinary stdout/stderr output, and tools to clone or split ends and tune pipe buffer behavior. Recent releases added optional Zstandard compression with optional shared dictionaries so large messages often compress into a single atomic chunk and can dramatically improve throughput, and compression is only enabled and loaded when requested. The module is POSIX-specific, does not guarantee global ordering across different writers, and mixed-data mode depends on a few control characters that could be confused by raw binary noise, but for Unix-like systems that need reliable, atomic message delivery from many writers Atomic::Pipe is a practical, well-tested choice.

DBD::Pg is the official PostgreSQL driver for Perl's DBI that lets Perl programs connect to and work with Postgres databases in a DBI-compatible way. It handles connection details including service files and SSL modes, supports server-side prepared statements and multiple placeholder styles, and gives fine grained control over data types and quoting so you can bind integers, bytea, booleans, arrays and Postgres-specific types safely. The driver also supports bulk COPY operations, large object access, asynchronous queries and asynchronous connects, notification listening, and useful DBI extensions such as last_insert_id, table and column metadata, and handy attributes like AutoCommit, RaiseError and pg_enable_utf8 for Unicode handling. DBD::Pg is mature and actively maintained with a long track record of fixes and improvements. The recent 3.20.1 release tightened up asynchronous prepare handling, fixed a hang with COPY TO STDOUT in async mode, and improved documentation for SSL connection options, making async and secure connections more reliable.

Net::Z3950::FOLIO is a small Perl module that provides a Z39.50 server front end for searching and retrieving bibliographic records from the FOLIO inventory module. It is the application core used by the z2folio script and exposes just two public actions: new(configBase) to create an instance from a JSON configuration file and launch_server(label, @ARGV) to start a YAZ-backed Z39.50 server that runs until stopped, using the provided label for logging and interpreting command-line options for the YAZ backend. If you need Z39.50 access to FOLIO data this module does the heavy lifting and is intended to be used via the included tooling rather than as a general-purpose library.

Number::ZipCode::JP is a compact Perl module for validating Japanese postal codes against the official formats used by Japan Post. It accepts codes as separate area and suffix parts or as a single string with or without a hyphen, and you can limit validation to specific categories such as area-specific or company-specific codes by importing the matching table. You create an instance with new, set or change the code with set_number, and call is_valid_number to get a true or false answer. It is handy for input validation, batch checks, and cleaning address data in scripts and applications.

EV::Nats is a high-performance asynchronous NATS client for Perl that runs on the EV event loop and implements the protocol in XS for minimal overhead. It supports the full NATS feature set you are likely to need, including publish/subscribe with wildcards and queue groups, headered messages, request/reply with automatic inbox management, automatic reconnect with exponential backoff, graceful drain, TLS and NKey/JWT authentication, and higher-level helpers for JetStream, KeyValue and ObjectStore. The API is oriented around nonblocking callbacks and gives you publish, hpublish, subscribe, request, batch, flush and connection controls while exposing statistics and tuning knobs for keepalive, pinging, reconnect behavior and slow-consumer handling. Note the important caveats: DNS resolution is blocking so use numeric IPs for latency-sensitive apps, TLS and NKey require OpenSSL at build time, the module treats data as raw bytes so encode UTF-8 yourself, and you must not let the EV::Nats object be destroyed from inside a running callback. In the recent 0.02 release TLS hostname verification and NKey authentication were hardened, JetStream/KV/ObjectStore protocol issues were fixed, and tests and CI coverage were expanded.

Text::KDL::XS is a fast Perl XS wrapper around the ckdl C library that reads and writes KDL documents with automatic support for both KDL v1 and v2. It gives you a high level tree API via parse_kdl and emit_kdl that returns Document, Node and Value objects for full fidelity round trips, plus a streaming Parser that provides SAX-like, memory efficient processing of large files. parse_kdl accepts strings, filehandles, blessed IO objects or code references and supports options like version selection and comment emission, while emit_kdl can operate in a tree mode that preserves property order and type annotations or in a convenient data mode that converts plain Perl hashes and arrays to KDL with deterministic but lossy output. Scalars are coerced to KDL null, booleans, integers, floats or strings according to clear rules, and the emitter offers configurable indentation and escape/identifier modes for fine control of output. This initial CPAN release bundles ckdl via Alien::ckdl and focuses on speed, fidelity when needed, and a simple convenience mode for common configuration tasks.

Alien::ckdl is an Alien::Base distribution that downloads, builds and installs the ckdl C library (a C11 implementation for the KDL document language) and then exposes the compiler and linker flags to Perl XS modules so they can include <kdl/kdl.h> and link against libkdl with minimal fuss. It always builds the upstream main branch as a static library into a private share directory and intentionally bypasses the upstream CMake build, compiling only the C sources that make up libkdl and omitting the Python, Cython and C++ bindings and the test suite so there is no Python or CMake dependency. You can use it as a build-time prereq for XS consumers such as Text::KDL::XS or call Alien::ckdl->cflags and ->libs directly or let Alien::Build::MM inject the flags into your Makefile.PL for a seamless build. This is the initial CPAN release and therefore installs from source by design.

ChordPro is a mature Perl program that converts plain ChordPro-format song files into polished, print-ready song sheets and songbooks, most commonly as PDF. It handles lyrics interleaved with chord annotations, supports Unicode, user-defined instruments and chords, automatic transposition and capo handling, printable chord diagrams and embedded images, and can emit a table of contents and a companion CSV for use with apps. The tool is highly configurable via JSON or relaxed-JSON config files and offers both a command-line interface and a cross-platform GUI for assembling and previewing songbooks. It also supports embedding ABC and LilyPond material as vector graphics and can output other backends such as ChordPro, LaTeX, and HTML. ChordPro is a ground-up rewrite of the older Chordii reference implementation to support the ChordPro v5 standard and modern needs. Recent development has focused on reworking keys and transposition logic, expanding the built-in chord database (including jazzy chords), improving line wrapping and PDF metadata handling, and routine bug fixes and packaging updates. If you produce, transpose, print, or publish collections of chorded songs and want fine control over layout and fonts, ChordPro is likely relevant to your workflow.

Imager::File::HEIF is a plugin for Imager that adds reading and writing of HEIF/HEIC images by wrapping the libheif library. It lets you load and save HEIF files, inspect available encoders and decoders, and control compression via simple image tags such as heif_quality, heif_lossless, heif_compression and heif_encoder, with additional encoder-specific parameters exposed as heif_* tags. The module supports pixel aspect ratio through the standard i_xres and i_yres tags and can limit libheif decoding threads via MaxThreads on newer libheif releases. You will need Imager plus libheif, libde265 and libx265 development libraries and libheif 1.11.0 or later is required for current features. Note that HEVC compression is patent-encumbered so commercial use may require licensing, HEIF processing is resource intensive, and some encoder toolchains can leak memory. Recent updates add better monochrome detection (accepting the heix brand), a faster color/mono API to avoid double decodes, the ability to choose compression and encoder, programmatic encoder/decoder inspection and encoder parameter support.

Captcha::reCAPTCHA::V3 is a small Perl module that helps you integrate Google reCAPTCHA v3 into web applications by handling server-side verification of the token your pages generate, returning the decoded JSON response from Google's API and providing helpers to evaluate the risk score. The constructor needs only your secret key and optionally a site key and a custom query name, and the module offers convenience methods like deny_by_score to fail requests below a score threshold and scripts to emit the minimal JavaScript for acquiring tokens for forms. It is designed specifically for reCAPTCHA v3 and does not support v2 or supplying a remote IP for verification because the v3 API does not use it. Tests that exercise the client-side JavaScript are not included. Recent releases removed LWP dependencies in favor of invoking curl and include compatibility work for newer OpenSSL versions.

CPANSA::DB exposes the CPAN Security Advisory reports as a ready-to-use Perl data structure so scripts and tools can query CPAN security metadata without parsing files manually. It provides a single method, db, that returns a hashref of all advisories and is used by CPAN::Audit but can be used by any code that needs programmatic access to CPANSA data. Each release also ships a JSON equivalent and includes GPG signatures and GitHub attestations so you can verify the archive and source before trusting the data. Use this module when you want a simple, verifiable way to incorporate CPAN security advisories into auditing or monitoring workflows.

Nice::Try brings a familiar try, catch and finally syntax to Perl by transforming your source at compile time so you can write nested exception blocks, assign the caught value to a variable, filter catches by exception class or condition, and return values from try blocks while preserving correct line numbers and the usual $@ behavior. It integrates with the Want module to provide richer context-aware returns such as object, arrayref or coderef results and it supports flow control keywords inside loops, works with __DATA__ and __END__ sections, and is thread-safe while disabling Want where unsafe. Because it is a source filter that uses PPI it avoids brittle regex parsing but does add some compile-time overhead for large codebases and lvalues are not yet implemented. If you need a compact, feature-rich try/catch implementation that supports finally blocks and class filtering beyond Perl's experimental try feature, Nice::Try is a practical and well‑documented option.

RT::Extension::MergeUsers is an add-on for Request Tracker that lets administrators consolidate two accounts so one becomes the primary and the other is treated as a secondary, making mail and activity from the secondary appear as if sent by the primary. It adds a Merge Users box to the User Administration page and provides programmatic methods on RT::User, a command line tool and a cleanup utility, plus REST2 API endpoints for authenticated, permission-checked merging and unmerging. The extension also supplies a canonicalize-email routine so messages from merged accounts show the primary identity. Be aware that merges are single-level only, the extension is not compatible with rt-serializer, and there are special considerations when using RT::Shredder or upgrading from very old versions where a migration script must be run. The module targets RT 5.0 and 6.0 and is published by Best Practical Solutions under the GPLv2 license.

JSON::API is a small, practical Perl helper for talking to JSON-based HTTP APIs that wraps JSON and LWP::UserAgent so you can create a client with a base URL and send GET, POST, PUT, PATCH and DELETE requests with automatic JSON encoding and decoding. It accepts the usual LWP options such as authentication, custom agent, SSL and cookie handling, and it returns decoded Perl data (or an HTTP status plus data in list context) while also exposing the raw HTTP::Response and response headers when you need low-level details. A useful predecode hook added in 2019 lets you preprocess raw response text before JSON is parsed, which helps with APIs that prefix responses to prevent CSRF. The module is aimed at scripts and automation that need a simple, configurable JSON HTTP client, and the changelog notes that maintenance and release notes are now tracked on the project’s GitHub releases.

Finance::Tiller2QIF converts Tiller Money CSV exports into QIF files you can import into desktop finance programs like GnuCash, KMyMoney, Quicken, HomeBank and Money Manager Ex. It stages work in three simple phases: ingest parses the Tiller CSV into a SQLite database, map applies a user-supplied, regex-based mapping file to translate categories, assign destination accounts and suppress duplicates, and emit writes the final QIF for import. You can run it from the command line or call its functions from Perl, use a config file, checkpoint the database, and pause between stages to tweak data or run ad hoc SQL. The mapping format is expressive yet easy to read, with account scoping, alternation, literal-pipe escaping, options to omit categories or skip transactions, and a configurable default rule. Licensed under GPLv3, this tool is a practical choice if you use Tiller and need a reproducible way to export clean, mapped QIF data for other financial software.

RT-Extension-MandatoryOnTransition is a plugin for Request Tracker that prevents tickets from being moved to or from specified statuses or queues until required core fields, custom fields, or roles have been set, so you can make sure items are resolved only after required information like a reply, time worked, a resolution field, or a particular role is assigned. It integrates with RT lifecycles and is configured in RT_SiteConfig.pm using the %MandatoryOnTransition structure to declare which fields are mandatory for particular status or queue transitions, and it supports value checks (must_be and must_not_be) and optional group membership checks for role assignments. The extension works with RT 6 and has a 0.x branch for RT 5, it exposes only the needed fields on the update page to make completion easier and enforces standard RT validation patterns for custom fields. Note that enforcement is not available on every update path yet, for example SelfService and some quick-create pages are not supported, and multi-valued custom fields have limited handling for must_be and must_not_be rules.

DarkPAN::Utils is a lightweight toolkit for interacting with a private CPAN mirror served from S3/CloudFront, making it easy to fetch and parse the standard CPAN package index, locate distributions that contain a given module, download distribution tarballs, and extract individual files or Perl module source for tasks like documentation generation. It works over the network using a configurable base URL or directly against a supplied Archive::Tar object so you can operate without network access when a tarball is already available. The module exports a small helper to parse distribution filenames, exposes methods to fetch and cache the 02packages index, search for modules, pull and unpack packages, and retrieve files or lib/Module/Name.pm sources, and it includes a simple command line interface and configurable Log::Log4perl logging. Recent changes focus on build and packaging updates in the 1.1.0 release, refactoring the CPAN::Maker bootstrap and project metadata and tests, with no major API changes to the runtime behavior.

CPAN::Maker::Bootstrapper is a command line tool that scaffolds a complete, ready-to-build CPAN distribution in one step, creating a managed Makefile, buildspec.yml, VERSION file, stub source (.pm.in/.pl.in) and test skeletons so you can run make to produce a distributable tarball immediately. It embeds a portable build system based on GNU make, bash and Perl that automatically scans dependencies, enforces optional quality gates like perl -wc, perltidy and perlcritic, supports modulino wrappers, and provides a safe extension point (project.mk) so you can add project-specific rules without touching the managed files. You can import an existing project into the scaffold, choose different stub types, customize behavior via a git-based or .ini config, and use built-in LLM-powered commands (code-review, pod-review, release-notes) that integrate with Anthropic Claude for iterative, annotated reviews and AI-assisted release notes. Be aware that imported files become .in sources and generated .pm/.pl files are overwritten by the build, and that the importer and stub options are mutually exclusive. Notable in the recent 2.0.0 release are refactors and new LLM role modules, improved prompts and release-notes support, and updates to the managed Makefile and .includes files to streamline the AI and build workflows.

CLI::Simple is a minimalist object-oriented Perl base class for building command-line programs using the modulino pattern so the same file can be a reusable module or an executable script. It provides straightforward parsing of Getopt::Long-style options, subcommands and positional arguments, automatically generates get_/set_ accessors for options and extra values, and exposes a clean run/init lifecycle for your code. Logging is integrated via Log::Log4perl and you can assign per-command log levels when registering handlers. For larger projects it supports an optional role-based architecture driven by a YAML manifest and Role::Tiny roles, and it includes handy developer tools such as -dump-spec, -scaffold, -migrate and -generate-completion to help migrate or scaffold role-based layouts and produce bash completions. The design intentionally avoids heavyweight framework constraints, making CLI::Simple a good fit for internal tools, admin scripts, and small CLIs that need structure without a lot of ceremony.

OrePAN2::S3 is a Perl utility for running a private DarkPAN, letting you host a CPAN-style archive on Amazon S3 and optionally serve it through CloudFront. It provides commands to inject and delete distributions, build and upload an index.html from the CPAN manifest, generate simple docs from README or POD, and push additional static artifacts to your S3 bucket, and it can be used either via a provided bash wrapper or directly as a modulino. Configuration is done with a JSON file that can hold multiple profiles specifying AWS credentials, region, bucket and prefix, CloudFront distribution and invalidation paths, and a Template::Toolkit template for the index so you can customize how packages are presented. The tool automates common mirror tasks like uploading files, reindexing, and optionally invalidating CloudFront caches, so it is a good fit for Perl developers or ops teams who want a lightweight, static private CPAN repository backed by S3. You will need an AWS profile with S3 and CloudFront permissions, and the author provides examples and a default template to get started quickly.

Amazon::S3::Lite is a compact, no-frills Amazon S3 client designed for AWS Lambda functions and small scripts that need the common object storage operations without the bulk of LWP-based libraries. It lets you list buckets and objects with pagination, fetch objects (with optional streaming to a file to avoid large memory use), read object metadata, upload objects from scalars or filehandles with metadata and ACLs, copy objects server-side, and delete objects or specific versions. The client uses HTTP::Tiny and AWS::Signature4 so its dependency footprint is small, it returns parsed Perl hashrefs for results, and it supports credential discovery from constructor args, environment variables, or a credentials provider object for IAM roles and rotating credentials. It is intentionally not a full S3 implementation and does not provide multipart uploads, presigned URLs, advanced bucket management, or raw HTTP response access. Error handling is simple and predictable with croaks for network and 5xx errors and undef for 404s where appropriate. In the recent 1.0.1 release the module added the x-amz-content-sha256 header, smoothed logger initialization, and formalized TLS requirements by adding IO::Socket::SSL and Net::SSLeay to the prerequisites.

Chess4p is a compact Perl library that supplies the building blocks needed to work with chess positions, moves and game data, aimed at developers building engines, analysis tools or PGN utilities. It splits functionality into focused modules for board state and bitboard operations, move objects, perft testing, PGN reading and common constants, and it supports legal move generation plus UCI and SAN input/output. The library is implemented for 64-bit systems and is practical when you need programmatic access to positions, fast perft counting or to parse and emit PGN and SAN moves. Recent updates moved the Board implementation to a pure bitboard model, added SAN parsing and output and a Board copy constructor, and improved testing and bug fixes, making the core functionality more robust. The code is open source and hosted on Codeberg for anyone who wants to try or extend it.

MetaCPAN::Client is a polished Perl interface to the MetaCPAN API that makes it easy to find and inspect CPAN authors, distributions, releases, modules, files and other MetaCPAN resources while often doing "what you mean" for common queries. It supports both simple lookups and rich, nested search specs for AND/OR/NOT-style queries and can return single entity objects or iterable result sets for large searches, including a scroller for pulling all matches. You can fetch POD, download URLs, autocomplete suggestions, recent releases and reverse dependencies, and plug in a custom HTTP user agent to add caching or other behavior, so it works well in scripts, services and tools. The module aims to track the MetaCPAN API closely and is actively maintained; recent updates add a count method, clean up type handling and fix author field handling.

Encode is Perl's core encoding toolkit for translating between Perl's internal character strings and external byte sequences, letting you decode byte streams into character strings and encode Perl strings back into octets. It provides simple functions like encode and decode, utilities to convert in place or between encodings, a find_encoding API to reuse encoding objects, and helpers for UTF‑8 handling and MIME header work, while also integrating with PerlIO so you can use encoding layers on filehandles. The module supports many encodings and aliases, lets you register new encodings and aliases, and offers flexible error handling via CHECK flags or coderef fallbacks so you can choose replacement, warning, or strict failure behavior. Be aware of a few important caveats documented by the authors: some operations may modify their input scalar in place, the internal UTF8 flag affects string representation and comparisons, and the difference between the liberal "utf8" and the strict "UTF-8" encodings matters for security and correctness; also the convenience helpers encode_utf8 and decode_utf8 accept lax UTF‑8 and are not recommended for data exchange. Encode is mature and actively maintained, with recent releases focused on robustness, test and build reproducibility improvements, and fixes for security and memory issues.

Time::Str is a compact Perl utility for converting between human-readable date/time strings and machine-friendly values, offering three main routines: str2time to parse strings into Unix timestamps (including fractional seconds), str2date to return parsed components as a hash, and time2str to format timestamps back into strings. It supports a wide set of standards such as RFC3339/RFC2822, HTTP dates, ISO 8601/W3C, SQL (ISO9075), ASN.1, Common Log Format, Git and more, plus a permissive "generic" parser that handles many real-world variants. The module gives fine control over fractional seconds with precision and a nanosecond override to avoid floating-point rounding errors, and accepts timezone offsets and UTC designators; str2time requires a numeric offset or UTC designator and will croak on unresolved abbreviations while str2date will preserve an abbreviation for external resolution. A few formats are parse-only or always output GMT or omit fractions by design, so check the format docs if you need offsets or subsecond output. Overall Time::Str is a practical choice when you need reliable, standards-aware parsing and formatting of dates and times across diverse inputs and outputs.

EV::Etcd is a high-performance, asynchronous etcd v3 client for Perl that plugs the native gRPC Core C API into the EV/libev event loop, giving you nonblocking, callback-driven access to etcd from evented Perl programs. It exposes the full etcd feature set including key/value operations, watches with automatic reconnect and progress notifications, leases and keepalives, distributed locks, leader election, atomic transactions, cluster membership and maintenance tools, and the auth system with user and role management. Errors are returned as structured hashrefs that include gRPC status and a retryable flag so you can implement appropriate retry logic, and streaming operations handle transient failures automatically according to configurable retry and reconnect options. Keys and values are treated as raw bytes so you must encode and decode character data yourself, and EV::Etcd clients are not safe to reuse after fork because the underlying gRPC thread does not survive into child processes. The most recent release fixes several robustness issues including use-after-free and memory-leak bugs and corrects 32-bit integer truncation, making the client safer and more reliable for production use. If you need low-latency, fully featured etcd access from an evented Perl application, EV::Etcd is a practical, production-ready choice.

PAX is a tool that compiles a Perl program and its repeatable inputs into a single standalone executable that carries compiled code units, dependency payloads, embedded assets, and optional native artifacts so you can deploy a Perl app without the original source tree or a host CPAN install. You drive it with the public pax command set using pax build and pax run and a declarative paxfile.yml or inline entrypoints, and it supports packaging web apps with templates and static assets, self-hosting builds, and Docker-friendly multi-stage deployment. Recent updates added inline -I, -M and -e support so you can build or run one-off entrypoints from the command line and hardened build timeouts for more robust behavior on platforms like Alpine, but dynamic runtime loading still falls back to noncompiled paths, bundled-perl binaries are larger than thin wrappers, and cross-distro native portability is not guaranteed.

RT::Extension::AttachmentViewer is a lightweight plugin for Request Tracker 6 that converts the dropzone thumbnails into clickable previews so you can open attachments at full size in a popup rather than downloading them. It supports images, PDFs, audio, HTML and text files and will fall back to a browser download for types the viewer cannot render. Installation is straightforward: add the plugin to your RT_SiteConfig, clear the Mason cache and restart your webserver, and the source code is available on GitHub. If you use RT for ticketing and want faster inline inspection of attached files, this extension removes an extra step and speeds up review. Initial release 0.01 published 2026-04-29 by Gerald Sedrati.

Text::CSV_XS is a fast, production‑quality Perl module for reading and writing comma separated value data that gives you both a low level object API and a convenient high level csv function for common tasks. It parses CSV into arrays or hashes, writes arrays or arrayrefs directly to files or scalars, and supports flexible separators, quoting and escaping rules, header detection and munging, fragment selection, and streaming for large datasets. It handles embedded newlines and binary data when run in binary mode, offers UTF‑8 and BOM support, provides hooks and callbacks for filtering or transforming rows, and exposes detailed error diagnostics so you can validate and recover from malformed input. The module is mature and actively maintained and the latest release includes a security fix for a possible stack corruption issue, addressing CVE-2026-7111.