CPANscan

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.

PAGI::FastAPI::Security provides a compact set of authentication helpers for the PAGI::FastAPI web framework, modeled after Python FastAPI's security utilities, to make it easy to extract credentials and present standard challenges. It includes ready-made schemes for HTTP Bearer, HTTP Basic, API keys via header/query/cookie, and an OAuth2 password-bearer helper, and it will produce the appropriate error metadata such as 401 plus WWW-Authenticate or 403 responses where applicable. The module intentionally stops short of validating tokens or passwords so you can plug in your preferred JWT, database or cache verification logic in a dependency handler, keeping the package lightweight and flexible. If you are building APIs with PAGI::FastAPI and want reliable, reusable credential extraction and challenge behavior without forcing a particular verification implementation, this module is likely relevant.

AWS::Lambda makes it easy to run Perl on AWS Lambda by providing a ready-made custom runtime, prebuilt Lambda Layers, zip archives and Docker images so you can deploy a simple Perl handler script or container image with minimal setup. It includes examples for packaging a handler, support for response streaming, built-in helpers for AWS X-Ray tracing, and an optional Paws layer for calling AWS services from your function, plus local testing workflows with Docker and the Lambda Runtime Interface Emulator. Common Perl modules are preinstalled and the package documents how to build custom module layers for additional libraries. Supported Perl versions follow the official Perl policy and Amazon Linux 2023 is the recommended platform, while older provided and AL2 layers remain available only for backward compatibility and are no longer maintained. This module is a good fit if you want to run Perl code on Lambda without building your own runtime from scratch or if you need an easy way to add Perl-based AWS SDK support.

Hyperman is a high-performance PSGI web server for Perl that combines a prefork supervisor with a per-worker XS event loop to serve synchronous and asynchronous apps with very low overhead. It runs any Plack app and lets handlers return a Hyperman::Future or any Future-compatible object so you can write nonblocking request handlers while the worker pumps its own loop. Hyperman supports TLS including SNI and optional/required client certs, cleartext and ALPN HTTP/2, multiple listeners per process with built-in https redirect, and production features like graceful drain, worker respawn and zero-downtime restarts. Logging can be done with a fast C-written Combined Log Format writer or a Perl coderef for custom handling. The module exposes timer and io_ready futures plus per-worker stats and also publishes a public C ABI so other XS modules can drive the loop and create or settle futures entirely from C. Recent releases added a stable public C ABI, HTTP/1 chunked-body decoding, hardening against request smuggling, multi-listener support and a fast builtin access log, making Hyperman a good fit if you need a low-latency, high-throughput PSGI server with async primitives and tight C integration.

Sereal::Encoder is a Perl module that turns in-memory Perl data structures into a compact, fast binary representation called Sereal, suitable for storage or fast IPC, and pairs with a separately released Sereal::Decoder for reading the data back. You can use it as a reusable encoder object or via convenience functions to serialize values or write them directly to files, and it offers many knobs such as optional compression with Snappy, zlib or Zstd, string deduplication, control over how blessed objects are handled, and a FREEZE/THAW callback mechanism so objects can provide their own serialization form. It also supports features to produce a more canonical byte representation for caching or comparison, and provides performance-oriented advice to prefer the object or sereal_encode_with_object interfaces over the one-shot functional call. The module is thread-safe on modern Perls and actively tuned for speed and compact output, but users should be aware of Perl-specific serialization subtleties such as string versus numeric representations and dualvars which can affect round-tripping in edge cases, and recent protocol versions add explicit boolean support.

Sereal::Decoder is a fast, C-backed Perl module for deserializing data encoded with the compact Sereal binary format so you can reconstruct Perl structures quickly and with low overhead. It provides an object-oriented decoder (plus faster functional wrappers) with methods to decode whole packets, read optional header data, parse from files or offsets, and report how many bytes were consumed so you can handle concatenated streams or incremental feeds. The decoder supports modern Sereal protocol versions (including protocol 5 in recent releases) and common compressors such as zstd and snappy while offering a range of safety and tuning options like refusing compressed input, rejecting or not blessing objects, whitelisting which classes may run THAW callbacks, UTF-8 validation, recursion and size limits, incremental parsing, and readonly outputs. It also implements the FREEZE/THAW hook for complex object serialization but warns that THAW executes class code so you should enable the defensive options when handling untrusted data. Recent updates improved thaw ordering, fixed rare crash scenarios around frozen-object state, and added protocol 5 support, so upgrade the decoder before upgrading any Sereal encoder.