CPANscan

HTTP::XSHeaders is a fast C-based replacement for HTTP::Headers and HTTP::Headers::Fast that transparently accelerates header handling in Perl programs by providing a mostly compatible XS implementation. You enable it simply by loading the module and existing code or dependencies that use HTTP::Headers or HTTP::Headers::Fast keep working while gaining much better performance. The module is designed to be lean and thread-safe as of version 0.400000 and normalizes header names to standard casing while always converting underscores to hyphens. It also simplifies the as_string output formatting, does not support literal leading-colon names or the old TRANSLATE_UNDERSCORE behavior, and loads Storable while performing cloning at the C level. Distributed benchmarks show significant speed improvements for common operations. This is an alpha release, so try it with caution and report any issues.

psed is a Perl reimplementation of the classic stream editor sed that reads input files or standard input and applies sed-style edit scripts to transform text line by line. It supports the usual sed features such as address ranges, hold space operations, substitution and transliteration commands, labels and branching, and POSIX basic regular expressions, and you can supply scripts via -e, -f or as a single argument while -n and -a control automatic printing and delayed file-opening. Invoked as s2p it will translate a sed script into an equivalent Perl program, making it useful both for automated search-and-replace tasks and for migrating sed scripts to Perl. The implementation is broadly POSIX-compatible and follows OpenBSD behavior with a few known deviations such as Perl-style reuse of empty regular expressions, the l command showing ESC as \e and VT in octal, trailing spaces being truncated from labels, and lack of collating-element support. Recent updates fixed \< and \> word-boundary matching at line boundaries and removed a test dependency, and an earlier release added support for separating commands with semicolons.

DBI is the standard, database‑agnostic interface for Perl that gives your scripts a consistent way to connect to databases, prepare queries, bind parameters, execute statements, fetch results, and manage transactions without tying your code to a particular database engine. It is an API layer only, so actual work is done by driver modules (DBD::*) but DBI provides the common methods and conveniences you expect such as placeholders, prepared statements, select/do wrappers, bulk execution, quoted identifiers, tracing and profiling, error handling modes (RaiseError/PrintError), callbacks and cached connections. If you need portable, testable database access from Perl — from quick one‑off queries to robust transactional applications — DBI is the right foundation and most drivers on CPAN plug into it. This is a mature, actively maintained module and recent releases include security and robustness fixes, including patches for possible stack and buffer overflow issues and improved driver compatibility and tracing, so upgrading to the latest release is recommended.

WWW::Vonage::API is a lightweight Perl client that simplifies calling the Vonage (formerly Nexmo) REST APIs by wrapping common HTTP verbs and handling URL construction, JSON encoding and basic authentication for you. You create an instance with your API key and secret, set optional defaults like API domain, version and region, then call methods like GET, POST, PATCH, PUT or DELETE with a resource path and a payload to send SMS, query reports, manage numbers, check balances and more. Each call returns a simple hashref with the raw content, HTTP status code and status message so you can inspect or parse the JSON response as needed. Note that the module currently implements only Basic Authentication so features that require JWT are not supported. Recent changes add a DEBUG option for diagnostic output and fix a bug that previously lowercased request paths so case sensitive resource names and IDs are preserved.

Crypt::OpenSSL3 is a modern Perl wrapper around OpenSSL that brings TLS and a full set of cryptographic primitives into Perl programs. The distribution exposes focused modules for making SSL connections, handling asymmetric keys, working with symmetric ciphers, computing message digests, producing MACs, running key derivation functions and managing X.509 certificates. The top-level module itself provides error handling and build-configuration introspection so you can query OpenSSL version and build metadata or inspect and clear library errors. If you need to do TLS networking, manage keys and certificates, or use OpenSSL crypto features from Perl, this package gives you direct access to those facilities while keeping the interface language-native and up to date with OpenSSL 3.

App::cpan2arch is the engine behind the cpan2arch wrapper that automates creating Arch Linux PKGBUILD files from CPAN distribution metadata. It reads environment variables and command line options, fetches module and distribution data from MetaCPAN, converts CPAN prerequisites into Arch dependency syntax, checks whether those dependencies already exist in the official Arch repos or the AUR, and produces a ready-to-use PKGBUILD written to stdout or a file. It is aimed at Perl developers and packagers who want a straightforward way to turn CPAN modules into Arch packages. The module reports problems to stderr and exits with a non-zero status on issues such as missing runtime components, network or API errors, tarball or file access problems, or incompatible Perl versions. See the companion components App::cpan2arch::GetMetadata, ::MergePrereqs, ::CheckPackages, and ::WritePkgbuild for the individual workflow pieces.

JSON::Structure is a Perl library for validating JSON Structure schemas and for checking JSON data against those schemas. It implements the JSON Structure Core specification and provides SchemaValidator and InstanceValidator classes along with simple helper functions to verify that a schema is well formed and that an instance conforms to it. You can use it with common JSON parsers like JSON::MaybeXS to decode text and then run validation in your Perl code. This module is useful whenever you need type-oriented schema validation to enforce data formats, improve interoperability, or add robust input checks to a Perl application. The project is maintained by the JSON Structure Project and is distributed under the MIT license.

Business::ISBN::Data provides the ISBN registration group and publisher range data that the Business::ISBN module uses to validate, parse and format ISBNs. The data are generated from the ISBN Agency RangeMessage.xml and are distributed with the module, but Business::ISBN will normally load them for you and you can point to an alternate RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable if you need newer or custom data. If no external file is found the module falls back to the bundled default data and will also look in the current working directory to accommodate application packagers. Note that Business::ISBN version 3.005 or later is required because the data structure changed to fix an ISBN‑13 issue. The distribution is kept current with frequent data updates and recent maintenance includes fixes such as preventing unintended autovivification when reading the range file.

Data::Mirror is a tiny helper library that makes fetching, caching and parsing remote data trivial by giving you mirror_TYPE($url) functions for common formats like JSON, YAML, XML, CSV, raw strings, file handles and local filenames. It automatically caches downloaded resources for a configurable time to live so your programs can reuse local copies instead of re-downloading, and you can override the TTL per request. The module exposes tweakable objects such as $UA for HTTP options, $JSON and $CSV for parser behaviour and $XDG to control where cache files live, and it also provides utility functions to get the canonical local filename, or to check whether a resource is mirrored or stale. On error the mirror_* calls return undef and issue a carp, and note that a legitimately empty JSON/YAML value can also be undef so wrap calls in eval if you need to distinguish parse errors. Recent change in v0.08 moved the cache into the user’s XDG .cache directory rather than /tmp so caches are now per user and shared across programs run by the same user.

FalkorDB is a Perl client for FalkorDB, a low-latency graph database built on Redis, that lets you run Cypher queries from Perl and converts the RESP protocol responses into convenient Perl objects for nodes, edges and paths. You create a connection with host, port and optional username/password or hand in an existing Redis::Fast instance, pick a named graph, execute writes and parameterized reads, and iterate results using a next_row style API. The module also exposes helpers to list and delete graphs and to access the underlying Redis client if you need lower level control. Note that the code was mostly generated by AI and has not been manually reviewed, so inspect the source before using it in production.

OpenAPI::Client is a Perl helper that turns an OpenAPI (Swagger) document into a ready-to-use API client by dynamically generating a subclass with methods for each operationId, so you can call API endpoints without hand-writing HTTP requests or payload validation. It accepts OpenAPI v2 or v3 in JSON or YAML, validates and coerces input parameters, and integrates with Mojolicious tools like Mojo::UserAgent and Mojo::Transaction to provide blocking, non-blocking callback and promise-based call styles, while letting you override the base URL or add custom content generators for formats like XML. The module exposes the underlying JSON::Validator schema so you can inspect or adjust validation rules and emits an after_build_tx event for last‑minute request tweaks. The package is marked experimental but stable in practice, and the most recent release adds autogenerated operation_id support and documentation refinements.

Mojo::Redis is an asynchronous Redis client for Perl built on Mojo::IOLoop so it integrates cleanly with Mojolicious applications. It offers both blocking and Promise-based nonblocking APIs, built-in pipelining, connection pooling, pubsub support, transactions, cursors and a small cache helper, and tries to follow the same ergonomic style as other Mojo database adapters. The module delegates parsing to Protocol::Redis::XS or Protocol::Redis::Faster, supports cluster and sentinel usage, unix sockets and connection TLS options, and provides convenience methods for creating database, cache and pubsub objects. Mojo::Redis is marked experimental so the API may evolve, and recent releases improved sentinel handling and added TLS-related query parameters for secure connections.

JSON::Validator is a mature Perl library for validating data structures against JSON Schema and OpenAPI specifications, letting you declare schemas as plain Perl data, JSON, YAML or with a programmatic Joi DSL and then validate input, coerce types, resolve $ref references and bundle schemas for distribution. It supports multiple JSON Schema drafts and OpenAPI v2 and v3, can load schemas from files, web resources or module data sections, caches fetched specs to avoid repeated downloads, integrates well with Mojolicious via Plugins, and offers extensible format validators and optional speedups (for example via Sereal::Encoder). The module focuses on correct, predictable error reporting and practical features like schema coercion, content-type handling and bundled specs so you do not need to fetch common definitions at runtime. Recent releases improved content-type negotiation when selecting schemas, relaxed idn-email validation to allow periods in the local part, and added a new "string" format among other reliability and performance fixes.

MIDI::RtController is a lightweight framework for building real-time MIDI processors that sit between your physical controller and a MIDI output, letting you remap, augment, or program live behavior with small filter callbacks. It runs on an asynchronous IO loop, accepts one or more input devices, and lets you register named filters for specific events like note_on, note_off, control_change, or for all events, so you can transform, echo, or schedule outgoing MIDI messages immediately or after a delay. The module also supports sharing a single loop and output across multiple inputs and ships with related filter modules for common tasks, making it a practical choice if you want to prototype or deploy live MIDI routing and processing without dealing with low-level device handling.

Alien::hiredis is a thin "Alien" wrapper that makes the hiredis C client library for Redis available to Perl modules and builds. It lets Perl XS modules find and link against hiredis by providing the library and headers either from a bundled "share" install or from an existing system installation, so module authors can depend on hiredis without manual compilation steps. The module is commonly used alongside Redis::hiredis and Protocol::Redis::XS and is licensed under the Artistic License 2.0 while the bundled hiredis is under the BSD license. The most recent release bundles hiredis 1.4.0 for share installs but still supports older non-broken system installs.

Search::Xapian is a Perl XS wrapper for the Xapian C++ full‑text search library that brings powerful indexing and querying into Perl with a more "Perlish" API. It lets you open or create Xapian databases, generate and parse queries with familiar flags for Boolean logic, phrases, wildcards and stemming, run enquiries to retrieve ranked matches and documents, and perform value and numeric-range filtering and sorting using portable serialisation helpers. The module exposes most of Xapian’s classes and features so you can build search engines, implement advanced query parsing, and handle term iteration and weighting from Perl code while still consulting the upstream Xapian docs for low‑level details. Note that a few Xapian classes and methods are not yet wrapped and some POD is incomplete, and you should use Search::Xapian >= 1.0.4.0 with Perl >= 5.8.7 when combining it with threads to avoid object-copying issues.

Net::Cmd is a lightweight base class that provides the common plumbing for command-oriented network protocols such as FTP, SMTP, POP3 and NNTP so module authors can focus on protocol specifics instead of socket and response handling. It supplies methods to send commands and data, translate line endings and perform dot-stuffing for protocols that use a dot-terminated data stream, parse three-digit reply codes and messages, manage simple debugging output, and present a tied filehandle for convenient data reads and writes. Net::Cmd is intended to be inherited by an IO::Socket::INET-like class and documents the minimal socket methods required if you use a different backend. It also exposes a set of status constants used by response and status methods and implements sensible pseudo-responses for connection closure and timeouts so callers always get predictable results. The module is mature and actively maintained in the libnet distribution, with recent releases improving protocol robustness and TLS handling, while the latest 3.15 release was a metadata update with no code changes.

JSON::PP is a pure-Perl JSON encoder and decoder that aims to be compatible with the faster JSON::XS C implementation so it can act as a reliable fallback when XS modules are not available. It offers both simple functional helpers like encode_json and decode_json and a configurable object interface to control UTF-8, ASCII or Latin1 output, pretty printing and spacing, canonical key sorting, relaxed parsing that accepts comments and trailing commas, and incremental parsing for streaming inputs. The module supports sensible mappings between JSON and Perl values including special JSON boolean objects, optional big number handling, and hooks for serializing and deserializing Perl objects via TO_JSON and FREEZE/THAW. You can also tune safety limits such as maximum depth and maximum input size. JSON::PP is included in the Perl core since 5.14, making it convenient on systems where building XS extensions is impractical, but if you need maximum performance you should consider JSON::XS or Cpanel::JSON::XS and if you want a smaller pure-Perl alternative look at JSON::Tiny.

LWP, also known as libwww-perl, is a mature collection of Perl modules that makes it easy to build web clients and simple HTTP servers by modeling web interactions as HTTP::Request and HTTP::Response objects handled by an LWP::UserAgent. It provides high level conveniences such as cookie management, robots.txt parsing, HTML form handling, content negotiation, proxy support, and helpers for ftp, file, gopher, news and mailto URLs, while also offering a terse procedural layer via LWP::Simple for quick scripts. The API is extensible and widely used for tasks like fetching pages, mirroring sites, automating form submissions and writing bots or test clients. Recent releases have focused on hardening and correctness, notably adding protections to avoid leaking credentials on cross‑origin redirects and refusing insecure https to http downgrades by default, so it remains a practical and safe choice for Perl web automation and tooling.

Mail::IMAPClient is a mature Perl library that implements the IMAP protocol (RFC3501) and gives scripts a high level API to connect to and manipulate remote mailboxes. It handles connecting and authenticating (plain LOGIN and several SASL methods such as CRAM-MD5, DIGEST-MD5, NTLM and PLAIN), SSL/STARTTLS, optional compression and keepalive, and exposes convenient methods for listing and subscribing folders, selecting mailboxes, fetching entire messages or body parts, parsing headers, searching and sorting, setting and clearing flags, copying, moving and appending messages, managing quotas and ACLs, and threading. The module supports UID-mode operations, transaction history and debugging output, provides utilities like fetch_hash, message_string and Range/MessageSet handling, and lets advanced users supply raw sockets or custom read/write hooks for nonstandard authentication. Errors are reported via LastError and there is a rich set of status queries for programmatic control. A few older behaviors were removed and some methods are deprecated or marked experimental, but overall this module is a comprehensive tool for automating IMAP mailbox tasks from Perl.

Test::Mojo::Role::OpenAPI::Modern is a Test::Mojo role that plugs OpenAPI::Modern into your Mojolicious tests so you can validate HTTP requests and responses against an OpenAPI document. It gives you an openapi accessor to supply or reuse an OpenAPI::Modern object, test helpers like request_valid and response_valid plus their inverse forms that can match specific error messages, and utilities to retrieve or dump JSON::Schema::Modern::Result objects for diagnostics. You can also assert the operationId for the last validated exchange and enable automatic error dumping with test_openapi_verbose. For test runs, use a relative openapi_uri because Test::Mojo uses a random port. This module focuses on making schema-driven request and response validation easy during app testing while deferring schema parsing and validation rules to OpenAPI::Modern and JSON::Schema::Modern.

Crypt::OpenSSL::X509 is a Perl wrapper for OpenSSL’s X.509 certificate functions that makes it simple to load, inspect and export certificates in PEM or ASN.1 form. You can read a cert from a file or string and extract subject and issuer names, serial number, validity window, public key details, RSA modulus and exponent, fingerprints (MD/SHA variants), extensions and Subject Alternative Names, and you can ask whether a cert is self‑signed or expired at a given time offset. It is aimed at developers who need to parse or validate certificates from Perl programs without shelling out to OpenSSL, and it supports a wide range of OpenSSL and LibreSSL releases. Recent work added compatibility with OpenSSL 4 and fixed const‑correctness and memory issues while improving test reporting. The subjectAltName handling covers the common GeneralName types but does not implement the RFC 5280 otherName tag.

Net::Statsd is a lightweight Perl UDP client for Etsy's statsd daemon that lets your application report counters, timings and gauge values to a central metrics collector. It provides simple functions like increment, decrement, update_stats, timing/get_timer and gauge, supports sampling to reduce traffic and can pack multiple gauge values into a single UDP packet to save bandwidth. By default it sends to localhost on port 8125 but you can change host and port; timers are reported in milliseconds and get_timer returns a callable timer object for convenience. The 0.13 release adds strict validation of metric names and values to block control characters, colons or pipes and prevent metric injection, with offending calls croaking. Because it uses UDP the client is optimized for high throughput but you should be aware that packet loss can affect gauge accuracy.

Mojo::JWT provides a Mojolicious-style API for creating and verifying JSON Web Tokens, making it simple to sign a set of claims into a URL-safe string and later decode and validate it. You build tokens by setting claims, expiration and not-before timestamps and an algorithm that defaults to HS256, then call encode to produce the token. Decode verifies the signature and timing claims and can use a supplied public key, a jwks array or a peek callback to select keys dynamically before verification. The module supports HMAC and RSA signing, exposes helpers for signing and verification useful when subclassing, and integrates easily with web flows such as OpenID Connect by accepting remote JWK sets. Be aware that JWTs are signed but not encrypted so you should not place secrets in the payload, the "none" algorithm is rejected by default unless explicitly allowed, and Perl hash randomization can change the exact encoded string even though encode/decode roundtrips remain valid.

OSPF::LSDB is a lightweight Perl base class for representing and managing an OSPF link state database, providing versioning, validation and conversion utilities for both IPv4 and IPv6 OSPF data. It stores LSDB fields using the familiar RFC names, supports a copy constructor to share the internal database with minimal overhead, and exposes simple methods to detect IPv6 databases, validate structure, upgrade older dumps to the current format, and report errors. The module is intended as the foundation for parsers, viewers and conversion scripts so use it when you need to load, store, convert or visualize OSPF LSAs or to build tools that consume ospfd, ospf6d or gated output. Methods die on fatal errors so callers should catch exceptions. Recent maintenance focused on usability and testing with updates such as allowing ospf2dot to write legends to output files and ensuring compatibility with YAML-Syck 1.46.

OcToolkit is a Perl library that automates OpenShift and Kubernetes project management by turning Template Toolkit templates into YAML and driving the cluster with oc or kubectl commands. It is focused on full lifecycle tasks — installing, validating, upgrading, backing up and deleting resources — and supports multi-cluster workflows, configurable per-instance options, and built-in secret handling with base64 encoding. The module is extensible via user callbacks for URL generation, component filtering, cleanup and configuration augmentation, so you can adapt template processing and diffs to your environment. It is intended both as the library behind the ocToolkit command line tool and as a building block for CI/CD pipelines, making it useful for small teams and projects that want template-driven deployment automation. Recent updates added examples, contribution and security documentation, and basic quality tests to improve packaging and maintainability.

CPAN::Perl::Releases::MetaCPAN lets you map Perl releases on CPAN to their tarball locations by querying the MetaCPAN API, so you can programmatically find download URLs and basic metadata like author, version, date, maturity and checksums. It offers an object interface to fetch structured release lists and a simple exported function perl_tarballs for getting tarball paths for a given version, making it useful for scripts or tools that need to locate or download official Perl release archives. The module mirrors CPAN::Perl::Releases but uses fastapi.metacpan.org for its data and includes links to artifact attestations for provenance.

TOML::Tiny is a minimal, pure-Perl TOML v1.0 parser and serializer that lets you read TOML files into native Perl data structures and write Perl hashes back out as TOML. It offers both simple functional calls and an object API and handles tables, arrays, strings, datetimes and booleans while providing hooks to customize how integers, floats, booleans and datetimes are inflated, falling back to Math::BigInt or Math::BigFloat when values exceed native precision. The module defaults to somewhat stricter parsing than older TOML libraries, supports quoted and multiline strings, binary/oct/hex integers and special float values like inf and nan, and aims to be compatible with TOML and TOML::Parser while adding a few useful options. Its pure-Perl, lightweight design makes it a good choice for scripts and environments where dependencies should be minimized. Recent releases removed a hard dependency on TOML::Parser and fixed tests when Types::Serialiser is not present.

Catalyst::Plugin::OpenIDConnect is a plugin for the Catalyst web framework that makes it easy to turn your application into an OpenID Connect provider, providing the authorization server side of OIDC and OAuth 2.0. It handles the common plumbing you need, including JWT creation and verification, state and code storage, and a reusable controller that mounts the standard endpoints and discovery document so you get authorize, token, userinfo, jwks and logout endpoints out of the box. You configure issuer details, signing keys and client registrations in your app config and then add a controller that extends the plugin controller so you keep full control of routing and integration with other Catalyst plugins. The plugin does not implement the OIDC client role, and it supports conditional initialization so apps sharing code can opt in to being a provider.

Astro::UTDF is a Perl module for reading and manipulating Universal Tracking Data Format files and turning each 75‑byte binary record into an object with convenient accessors for timestamps, azimuth, elevation, range delay, Doppler counts, transmit frequency, antenna metadata and many other UTDF fields. You can bulk read a file with slurp and get a sequence of Astro::UTDF objects linked to their prior record so the module can compute Doppler shift, range rate and human‑friendly measurement times, and you can also construct or modify records via mutators or by supplying hex/raw record data. The module exposes controls for validity checking, lets you override computation factors such as M and K and set transponder latency, and includes a decode helper that formats several fields for display. Note that the author marks the code as alpha and it was developed without access to the full UTDF specification, so users should validate results against their own data. Recent maintenance updated metadata and added a pointer to a Python implementation of UTDF for reference.