CPANscan

IO::Socket::Timeout adds per-operation read and write timeouts to existing IO::Socket objects such as IO::Socket::INET. You opt in by calling enable_timeouts_on on a socket and then set read_timeout and write_timeout on that socket. It also provides methods to disable or re-enable timeouts and to query whether they are active. When a timeout occurs the socket operation returns undef or an empty string and errno is set to ETIMEDOUT or EWOULDBLOCK so you can detect and handle timeouts in your code. On supported systems the module uses platform socket options to enforce timeouts and falls back to select when needed and you can force the select implementation with an environment variable. This is a lightweight, drop in way to avoid blocking reads and writes in networked Perl programs and it pairs well with retry helpers like Action::Retry when you need reconnect or retry logic.

Module::CheckLatestVersion is a small utility that helps Perl authors detect when a loaded module is not the newest release published to an authority like CPAN or DarkPAN. It exports a single function, check_latest_version, which you can call from a module or script to compare the package $VERSION with the latest known release and either warn or die if it is out of date. Checks are cached (default cache timeout comes from Cache::File::Simple) and can be skipped automatically in common automated environments or explicitly via environment variables or the do_check option, and you can control verbosity with a log_level setting. Recent updates added the do_check option and configurable logging. This module is useful when you want lightweight, automatic verification that users or deployments are running the most recent version of a module.

Google::RestApi is a Perl framework that makes it easy to work with Google REST services from scripts and applications by providing object-oriented wrappers for Drive v3, Sheets v4, Calendar v3, Gmail v1, Tasks v1, and Docs v1, so you can list and copy files, read and write spreadsheet ranges, create calendar events, send messages, manage tasks, and edit documents without dealing with raw HTTP calls. It centralizes OAuth2 authentication and configuration, assembles endpoint URIs via chainable resource objects, offers a low-level api method when you need it, and includes conveniences such as pagination callbacks, a per-request callback hook, throttling for development, and tutorial scripts to get you started. The core Drive and Sheets modules were hand-written and other endpoints were generated to fill gaps, so most common operations are covered and well tested but you may see rough edges on less-used calls. If you need programmatic access to Google services from Perl and can set up OAuth2, this module provides a practical, script-friendly API.

Math::MPC is a Perl wrapper around the MPC C library that gives you true multiple‑precision complex numbers and a full suite of complex arithmetic and special functions with explicit control over precision and rounding modes. It exposes almost all mpc routines from basic arithmetic and power to trig, exponentials, logs, roots, modular functions and utilities for conversion and formatted I/O, and it interoperates with Math::MPFR and GMP objects so you can mix real and complex high‑precision types. You can create blessed Math::MPC objects that clean up automatically or use non‑blessed in‑place objects if you want manual memory control and the module also overloads common operators so code looks natural while using the current default precision and rounding. Note that Math::MPC depends on the GMP, MPFR and MPC C libraries and must be built against them, and you can get crashes if you pass incorrect argument types or rely on overloaded operators to always preserve the sign of zero. The module is mature and actively maintained; recent releases improved tests and build support such as quadmath builds on Cygwin and added newer mpc functionality while keeping backward compatibility.

Software::Policies is a lightweight Perl toolkit for generating common repository policy and license files, including CONTRIBUTING, CODE_OF_CONDUCT, SECURITY and LICENSE, so you can quickly produce ready-to-use text in formats like Markdown. You create a Software::Policies object and call create with the policy name, class, version and any attributes and receive one or more policy files as plain text that you can drop into a repo or wire into Dist::Zilla automation. The module is handy for making public projects look complete and welcoming, follows common templates such as the Contributor Covenant and CPAN Security guidance, and integrates with Dist::Zilla helpers for automated generation and testing. It is a young, actively maintained project with incremental updates through version 0.003.

PDL::NDBin is a PDL-based Perl module for making multidimensional histograms and for running arbitrary per-bin computations on packed ndarrays. Its preferred object-oriented API lets you define axes and variables, use built-in actions such as Count, Sum, Avg, StdDev, Min and Max, or supply your own code or XS classes to be executed per bin. You can feed data piecewise so very large data sets can be processed without loading everything into memory, and the wrapper functions ndbin and ndbinning offer a concise procedural way to get n-dimensional histograms. The module supports autoscaling of axis ranges, fixed or user-provided variable-width grids, bad-value handling, and returns results shaped to the bin grid. It does not yet support weighted histograms or direct extraction of the raw list of values per bin. Recent releases are maintenance-focused with updates to improve compatibility and testing with modern PDL versions.

PDL::FFTW3 is a PDL wrapper around the FFTW3 library that lets Perl Data Language users compute fast N‑dimensional Fourier transforms on ndarrays, including complex↔complex and optimized real→complex transforms, with support for single and double precision and PDL threading for batched operations. It exposes functions like fft1..fftn, ifft1..ifftn, rfft1..rfftn and irfft1..irfftn (rNfftX is an alias) and supports in‑place transforms for complex data while requiring native complex PDL types for inputs and outputs. The module follows the common convention of normalizing the inverse transform so ifft(fft(x)) recovers x, handles the half‑spectrum layout for real transforms and documents the ambiguity in inverse real output sizing that you resolve by supplying an output ndarray of the desired length. You will need a system installation of FFTW3 to build and use it. Recent updates remove legacy PDL::Complex support so everything uses native complex types and the distribution was relicensed to match PDL itself.

IPC::Manager is a Perl library for passing structured messages between processes on the same machine without a central broker. You create or spawn a datastore and share a short connection string, then any process can connect by name and send or receive IPC::Manager::Message objects using a pluggable serializer and a choice of transport backends. Backends include filesystem-based options, atomic pipes, Unix sockets, various SQL databases, and in-memory or shared-memory variants, and the module can pick a suitable protocol automatically or let you specify one. It also provides helpers to spawn lightweight services and named worker processes so you can build simple service trees and request/response patterns while the manager handles client registration, delivery and cleanup. Messages are created and read through a small API so the module fits easily into scripts, daemons and test harnesses that need reliable local messaging. Recent releases focus on robustness and platform compatibility with fixes for Unix sockets on FreeBSD, improved message ordering, central message sorting, and additions like JSONFile and SharedMemory clients and a move to Cpanel::JSON::XS for more reliable JSON handling.

NKC::Transform::BIBFRAME2MARC is a Perl utility for converting bibliographic records from BIBFRAME XML into MARC XML using XSLT transformations. You instantiate the object, choose a transformation version (default is 3.0.0, several older versions are supported) or supply your own XSLT file, and call transform with BIBFRAME XML to receive MARC XML as a string. The module relies on XML::LibXML and XML::LibXSLT and will report errors if the XSLT file cannot be read or if unknown parameters are passed. It is a straightforward choice when you need to migrate or integrate BIBFRAME data with MARC-based systems.

Enum::Declare adds a simple declarative enum keyword to Perl so you can define named constants and a rich enum metadata object with minimal boilerplate. You write enums with optional attributes to make them integer sequences, string values that default to the lowercased name, or bitflags that auto-assign powers of two, and you can export constants into callers if desired. Variants may be given explicit values and integer enums auto-increment from the last explicit value, and every enum name also returns a meta object providing introspection like names, values, name/value lookup, validity checks, count, and a pairs list. The meta object also offers an exhaustive pattern matching helper that requires handlers for every variant or a wildcard default, which simplifies mapping enum values to behavior. This module is useful when you want clear, compile-time constants and convenient runtime introspection for enumerated types in Perl.

DarkPAN::Utils is a small utility library for working with a private CPAN mirror hosted on Amazon S3 and served via CloudFront, letting you download and parse the standard CPAN package index, fetch distribution tarballs, and extract individual files or Perl module sources for documentation or inspection. You can operate over the network by giving a base_url or work entirely locally by passing an Archive::Tar object, which is handy when a newly uploaded tarball is not yet available through the CDN. The module provides a parser for distribution paths, methods to fetch and cache 02packages.details.txt.gz, a find_module search over the in-memory index, fetch_package to download and load a tarball, and extract_module or extract_file to retrieve specific entries. It also includes a tiny command line front end and configurable Log::Log4perl logging via init_logger and log_level. Note that fetch_darkpan_index must be called before find_module and that network-based methods require base_url and will die on HTTP failures.

Crypt::OpenSSL3 is a Perl wrapper for OpenSSL 3 that gives Perl code direct access to modern SSL and cryptographic primitives. The distribution supplies modules for SSL connections, asymmetric keys, symmetric ciphers, message digests and MACs, key derivation functions, and X509 certificate handling, while the top-level Crypt::OpenSSL3 module focuses on error handling and build-time configuration and version introspection. It is a good fit when you need low level OpenSSL 3 functionality from Perl rather than a higher level abstraction. Recent releases expanded ASN.1 and X509 type coverage, improved compilation on clang and C++, and added a new sign_init_ex feature for digest contexts while gating X509 VerifyParam get_purpose on OpenSSL 3.5 and newer.

Cucumber::Messages is a Perl library that maps the Cucumber message protocol into native classes and gives you NDJSON serialization and deserialization so Perl programs can produce, consume, and manipulate Cucumber message streams. It provides an Envelope wrapper with to_json/from_json helpers and concrete message types for attachments, external attachments, Gherkin documents, pickles, test cases and steps, timestamps, exceptions and more, letting you build reporters, formatters, CI integrations or other tooling that reads or writes Cucumber messages. The API focuses on representing the protocol in memory and on the wire rather than execution details, and supports handling large binary artifacts via external attachments to avoid embedding heavy data. The code is released under the MIT license.

Log::Dispatchouli is a lightweight wrapper around Log::Dispatch that makes it very easy to add practical logging to Perl programs without wrestling with levels and categories. It can send output to syslog, stdout, stderr, files or to an in-memory array for tests and uses String::Flogger to format messages so you can log plain text, structured data, sprintf-style arrays or lazily evaluated coderefs. It also provides structured event logging via log_event using logfmt formatting, simple per-logger and per-message prefixes, proxy loggers for localized context, and handy controls such as debug, muted, pid tagging and fail_fatal behavior. There are testing helpers like new_tester and events, and convenience methods to get formatted strings without emitting them (flog_messages and fmt_event). Recent releases add optional use of Log::Fmt::XS for logfmt emission and fix an auto-use bug, and note that the older to_file option is deprecated and scheduled for removal.

SQL::SimpleOps is a Perl module that builds and executes common SQL operations across multiple database engines via DBI, supporting MySQL, MariaDB, PostgreSQL and SQLite3. Rather than parsing SQL it provides a convenient builder and executor for inserts, updates, deletes, selects, cursor-based paging and subqueries while allowing you to map friendly aliases to real table and column names to avoid recoding when schemas change. Results can be returned into hashes, arrays, scalars or handled by callbacks and the module offers flexible where and having expression formats, conflict/upsert support, per-call or global options for quoting, commit behavior, syslog or STDERR messaging and optional SQL file logging for auditing or recovery. It also includes cursor helpers that save paging state and features for reversed or indexed buffers to suit different retrieval patterns. Recent updates added select/having and buffer_reverse options and fixed several where-clause edge cases including correct handling of empty conditions as IS NULL, so it is a pragmatic choice if you want to reduce SQL boilerplate in Perl applications without writing engine-specific code.

Perl::Critic::Policy::Security::RandBytesFromHash is a linting rule for Perl::Critic that finds a common but unsafe pattern where programs try to produce random bytes by hashing predictable inputs such as rand, time, process id, reference addresses or internal counters. The policy explains why hashing those seeds with functions like MD5 or SHA gives a false sense of security and can be guessed by attackers, and it points developers toward secure alternatives such as Crypt::URandom, Crypt::SysRandom or Crypt::PRNG. It flags calls that look like hash functions or joins built from insecure sources and may sometimes report the same construct more than once. The module is aimed at catching legacy and new code that uses this risky shortcut and requires Perl 5.24 or later; the package is newly released as v0.1.0.

Amazon::API is a Perl base class that provides a lightweight, generic gateway for calling AWS services and for building small, focused service clients. You can use it directly for ad hoc requests, subclass it to expose a handful of methods for a single service, or use the included amazon-api tool to generate full service and shape classes from Botocore metadata so that requests and responses are serialized correctly. The module handles signing, content-type selection, pagination and optional automatic decoding of JSON or XML responses and integrates with Amazon::Credentials for flexible credential sourcing. It is a good fit if you want to install or use only the AWS APIs you need rather than a full SDK, but it expects some familiarity with AWS API payloads and requires generating shape classes for full Botocore-based support. Recent releases replaced LWP::UserAgent with a project-specific HTTP::UserAgent implementation and removed an unused accessor dependency while continuing to refine Botocore serialization and pagination behavior.

Devel::CallParser provides an XS-level C API that lets extension authors attach custom argument parsers to Perl subroutines so calls can be parsed by C code instead of relying solely on Perl's default parser. It supplies header files and linkable objects at build time and exposes a central cv_set_call_parser primitive plus a suite of helper parsers for parenthesised, nullary, unary, list, block-and-list and prototype-driven argument forms, making it useful when you need to implement nonstandard call syntax or custom compile-time argument handling in an XS module. The facility is most effective on modern Perls, with limited support on Perl 5.11.2–5.13.7 and full functionality on 5.13.8 and later, and it only triggers for unqualified subroutine names. The author has fixed portability and core-interaction issues in recent releases so generated headers work across API-compatible Perls and several incompatibilities with older Devel::Declare and Data::Alias versions have been addressed.

Log::Report is a Perl framework that unifies three related concerns into one API: structured logging, exception handling, and internationalized messages. It gives you easy message constructors like __x and __n that build objects with delayed interpolation and translation, short helper functions such as error, info and trace to replace die/warn, and a dispatcher system that can send each report to multiple back-ends such as files, syslog or Log::Log4perl with configurable verbosity modes. It also provides a try block that captures exceptions as rich message objects so callers can inspect, rethrow or route them without losing untranslated parameters or context. Use it when you want consistent multi-destination logging, language-aware user output, or cleaner exception semantics across modules and applications, and opt for Log::Report::Optional when you need a very lightweight footprint. Recent releases (current 1.44) renamed exception "classes" to "tags" in a backwards compatible way and ensure converted die messages receive a 'die' tag.

Dancer2::Plugin::LogReport is a Dancer2 plugin that connects your web app to the Log::Report system to give you unified logging, exception handling and translation support. It captures Log::Report messages and can stash user-facing notices and errors in the session for display in templates while routing debug and error output to configured dispatchers such as STDERR, files or syslog. The plugin supplies convenience helpers like process to run code and catch fatal exceptions cleanly and fatal_handler to let you customize how fatal errors are presented, for example returning JSON for API routes. It also adds a success message type, integrates with DBIx::Class profiling, and is configured through the Dancer2 logger settings so you can control formats and destinations. If you need structured, flexible logging plus simple user-facing error handling and internationalization across a Dancer2 application this module is likely relevant. Recent releases tightened security to avoid leaking internal error text to end users and addressed Dancer integration and dependency issues.

Business::NAB is a top-level Perl namespace that groups a set of modules for creating and parsing the file formats used to exchange payment and reporting data with NAB. The distribution itself is just an entry point and links to focused classes that handle BPAY batch payments and remittances, Australian Direct Entry payments, returns and reports, NAB account information (NAI/BAI2) files, and XML acknowledgements. If you are a developer automating NAB payment runs, importing bank reports, or integrating reconciliation and reporting workflows, these modules give you ready-made parsers and builders to handle the common interchange formats. The code is open source, licensed under the same terms as Perl, and the project accepts contributions via its GitHub repository.

Atomic::Pipe gives you a simple way to send discrete, non-mangled messages over POSIX pipes even when many processes or threads are writing at once by breaking messages into PIPE_BUF-sized atomic chunks, tagging them, and reassembling them on the read side so readers always get whole messages. It provides paired reader and writer objects, constructors for pipes, FIFOs, filehandles and file descriptors, blocking and non-blocking modes with buffering and flush, and optional pipe buffer resizing on supported Linux systems. Ordering between different processes or threads is not guaranteed and the atomic guarantee is limited by the platform PIPE_BUF value, and the module only works on POSIX-compliant pipes. A mixed-data mode lets you embed atomic bursts and messages inside noisy STDOUT or STDERR streams using special control characters so you can recover data from interleaved output, but that mode will break if the noisy output itself contains those control characters. Use Atomic::Pipe when you need reliable, message-oriented IPC over pipes and want to avoid the usual interleaving and mangling of concurrent writers.

Imager is a full-featured Perl library for creating, editing and saving true-color images and is well suited for tasks like thumbnails, watermarks, filters and format conversion. It can read and write many common formats, draw primitives and text, handle alpha and palettes, perform scaling, cropping, rotation and compositing, and offers a rich set of filters and programmable transformation engines. Functionality is organized into focused components such as Draw, Filters, Transformations, Font and Files so you can build simple scripts or complex image pipelines using an object oriented API that reports errors via errstr. The project is actively maintained on CPAN and GitHub and is licensed under the same terms as Perl.

Developer::Dashboard gives you a single local home for everyday development tasks by combining a lightweight browser dashboard, a shared CLI entrypoint, and a prompt status layer that all read the same runtime data. It organizes bookmarks, saved pages, quick notes, repeatable actions, background collectors that prepare cached health checks, and compact indicators that drive both the web UI and your shell prompt. The tool also includes helpers for opening files and resolving module or Java class names, small data query commands for JSON/YAML/TOML/properties, and a project-aware Docker Compose resolver so common container workflows live behind one command. It supports layered runtime lookup so project-local ./.developer-dashboard trees can override home defaults without losing shared fallbacks, stages built-in helper scripts privately to avoid polluting your PATH, and provides simple skill extensions you can install from Git for repo-scoped tooling. It is implemented in Perl but works across polyglot projects and ships sensible security defaults like owner-only runtime permissions and optional self-signed HTTPS for the web UI. Recent releases tightened the skill layering behavior so same-repo child layers no longer shadow their base skill and improved the layered skill dispatch, bookmark and config inheritance while adding test coverage for those cases.

SPVM is a statically typed language with Perl-like syntax that lets you write high‑performance code while keeping familiar Perl idioms. It supports ahead‑of‑time and just‑in‑time compilation, can produce standalone executables, and provides tight C and C++ integration plus a Perl binding so you can call SPVM methods from Perl or wrap native libraries. The ecosystem includes many standard and CPAN‑style modules, built‑in support for threads and lightweight coroutines, static typing with inference and analysis, and a focus on performance for numeric and system code. Be aware the project has not reached 1.0 and does not guarantee backward compatibility. Recent work has strengthened the build and packaging toolchain, adding a robust parallel build engine (including Ninja‑style content hashing) and improved cross‑platform linker behavior, and the documentation has been consolidated to make the language and builder APIs easier to use.

SPVM::Resource::SQLite packages the SQLite C amalgamation so SPVM native extensions can compile and use SQLite without requiring a separate system installation. It provides sqlite3.c plus the sqlite3.h and sqlite3ext.h headers and configures compilation with common options turned on, including thread safety, column metadata, FTS5 full text search, R*Tree spatial indexes, JSON and math functions, and the dbstat virtual table. To use it you add Resource::SQLite to your SPVM::Builder::Config and include "sqlite3.h" in your SPVM C sources to call SQLite APIs directly. The module is MIT licensed, maintained by Yuki Kimoto, and recent updates standardized the build to C99 for improved portability.

Sort::DJB provides Perl bindings to Daniel J. Bernstein's djbsort library, giving you fast, branch-free sorting of primitive arrays using bitonic sorting networks. It exposes dedicated functions for signed and unsigned 32/64-bit integers and 32/64-bit floats, each in ascending and descending variants, and each function accepts an array reference and returns a new sorted array reference without modifying the original. The implementation is constant-time and type-safe, making it a good fit for cryptographic use cases that need to avoid timing side-channels, and when available the XS bindings use SIMD optimizations such as AVX2, SSE4.2 or NEON for extra speed while a portable C fallback and a pure-Perl companion are provided for compatibility and testing. Small helpers let you query the bundled djbsort version, target architecture and which implementation is active. Recent notable change: the distribution was relicensed to GPLv2 in version 0.2.

XAO::Base is a lightweight collection of foundational helper modules used across the XAO product family to provide common services developers rely on. It bundles error namespace generation, a dynamic object loader that other XAO components use, a project registry and context switcher useful for storing site configuration and database handlers in mod_perl environments, a simple hash-oriented object with URI-style access, assorted small utility routines, and a configurable base object for composing configuration pieces. If you are developing on or extending the XAO framework these building blocks save time and keep behavior consistent; if you are not using other XAO components this package is unlikely to be useful on its own.

Data::RingBuffer::Shared implements a fixed-size circular buffer in shared memory for Linux running 64-bit Perl, letting multiple processes efficiently publish and read a rolling window of values. Writes never block and always succeed, overwriting the oldest entries when the buffer is full, while readers can fetch the latest values by relative index or by absolute sequence number, dump the whole buffer, or wait for new data with optional timeouts and eventfd notifications. Two typed variants are provided for 64-bit integers and doubles, and write() returns a sequence number for coordinated reads, making this well suited to metrics, sensor streams, debug traces and other rolling-window use cases. Be aware the underlying mmap is writable by any process that opens it, and this module is Linux-only.