CPANscan

RT::Extension::AwayMode is a small Request Tracker (RT) add-on that helps prevent tickets from being left waiting when an owner is out of office. Users can set an away flag on their Preferences page and optionally specify start and end dates, and while away they see a persistent banner in the web UI. If an away user posts a reply to a ticket they own, the extension reassigns the ticket to Nobody and adds an internal comment explaining the handoff so the rest of the team can see and take over work. It includes a simple, testable routine for evaluating away status and is intended for use with RT 6.0.3.

Sys::Virt is a Perl XS binding to the libvirt API that gives Perl programs a consistent way to manage virtual machines and related resources across different hypervisors. It lets you open local or remote connections, create and control domains, networks, storage pools, interfaces and node devices, inspect host capabilities and statistics, convert and validate domain XML, and subscribe to lifecycle and other events. The module supports authentication callbacks, TLS and a variety of libvirt URIs such as QEMU and Xen, and it exposes many helper methods and constants for tasks like CPU compatibility checks and memory tuning. Note that event callbacks return IDs that must be explicitly deregistered so the connection can be garbage collected, and the author cautions the XS layer should be audited for possible memory leaks. If you need to control libvirt from Perl, Sys::Virt provides the standard, feature rich interface and reports errors through Sys::Virt::Error objects.

SSVC is a Perl module that implements the Stakeholder-Specific Vulnerability Categorization framework so you can turn stakeholder-specific inputs into actionable vulnerability prioritization decisions. It ships implementations for common methodologies including CISA, CISA BOD 26-04, coordinator publication and triage, deployer and supplier, and it exposes introspection helpers so tools can enumerate decision points, allowed values and human labels. You create SSVC objects with the relevant decision point values, ask for the derived decision, serialize to JSON for interchange, and when using SSVC::CISA parse or emit the official compact vector string format. You can also register your own methodology classes to extend the system. Note that only the CISA implementation supports the official vector string grammar while other methodologies offer only a generic string representation.

Net::HTTPS::NB is a drop-in replacement for Net::HTTPS that is designed for non-blocking use, so you can perform TLS handshakes and read responses without tying up your program. It keeps the same high-level API as Net::HTTPS but never attempts multiple internal reads when you call read_response_headers or read_entity_body, and it adds a Blocking option to perform a non-blocking connect. When a handshake is incomplete you can call connected to check status and inspect the exported $HTTPS_ERROR which will be HTTPS_WANT_READ or HTTPS_WANT_WRITE to tell you whether to wait for readability or writability. read_response_headers returns an empty list if headers are not yet complete and read_entity_body returns -1 when no new data is available, which makes it easy to integrate with IO::Select or event loops. Use blocking(0) to make the socket non-blocking and blocking(1) to restore blocking mode. If you need a simple, Net::HTTPS-compatible client that works cleanly in non-blocking or event-driven programs, this module is a good fit.

String::RewritePrefix is a small utility for turning short identifiers into fully qualified names by substituting known prefixes, which is especially useful for plugin or mixin loading where you want to map bare names like "Plugin" to "MyApp::Plugin". You provide a mapping of prefixes to replacement strings or coderefs, and the module rewrites each input using the longest matching prefix so only one substitution is applied. You can call the class method directly or import a named rewrite routine into your namespace for convenience. The module supports dynamic prefix generation via coderefs and recent updates refreshed packaging and set the minimum supported Perl to v5.12.

Config::IniFiles is a mature Perl module for reading, editing and writing INI style configuration files in a straightforward, script friendly way. It offers both an object API and a tied hash interface so you can fetch and set sectioned key=value pairs, handle multi line values with here document or continuation lines, customize comment characters and case sensitivity, and use default or fallback sections. The module also supports stacking or importing another Config::IniFiles object so you can overlay site specific settings over shipped defaults, and it can write either full configuration files or compact delta files that record only changes. You can preserve and manipulate comments and trailing comments, control write permissions and encoding via filehandles, and inspect parse problems via the @Config::IniFiles::errors array. Be aware that rewritten output may not exactly preserve original formatting and that WriteConfig does not perform file locking, so you should manage concurrent writers yourself.

App::MARC::Count is a small, focused base class for a command-line marc-count utility that opens MARC XML files and counts the records they contain. It exposes a simple object API with new to construct the app and run to execute it, where run returns 0 for success and 1 for error. The module relies on MARC::File::XML and related utilities and includes an example showing how to prepare a MARC XML file and invoke the script to print the record count. The recent 0.05 release added support for compressed input files, making it easier to work with gzipped data. If you need a lightweight starting point to build or script record-counting for MARC XML collections, this module is a practical choice.

Dist::Starter is a small command line tool for quickly scaffolding a Perl distribution from a template. You run the provided diststarter script with a distribution name and it fills a template into a target directory, with options to select the template directory, output location, minimum Perl version, initial version and license, and to supply author metadata from your system GECOS, from git config, or from environment variables. Defaults are configurable via a run-control file so you can set your preferred template and values once and reuse them, and a dry-run mode prints the generated context as YAML so you can inspect what will be created before writing files. The distribution ships with a default template and is comparable to tools like Cookiecutter and Copier but focused on Perl projects. Note that this is an alpha release and some features such as easier template creation and extra script/share options are still TODO.

Net::API::REST is a compact framework for building RESTful APIs inside Apache/mod_perl applications that handles routing, path variable extraction and dispatch to endpoint handlers so you can express endpoints as simple subs or class methods. It provides request and response objects, CORS and OPTIONS preflight support, content type and method checking, network and access control hooks, and built‑in JWT encode/decode with optional encryption, while returning standard Apache2 HTTP status codes. The module supports multiple API versions, configurable methods, languages and content types, response compression, upload handling and post‑response callbacks and integrates with companion classes like Net::API::REST::Endpoint, Request, Response and JWT so you can focus on business logic rather than low level Apache plumbing. It is intended specifically for mod_perl/Apache2 environments and is actively maintained; the most recent release improves how the handler deals with exceptions returned by endpoint code.

API::Instagram is a Perl library that wraps Instagram's REST and Search APIs in a simple object oriented interface, making it easy to authenticate via OAuth2, build the authorization URL, exchange the returned code for an access token, and then fetch Instagram data such as the authenticated user feed, arbitrary users, media items, tags, locations, search results and currently popular media. It returns domain objects like API::Instagram::User and API::Instagram::Media so you can work with Instagram data in Perl idioms, offers a singleton convenience constructor and caches created objects by default with an option to disable that behavior, and is a good fit for Perl developers who want to embed Instagram access into web apps, bots or data-collection scripts without dealing with low-level HTTP calls.

Regexp::Pattern is a lightweight convention and helper for organizing and reusing regular expressions in Perl by placing named pattern definitions in Regexp::Pattern::* modules, each exposing a %RE hash that can contain plain regexes, documented examples, tags and dynamic generators that accept arguments. The module supplies a simple re() function to retrieve a pattern by name and a straightforward import mechanism to pull patterns into your own %RE with options for renaming, adding prefixes or suffixes, and filtering by tags so you can discover and compose useful building blocks without magic. Authors can include summaries, examples and metadata so tools or tests can validate patterns and users are encouraged to mark anchored or capturing patterns for clarity. Regexp::Pattern is a lower-overhead alternative to Regexp::Common and recent releases added flexible anchoring options including left-only and right-only anchoring.

Mail::BIMI is a Perl module for mail systems that want to retrieve, validate, and process Brand Indicators for Message Identification (BIMI). It ties into existing authentication checks by working with DMARC and SPF objects, fetches BIMI assertion records from DNS, downloads and verifies SVG brand indicators and Verified Mark Certificates, and produces a structured result plus Authentication-Results and optional BIMI headers for messages. The module includes configurable options, caching, DNS resolver support, and tools to validate records or indicators before publication, making it useful for mail servers or processing pipelines that need to enforce or report BIMI status. Recent updates improved X509 subject parsing to reduce warnings and expanded the trusted CA list to include ssl.com.

Fsdb is a mature suite of command-line tools and Perl libraries for treating plain text tables as lightweight, pipeline-friendly databases, making it easy to extract, join, sort, pivot and compute statistics on experimental or log data without a full database server. Fsdb files use a simple header to name columns and optionally give types, and the tools (dbcol, dbrow, dbsort, dbjoin, dbcolstats, dbmapreduce and many more) let you build compact shell or Perl pipelines to filter rows, compute means, histograms, percentiles, regressions, and other statistics, or to prepare data for graphing and mail merges. It is designed to handle medium-to-large datasets efficiently by streaming and using temporary files when needed, to exploit multiple cores via parallel sorts and merges, and to transparently read compressed files or HDFS paths. Fsdb emphasizes readable schemas and provenance by logging the pipeline operations in output comments, and it includes a Perl IO API for embedding pipelines in scripts. It is not a transactional, indexed database and is focused on single-user, text-based workflows, so very large or index-heavy workloads may be better served by a full DBMS, and users should be aware of normal floating-point limits for extreme numeric ranges. Fsdb is open source (GPLv2), installs with the standard Perl build tools, and requires a modern Perl (5.8+ with some features assuming 5.10+).

Object::Cache::Sqlite is a lightweight Perl module that provides a persistent, SQLite-backed object cache with automatic time-to-live expiration. It serializes Perl scalars and complex data structures using Cpanel::JSON::XS and stores them in a single database file that the module will create if needed. The API is simple: construct with a db_file, then set keys with either a relative TTL or an absolute Unix timestamp, get and delete values, inspect counts and keys, and remove expired entries with an optional VACUUM to reclaim space. This module is a good fit when you want an easy, disk-backed cache shared across processes or restarts without deploying a separate caching service.

Cucumber::TagExpressions is a small Perl library for working with Cucumber-style tag filters: it parses tag expression strings like "@smoke and not @wip" and returns an evaluator object you can use to test whether a scenario's tags match the filter. You call Cucumber::TagExpressions->parse($expr) to get an ExpressionNode and then call ->evaluate(@tags) to check membership, which makes it convenient to select or skip Gherkin scenarios in test runners and tooling. The module is MIT licensed and is a Perl port of the widely used tag-expressions library from the Cucumber ecosystem. Recent maintenance has focused on release and packaging fixes so the distribution and test runs behave reliably when installed from CPAN.

Gherkin is a Perl implementation of the Gherkin language parser and compiler used by the Cucumber project, designed to read .feature files and emit a stream of protobuf-based Cucumber::Messages wrapped as NDJSON envelopes. It is generated from the official Gherkin grammar and can include the original source text, the parsed AST, and the executable "pickles" in its output, with caller-supplied id generator and sink callbacks to receive each message. The module handles declared file encodings and is intended as the first building block in a Cucumber-style tooling pipeline for building testing and reporting tools in Perl. Note that versions 21 and earlier sent plain hashes while current releases emit Cucumber::Messages, and the code is distributed under the MIT license.

Cucumber::Messages is a Perl library that implements the Cucumber message protocol and provides in-memory classes plus NDJSON serialization and deserialization for exchanging structured test data. It models the full set of protocol messages such as Envelopes, Pickles, Sources, Attachments and ExternalAttachment, timestamps, durations, test step and test case events, and offers simple to_json/from_json helpers so you can read or emit the same NDJSON streams used across the Cucumber ecosystem. Use it when you build formatters, reporters, test runners or any tool that must consume or produce Cucumber message streams in Perl. The code is MIT licensed and maintained alongside the multi-language messages project, which has recently added support for externalized attachments and ongoing schema and cross-language refinements.

POSIX::RT::Signal provides Perl bindings for POSIX real-time signal features so you can send signals with an optional numeric payload, wait for and retrieve detailed signal information, and reserve signals for exclusive use across your code. It exposes functions like sigqueue to queue a signal to a process or thread, sigwaitinfo and sigtimedwait to block and receive a Signal::Info object for an arriving signal, and sigwait to simply wait for a signal, and it expects you to mask the signals you plan to wait for. The module also offers allocate_signal and deallocate_signal to claim real-time signals for coordinated use, with a fallback to SIGUSR1 and SIGUSR2 if real-time signals are unavailable. Use this when you need precise, race-avoiding interprocess or interthread signaling in Perl or when integrating with POSIX real-time timers and signal masks.

Google::Auth is a lightweight Perl helper for locating and returning Google Application Default Credentials and the current project ID so your code can authenticate to Google Cloud services without hardcoding keys. Instantiate the module and call default($scopes, $options) to get a credentials object you can use with HTTP clients and API calls, and control pluggable external account behaviour with environment flags such as GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES and GOOGLE_EXTERNAL_ACCOUNT_ALLOW_CUSTOM_UNIVERSES. The module is maintained by Google and recent releases have tightened security and reliability, including safer handling of pluggable credential execution and respecting standard proxy environment variables during credential fetches.

Math::NLopt is a Perl binding for the NLopt nonlinear optimization library that gives Perl programmers a simple, Perlish way to run a wide range of local and global optimizers for functions with or without gradient information. It wraps the native NLopt C library (installed or located for you via Alien::NLopt), presents a small object API that works with plain Perl arrays, and exposes the same algorithms and result codes as NLopt so you can construct an optimizer, register objective and constraint callbacks, set bounds and tolerances, and call ->optimize to get back optimized parameter vectors and the final objective value. The module mirrors the familiar Matlab/Python-style workflow while integrating with Perl error handling, returning results or throwing exceptions on NLopt errors and rethrowing exceptions from your callbacks; you can also disable exceptions from optimize and inspect last_optimum_params and last_optimize_result if you prefer. If you need general-purpose nonlinear optimization in Perl, Math::NLopt is a mature, well-tested choice with many algorithm constants and utility functions. Note that the recent 0.12 release made a few API changes that you should be aware of: the old create method was removed, the scalar and vector constraint callback signatures were fixed (vector constraints now receive proper two-dimensional Perl arrays), and various bugs and memory leaks were corrected to make callback data handling and object lifetime more robust.

Affix is a modern, high-performance Foreign Function Interface for Perl that lets you call C, Rust, Zig, C++, Go, Fortran and other native code directly from Perl without writing XS or compiling glue code. It uses JIT-compiled trampolines and a rich type system to provide near-native call speed while exposing C primitives, structs, unions, enums, SIMD vectors, pointers and live zero-copy views that map C memory to ordinary Perl hashes and arrays. You can load libraries across platforms, bind functions or raw addresses, pass Perl coderefs as callbacks, manage C heap memory with malloc/calloc/realloc/free and pin Perl scalars to C globals, and inspect layouts with sizeof, alignof and offsetof, making it a good fit whenever you need tight, low-overhead interop between Perl and system libraries. The project is mature and cross-platform with companion tools to generate bindings and build polyglot libraries, and the latest release adds RISC-V support while fixing several memory-lifetime bugs around malloc/calloc/realloc and trampoline layout for safer, more reliable use.

Data::TableReader helps you turn messy, human-edited tabular files like Excel, CSV, TSV or HTML into clean, validated records for automated imports by finding the header row, mapping columns to the fields you expect, and extracting each row as a hashref, arrayref or object. You declare the fields you want using simple names or richer specifications including header regexes and Type::Tiny validators, and the reader will search within a configurable range of rows to locate the table and build a column map. It copes with real-world nastiness via configurable policies and callbacks for ambiguous or unknown headers, blank rows, and validation failures, and captures warnings or messages through a pluggable logging hook so you can present clear feedback to users. The module auto-detects file format and character set, supports custom decoders and mock data sources, and exposes an iterator that yields the cleaned records, making it a practical choice when you must import unstable or poorly formatted spreadsheet data reliably.

Data::Identifier is a lightweight, format-agnostic wrapper for identifiers that unifies UUIDs, OIDs, URIs and a range of well known types behind a single object interface, so you can create, inspect, convert, compare and generate identifiers without worrying about their raw format. It can parse identifiers from many sources, produce canonical forms, convert to other representations such as URI or numeric types, generate cryptographically strong random IDs, and provide metadata like display names, tag names, namespaces and generator information. The module also offers comparison and ordering routines, optional registration for in-process deduplication and hooks to adapt behavior for performance or to disable features you do not need. Validation and normalization are performed where practical but are intentionally conservative for performance and completeness, so the module may not reject every invalid input and deduplication is not guaranteed to collapse all equal values. Overall this is a practical tool if you need a consistent, high level API for working with many identifier formats in Perl.

Template::Stencil is a compact, high-performance Perl template engine that compiles a simple "{% %}" template grammar once into packed bytecode and then renders with a C interpreter directly into a scalar buffer for very fast repeated renders. It supports variables with dotted and indexed paths, automatic HTML-escaping with an opt-out raw tag, chained filters (built-in C filters plus user coderef filters), conditionals, for-loops with a handy loop object, scoped set bindings, static includes, and a wrapper/layout facility so you can render a page into a layout without intermediate strings. The engine caches compiled templates with file mtime revalidation and a bounded LRU for string templates, returns wire-ready UTF-8 by default, and is designed for prefork and ithreads usage with no shared locks or per-render heap allocations at steady state. Caveats the author calls out are that templates cannot traverse blessed references (no method calls), empty unblessed arrays and hashes are treated as false in conditions, hash iteration is sorted by default for determinism, and a handful of reserved words cannot be used as leading identifiers. This is the initial 0.01 release, a lean first version focused on speed and predictable rendering behavior.

Datafile::Array is a lightweight pure-Perl toolkit for reading and writing simple delimited text files that makes common CSV and TSV tasks easy without adding compiled dependencies. It handles quoted CSV fields including escaped quotes and multi-line records, supports automatic or explicit header lines and an H/R prefix convention, can trim values and filter records by simple patterns, and can load data into arrays of hashes or into keyed hashes for lookup. It also provides a standalone parse_csv_line function for one-off parsing needs and writes files safely using a temporary-file-and-rename strategy with optional backups and permissions, returning record counts and human-readable message lists instead of dying on I O errors. This module is a good fit for scripts and small applications that need dependable, configurable delimited-file I O without the weight of larger CSV libraries.

Fetch is a modern Perl HTTP client that gives you high-performance, asynchronous requests via Fetch::Future objects while also working synchronously when you call ->get because it will pump an event loop for you. Its performance hot path is implemented in vendored C and it speaks HTTP/1.1 and HTTP/2 over cleartext and TLS with connection pooling, redirect following, per-request timeouts, streaming bodies, a cookie jar, JSON helpers and native WebSockets. You can use it out of the box with its built-in standalone loop or plug it into existing async frameworks like IO::Async, AnyEvent or Hyperman so the same code can run as a simple blocking call or as thousands of concurrent requests. Requests resolve to Fetch::Response objects with status, headers and content and failures manifest as failed futures you can inspect. The 0.02 release fixes a small C-level bug in URL scheme handling.

Text::Stencil is a high-performance Perl renderer that turns uniform lists or tables of arrayrefs or hashrefs into text by compiling a row template once and running a tight C rendering loop. Templates use simple placeholders like {0} or {name} and support a rich, chainable set of built-in transforms for escaping and formatting such as HTML, URL and JSON escaping, numeric and date formatting, truncation, padding, default values and pluralization. You can load templates from files, clone renderers, render into a string, stream bytes directly to a filehandle or drive output from a callback for large or streaming data. The module is strict about template syntax and reports unknown transforms or bad parameters at compile time to avoid silent errors. It is notably faster than Text::Xslate for common array and hash row workloads, but you should be aware of its byte-vs-character handling rules for Unicode and that a renderer object is not safe for concurrent renders from multiple threads. Use Text::Stencil when you need very fast, template-driven generation of tabular text or HTML and can keep each thread or process its own renderer.

XML::Hash::XS is a compact, high-performance Perl extension written in C that converts between Perl hashes and XML both ways while keeping memory use very low by streaming data instead of building a full DOM. It can emit XML to a string, a filehandle, or a callback and can parse strings, filehandles or incremental chunks through a parser, supports encoding options, pretty printing, canonical key ordering, an attribute-mode that maps hash keys to XML attributes, and filters and callbacks for extracting or handling specific nodes in large documents. The module also understands object serialization via toString, overloaded stringification, or an iternext iterator to generate large XML sets efficiently. Optional libraries such as XML::LibXML and iconv or ICU extend DOM building and charset conversion features. This module is a good fit when you need very fast, memory‑efficient hash-to-XML or XML-to-hash conversion and streaming processing of large XML.

WebDyne is the core runtime for the WebDyne framework that renders ".psp" pages to HTML either as the main request handler under servers like Apache/mod_perl, PSGI, or PAGI or as a standalone renderer callable from scripts. It exposes simple functions such as html and html_sr to convert templates that embed Perl into HTML, supports passing parameters, template parsing and caching, chained handlers, filters, CGI-style parameter access, and integration with other WebDyne modules. In standalone mode it will create a fake request object if needed, can write output directly to a filehandle or return the rendered HTML, and a small command line renderer is included for quick generation and diagnostics. Full usage examples and documentation live in the module source and on the project GitHub, making WebDyne a practical choice when you want a Perl-centered templating and request-handling system for web apps or offline page generation.

Apache2::API is a convenience framework that wraps the mod_perl2 Apache API into a single, easy-to-use object for building HTTP handlers and responses in Perl. It gives you request and response objects, helpers to encode and decode JSON, UTF-8, URL and base64 payloads, built-in logging and error/bailout handling, automatic JSON reply formatting, configurable response compression, Server-Sent Event support and cleanup callbacks, plus utilities like UUID generation and htpasswd/apr1_md5 password helpers. The module also exposes Apache and APR constants, supports localized messages and language formatting, and lets you inspect or register handlers for Apache phases. Recent releases added support for a retry_after property that sets the HTTP Retry-After header and fixed a security issue in password salt generation by requiring secure random sources, so it is a good fit if you need a consistent, JSON-oriented layer on top of mod_perl for building web APIs or handlers.