CPANscan

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.

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.

Sereal is a Perl module that provides a fast, compact binary serialization format by bundling the Sereal::Encoder and Sereal::Decoder implementations into a single thin wrapper. It is aimed at high-performance use cases such as IPC, caching, network transport and on-disk persistence and handles complex Perl data structures, freeze/thaw hooks, and a range of numeric types. For best speed you should use the object-oriented Encoder/Decoder interface but convenient exported functions exist for simpler tasks and there are helpers to obtain shared encoder/decoder objects, clear their caches, and read or write sereal packets to files. The implementation supports multiple compression backends including Snappy, zlib and Zstd and exports constants for those modes. Because encoder and decoder are released separately the module ensures compatible versions are loaded and warns that you should upgrade decoders before encoders; recent notable work includes the protocol 5 release with improved floating point handling, support for newer Perl bools and various build and security fixes.

Test::Returns is a small testing helper for Perl that makes it easy to assert that a function or method return value conforms to a declared schema. It exports readable helpers like returns_ok and returns_not_ok that validate values via Return::Set and Params::Validate::Strict and integrate with Test::Builder so they work alongside Test::More and Test::Most. The module accepts type => 'array' as a convenient synonym for 'arrayref' and passes through underscore-prefixed schema keys used by some generators. It is minimal, GPL2-licensed, and provided as-is without warranty.

Module::Generic is a feature-rich base class for building Perl objects quickly that supplies a large toolkit of reusable helpers so you can focus on your domain logic rather than boilerplate. It provides flexible, type-aware getter/setter helpers for scalars, numbers, booleans, dates, IPs, UUIDs, arrays and nested object trees, a create_class helper to generate classes and accessor methods on the fly, AUTOLOAD-based dynamic access to hash keys, and convenient facilities for serialization, cloning, structured error/exception objects, debug and colorized terminal messages. Many utility routines are lazy-loaded to reduce memory use and performance-critical checks are implemented in optional XS with pure-Perl fallbacks if the XS backend is not available. The design favors non-fatal error handling by returning undef and an exception object instead of dying, which makes it easy to propagate and inspect errors consistently. It also includes helpers for loading classes, instantiating related objects, pretty-printing and dumping data, and thread/process-aware global error storage. Note that a few metaprogramming features such as dynamic symbol insertion and runtime class creation carry thread-safety caveats and some functionality depends on optional CPAN modules, so preload or avoid those at runtime in threaded contexts if that matters for your application. If you are writing Perl modules or applications that need rapid, consistent creation of typed accessors, nested object models and common utilities, Module::Generic can save a lot of time.

Net::Firewall::BlockerHelper is a lightweight Perl helper for programmatically managing IP bans across multiple firewall backends. It exposes a simple API to initialize and teardown firewall rules, ban and unban IPv4 and IPv6 addresses, handle CIDR ranges when the chosen backend supports them, list current bans, flush all bans, and reapply rules. The module validates ports, protocols, IPs and CIDRs, offers a configurable self_heal mode that checks and restores the backend setup before each action, and delegates actual rule work to backend implementations such as ipfw. Error handling is done via Error::Helper and failures are treated as fatal, making this module a practical choice for scripts or services that need a uniform way to manage blocking across different firewalls.

Lingua::TokiPona::Word is a small utility for representing and working with words in the miniature language Toki Pona. It creates normalized, deduplicated word objects from either a plain string or another identifier object and provides a simple API to get the word back as text, test equality, and perform a stable ordering via cmp with the usual Perl operator overloads. The module builds on Data::Identifier interfaces so it is useful when you need canonical, comparable word objects for parsing, indexing, or manipulating Toki Pona text. This is the initial release and offers the core behaviors of normalization, deduplication, string conversion, equality checks, and a stable but not strictly specified sort order.

Concierge is an extensible service layer that handles user identity, sessions, and user records for applications by coordinating three core components, Auth, Sessions, and Users, and by allowing additional pluggable components to be attached to a desk, which is a directory holding the app's concierge configuration and storage. It exposes simple lifecycle calls for visitors, guests, and logged in users so you can create anonymous trackers, session-backed guests, authenticate users, restore sessions from user keys, convert guests to accounts, and manage sessions and passwords while keeping credentials out of user records. All API calls return structured hashrefs with clear success and message fields so your application always retains control and errors are reported instead of failing silently. The system is backend-agnostic so you can swap or add storage and auth backends and optionally defer expensive component initialization until first use. Recent notable changes in v0.13.0 removed the earlier feature that promoted component methods into the concierge itself so added components must now be called through their component object, and added user-level mirror methods verify_password, reset_password, and logout so returned user objects can perform those checks and updates directly. If you need a reliable, pluggable identity and session orchestration layer that keeps operational resources separate from application logic, Concierge is a good fit.

Crypt::SMIME is a Perl module that provides a simple object interface for creating and consuming S/MIME messages so you can sign, verify, encrypt and decrypt MIME mail using OpenSSL's libcrypto. You give it your private key and certificate as PEM strings or load them from PKCS#12, point it at trusted certificate stores, then call sign, check, encrypt or decrypt and use helper methods like isSigned, isEncrypted, extractCertificates and getSigners to inspect messages. It supports detached signatures, lets you choose the cipher for encryption, can check certificate revocation lists and lets you set the verification time, and it follows Perl tainting rules when inputs are tainted. Recent releases modernized OpenSSL support by requiring OpenSSL 3.0 or newer, added support for AEAD ciphers such as AES-GCM and an explicit cipher argument for encrypt, added getCapabilities and CRL-check flags, and include build fixes for OpenSSL 4.0 and Windows.

Dist::Zilla::PluginBundle::Author::GETTY is a ready-made Dist::Zilla configuration bundle that wires up the author GETTY's preferred plugins and sensible defaults so you can build, test, and release Perl distributions with minimal setup. It handles versioning, metadata, PodWeaver, Git-based version management and release commits, optional GitHub release publishing, install-after-release, and support for XS or Alien-based C libraries, plus convenient hooks to run scripts before or after build and release. The bundle auto-detects GitHub remotes but can emit generic or Gitea/Forgejo metadata for self-hosted forges, excludes README.md from release tarballs by default, and can also add Docker image build and CI wiring through a shared GitHub Action, so it suits pure-Perl modules, XS modules, and packaged C-library wraps. Configuration options let you opt out of particular behaviors, mark a dist as up for adoption, add IRC support in metadata, restrict which files get $VERSION rewritten, and pass through Alien or Docker settings without manual plugin plumbing. Notable recent change in v0.317 adds a tag_format option so you can control the format of Git tags produced at release time, for example to prepend a v for other ecosystems while keeping Perl version semantics intact.

Mojolicious::Plugin::Fondation is a plugin manager for Mojolicious that helps you compose web apps from reusable modules by loading plugins recursively, resolving dependencies, and merging configuration and resources in a predictable way. It combines configuration from three sources with a clear priority (direct overrides, then application config, then plugin defaults) and concatenates arrays so apps can extend lists such as dependencies or roles. Fondation automatically exposes plugin share/templates and share/public directories to your app, wires plugin controller namespaces into the router, and performs configurable post-load actions like Templates, Controllers and Static, then calls an optional fondation_finalyze hook for plugins that return $self from register. The framework also supplies helpers including a manager accessor and render_zone/render_zone_js for injecting HTML and JS fragments from plugins into layout zones, and it supports custom action classes for additional initialization work. Recent releases added clearer action logging so you can see which plugin an action runs on, provided JavaScript and date-format fallbacks, and added conveniences like scanning a development plugins directory.

Dist::Zilla::PluginBundle::DROLSKY is the personal Dist::Zilla plugin bundle used by Dave Rolsky to assemble and configure the many plugins he uses to build, test, document, and release Perl distributions. It acts like a ready-made dist.ini that wires up metadata generation, versioning, Git integration, test suites, Pod checks and spelling, license and contributors handling, AutoPrereqs detection, Readme generation, optional PPPort support for XS code, and a host of other release-time conveniences, while allowing per-plugin removal or reconfiguration. The bundle is intended as a blueprint rather than a drop-in for other authors, so you will likely consult it for ideas and patterns rather than copy it verbatim, and you can find its source and bug tracker on GitHub if you want to inspect or adapt it.