CPANscan

Long::Jump lets you mark a named point in execution with setjump and later unwind out of deeply nested call frames back to that point with longjump, optionally returning a list of values to the setter. It is a Perl-level analogue of C's longjmp but safer because jumps only move upward in the call stack and you cannot jump into arbitrary frames. setjump runs a block and yields undef when no longjump occurred or an array reference containing the returned values when longjump is used, and you may nest multiple jump points provided they use unique names. Calling longjump without a matching setjump throws an exception, and the recent addition of havejump lets you test whether a named jump point is currently active before attempting a jump. This module is handy when you need a controlled way to abort deep call chains and deliver results to a single handler.

HV::Monitor is a small Perl module for collecting and reporting statistics from hypervisors using a pluggable backend system with a simple object API. You create an instance, load a backend (the default is CBSD) and call run to execute the backend poller and return status while emitting the gathered metrics, which previously printed to STDOUT. The module is lightweight and script-friendly, with recent changes adding -q, -w and -o flags so output can be written to files instead of always printing, and the changelog shows ongoing backend fixes and enhancements for Libvirt/QEMU and bhyve. If you need an easy way to poll hypervisor metrics from Perl and wire those results into scripts or monitoring workflows, HV::Monitor is worth a look.

Horus is a high-performance XS UUID/GUID generator for Perl that implements all RFC 9562 versions (v1-v8) plus NIL and MAX and offers ten output formats including hyphenated, hex, URN, base32/64, Crockford and raw binary. It provides both procedural functions and an OO interface for single or bulk generation, supports deterministic namespace UUIDs (v3 and v5), time-based and sortable variants (v1, v6, v7), and handy utilities for validation, parsing, comparison and format conversion. Written with no external C library dependencies and optimized with random buffering and precomputed tables, Horus is designed to generate millions of v4 UUIDs per second while minimizing Perl/C crossings. Recent releases tidy up internal XS/op handling and pp code and include platform fixes for clock_gettime and threaded Perls to improve stability. If you need a fast, flexible UUID generator with broad format and version support, Horus is a solid choice.

WWW::PayPal is a Perl client library for PayPal's REST API that makes it easy to integrate checkout and recurring billing into Perl applications. It implements Orders v2 for one‑time payments and Billing Subscriptions v1 for recurring plans, and exposes controllers for orders, payments, products, plans and subscriptions so you can create orders, redirect buyers to approve payments, capture payments, issue refunds and manage subscription lifecycles. Authentication uses a PayPal client ID and secret and the module supports sandbox mode for testing. It caches OpenAPI operation tables to avoid runtime spec parsing and is a straightforward, Perl-native way to work with PayPal's modern REST endpoints.

Authen::Passphrase is an extensible Perl framework that models hashed passwords as objects and gives a consistent, high level API for creating, checking and serializing passphrase verifiers. You can construct recognisers from common encodings such as Unix crypt strings or RFC 2307 userPassword values, ask an object whether a candidate passphrase matches, and emit the stored form back as a crypt or RFC 2307 string; very weak schemes may also expose a recoverable passphrase. The distribution implements a wide range of historical and practical schemes for compatibility but recommends using modern choices such as SaltedDigest or BlowfishCrypt for new applications. The documentation also explains practical concerns like side‑channel timing exposure and limitations of doing cryptography in Perl, so you can assess whether extra hardening is needed. Recent maintenance updates fixed various loading and compatibility bugs and improved the documentation to emphasise preferred algorithms and side‑channel considerations.

Net::Async::Kubernetes is an asynchronous Kubernetes client for Perl built on IO::Async that gives you Future-based CRUD plus high-level helpers for pod logs, port-forwarding, exec and attach sessions, file copy to and from pods, and resilient watch streams. It integrates with Kubernetes::REST and IO::K8s so you work with inflated resource objects and the same short class names and CRD support you already know, and it resolves authentication from explicit server/credentials, a kubeconfig file, or in-cluster service account tokens automatically. All operations return Futures and the watcher includes automatic reconnect, resume via resourceVersion, and per-event callbacks so you can build event-driven tooling and controllers without blocking. Recent work adds a minimal controller runtime you can bind to a client for keyed workqueues and serialized reconcile dispatch, active exec and attach APIs with websocket duplex sessions and session helpers, cp_to_pod and cp_from_pod file-transfer helpers built on exec, and a TLS fix for kubeconfigs that embed CA or client PEM blocks so mTLS works correctly. If you need a nonblocking, IO::Async-native way to script or run controllers and interactive pod sessions against Kubernetes from Perl, this module is a solid choice.

App::Run::Command::ToFail is a small Perl base class that provides a simple framework for building a command line tool which runs another program and reports its outcome as an exit code. It offers a constructor and a run method that returns 0 on success and 1 on error, and relies on Getopt::Std for argument parsing and Readonly for constants. The module is minimal and intended as a starting point for utilities that need to invoke a script or binary and detect failure conditions, as illustrated by the included example that executes a temporary Perl script and returns an appropriate exit code. The code is lightweight, easy to subclass, and available on GitHub under a BSD 2-Clause license.

Net::Nostr is a Perl implementation of the Nostr decentralized messaging protocol that provides both client and relay functionality along with a rich set of helper modules for keys, events, message parsing, identity and signing, and many NIP extensions. It makes it straightforward to build WebSocket clients and run relays from Perl using simple factory methods and includes support for things like encrypted direct messages, relay info and management, media attachments, bech32 identifiers, threads, reactions, channels, and application-specific data. The distribution targets a wide range of NIPs so you can interoperate with modern Nostr features without wiring them up yourself. Recent releases added native TLS listener support for relays and exposed TLS options on the client so secure wss connections are easy to configure. If you want to build or integrate Nostr-capable applications or run relays from Perl, this module collection provides a comprehensive, production-minded toolkit.

Geo::H3 is a Perl object oriented wrapper for Uber's H3 geospatial indexing library that exposes H3 functionality through libffi and FFI::Platypus so you can work with H3 cells from Perl code. H3 partitions the globe into hexagonal cells and Geo::H3 makes it easy to convert between latitude and longitude and H3 indexes, to find a cell center, to get cell boundaries, to enumerate neighbors, and to measure distances, all using simple Geo::H3, Geo::H3::GeoCoord and Geo::H3::Index objects. The module presents coordinates in decimal degrees on the Perl side and supports H3 indexes as 64 bit integers or strings, while a lower level Geo::H3::FFI interface talks directly to the C structures when needed. This is a good fit if you need spatial indexing, aggregation, tiling, or proximity queries in Perl, but note it targets the stable H3 3.x API and does not support the incompatible 4.x line. The distribution is MIT licensed and requires installing the libh3 C library from the H3 project.

Spreadsheet::Write is a lightweight, row-oriented writer for spreadsheet files that lets you build CSV, Excel 97 (XLS) and Excel 2007 (XLSX) documents one row at a time with a single, consistent API, making it ideal for generating reports and data dumps. You create a new writer with new(file => ...), optionally let it auto-detect format from the filename or supply an IO handle, then push rows with addrow or batches with addrows, using simple scalars or hashrefs to attach styles, types, formatting and comments to individual cells, and use addsheet, freeze and close to manage worksheets and finalization. Many formatting options can be defined once as named styles and reused, unsupported features are safely ignored for formats that do not support them, and the module caches formats for better Excel performance. Recent maintenance cleaned up dependencies, added a license, and improved IO handle and format handling to make the module easier to install and use.

App::MARC::Filter is a small Perl base class that powers a command line utility for reading MARC21 XML bibliographic records and extracting or filtering records by simple criteria such as tag and subfield values. It supplies a constructor and a run method to drive a CLI workflow that accepts a file and matching arguments, returns standard exit codes, and can handle MARC XML input and common compressed formats via existing CPAN modules. The module is aimed at librarians, data managers, and developers who need a lightweight, scriptable way to count or pull MARC records from files and integrate that capability into larger workflows. It is intentionally minimal, depends on well known CPAN libraries, is available on GitHub, and is distributed under the BSD 2-Clause license.

Geo::H3::FFI is a Perl FFI binding that exposes the H3 geospatial hexagon grid C library to Perl programs. It lets you convert latitude/longitude to H3 indexes and back, get cell centroids and boundaries, traverse neighborhoods and lines (k-ring, hexRange, h3Line), move between resolutions, compact and uncompact sets, perform polygon polyfills and outline extraction, work with directed edges, and access utility functions for areas, edge lengths and distances. The module supplies FFI-friendly structs and wrapper helpers that return Perl data structures for convenient use. Note that it targets the H3 v3.x API and is intended to be used with H3 v3.7.2 because the H3 library underwent an incompatible rewrite in v4. This is a good choice if you want full H3 functionality from Perl without writing XS code.

Treex::PML is a Perl library that implements the Prague Markup Language (PML) to read, write and manipulate linguistically annotated treebanks and related XML-based annotation formats. It provides a high-level object model for documents, trees and nodes, schema-aware instances and utility types, pluggable I/O backends and optional on-the-fly XSLT conversion so you can load, validate, convert and traverse complex annotation layers without dealing with raw XML. The package uses a Factory pattern so you can swap in customized class families, includes helpers for resource-path resolution and deep cloning, and still supports older FS-format treebanks used by the TrEd ecosystem. If you work with dependency or constituency treebanks, corpus conversions or tooling around PML, this module gives you a ready-made, extensible Perl API; recent updates fixed saving of relative resource paths and made the test suite compatible with Perl 5.10.

Finance::Tax::Aruba is a Perl toolkit for calculating Aruba-specific taxes, focused mainly on individual income tax and payroll-related components at a practical, user level. It handles yearly tax rules across recent years and includes support for pensions, employer- and employee-paid premiums, fringe and non-fringe benefits, child deductions, and computations of employer social and government costs, with a bundled payroll helper script (bin/loon.pl) to simplify typical use cases. The distribution is actively maintained and recent releases added 2025 support and fixed a bug in the lowest income tier for 2023/2024. The author lists further planned improvements such as elderly deductions, dual-household calculations, SVB fees and other tax types, so the module is a good fit if you need a straightforward Perl-based way to model Aruban individual payroll and income tax today and want a project that is continuing to gain features.

Protocol::Gearman is an abstract base class that provides the common plumbing for implementing Gearman clients and workers rather than a drop-in tool for end users. It defines the minimal methods an implementation must supply, such as a send method to transmit bytes, new_future to create Future objects for asynchronous responses, and a place to stash Gearman-related state, and it supplies a suite of helpers for packing, parsing and sending Gearman protocol packets, dispatching received messages and handling simple request patterns like echo. The module also offers a convenient new_prototype constructor so you can build lightweight prototypical client or worker objects with code references, which is handy for tests and small scripts. Recent updates refreshed the codebase for newer Perl features and fixed a Future API compatibility issue, so the module is current and suitable as the foundation for custom Gearman implementations.

Apertur::SDK is the official Perl client for the Apertur API that makes it simple to manage upload sessions, send images, verify webhooks, and perform full CRUD on resources like destinations, API keys, webhooks, and encryption keys. You create a client with an API key or OAuth token and the module auto-detects sandbox versus live environments from the key prefix, then exposes focused resource accessors for uploads, polling, stats, and more so you can integrate Apertur workflows with a few straightforward calls. It supports plain and encrypted image uploads, long polling to retrieve processed assets, and helpers to verify webhook signatures, with encryption features enabled on demand via optional Crypt::OpenSSL::RSA and CryptX dependencies. Errors from the API are raised as typed Apertur::SDK::Error objects so you can catch authentication, rate limit, validation, and not found conditions explicitly. The SDK relies on common Perl HTTP and JSON libraries and is released under the MIT License.

Test::Which is a small testing helper that makes it easy to skip unit tests when required external programs are not available or do not meet version requirements. You can declare program requirements at compile time or check them at runtime with which_ok, and the module will locate executables on PATH or accept absolute paths, probe their version output using a built in heuristic or a custom flag or extractor, and compare versions with standard operators or regexes. Results are cached for the life of the process to avoid repeated invocations and verbose output can be enabled via environment variables so your test runs show the detected versions. The module works across Unix, macOS and Windows though platform quirks are noted and unusually formatted version output may need a custom extractor or explicit version_flag. Recent updates added a configurable timeout for program probes, better Windows handling and fixes to ensure messages are not lost.

Data::MARC::Leader is a compact Perl object for representing and validating the 24-character leader of a MARC bibliographic record. It provides a constructor and simple accessors for each leader element such as record length, record type, record status, character coding scheme, base address of data and the various length and count fields. The module enforces allowed codes and field lengths and can hold the raw leader string, so it is useful for building, parsing or checking MARC records in library systems, conversion scripts and data validation workflows. It is lightweight and designed to plug into Perl toolchains that work with MARC data.

MARC::Leader::Print is a lightweight Perl formatter that turns a Data::MARC::Leader object into easy-to-read text for display or logging, making the 24-byte MARC leader understandable at a glance. By default it prints descriptive labels for each leader element but it can be switched to show raw values instead, and it can return either a single joined string or an array of lines. You can enable optional ANSI color output and control it via a constructor flag or environment variables, and you can customize the scalar output separator. It is aimed at developers and cataloging staff who need a simple way to inspect or present MARC leader data and integrates with Data::MARC::Leader and common Perl utility modules; source and license information are available on the project GitHub.

CPAN::Maker is a command-line toolchain for turning a Perl project into a CPAN-ready distribution. You drive it with make-cpan-dist.pl or its bash wrapper and a YAML buildspec, and it will discover module dependencies, generate a Makefile.PL, collect your modules, scripts, tests and extra files, and build a tarball ready for publishing. It supports automatic dependency resolution (scandeps or Module::ScanDeps::Static), optional recommended, build and test dependencies, and options to control versioning and which files are packaged, so it is handy for authors who want to automate packaging instead of handcrafting manifests. The author notes that dependency scanners are not perfectly reliable so you should review the generated requires lists. In the recent 1.7.2 release support for Module::CPANfile and Module::ScanDeps::Static was added and packaging was improved to include .pm and .pod files while skipping scanning of POD files.

Crypt::SMIME is a Perl class for creating and handling S/MIME email messages that lets you sign, verify, encrypt and decrypt MIME content using OpenSSL's libcrypto. It works with PEM and PKCS#12 keys and certificates supplied as strings rather than filenames and exposes simple methods to set private and public keys, produce detached signatures, verify signed messages, encrypt for one or more recipients, and decrypt incoming S/MIME. The module also provides helpers to extract certificates, enumerate signers and read a peer's SMIMECapabilities, supports taint awareness and lets you control verification time and flags including CRL checks. Recent updates require OpenSSL 3.0 or newer, add an optional cipher argument so you can use modern AEAD ciphers like AES-GCM while preserving a sensible AES-128-CBC default, and ensure the module advertises AEAD support in signatures for better interoperability. If you need straightforward S/MIME support from Perl and already have OpenSSL available, Crypt::SMIME is a practical, maintained choice.

MOP4Import::Declare is a toolkit for building custom Perl exporters that turns use/import arguments into structured "declare_*" method calls so you can add pragmas, symbols, methods and variables to a target package in a consistent way. It dispatches incoming import items by type so a bare "-name" triggers declare_name, an arrayref like [name => @args] invokes declare_name with arguments, ordinary names and sigils are handled like traditional exports, and code refs can act as callbacks. A small Opts object carries caller information into each handler and the module provides helpers for common needs such as defining fields, constants, adding base or parent classes, remapping methods, and marking modules in %INC. It also offers convenience pragmas like -strict and -as_base and emits debug traces when DEBUG_MOP4IMPORT is set. If you need features beyond its built in dispatching, you can subclass and override dispatch_import to implement tag lists or other advanced Exporter behavior.

Dist::Zilla::Plugin::Repository automatically detects your project’s version-control checkout and writes the repository information into the distribution metadata so CPAN and other tools can link back to your source. You enable it by adding [Repository] to dist.ini and it handles common systems such as git, svn, cvs, darcs, bzr and hg while letting you override detection with an explicit repository URL or choose which git remote to use. It maps repository and web URLs into CPAN Meta fields and supports modern metadata practices, though the old github_http option is deprecated and using the MetaJSON plugin is recommended if you need both clone and web URLs. The most recent release broadened support for marking repositories with issue and web endpoints so hosting platforms like GitHub, GitLab and Bitbucket are represented correctly. The implementation is largely based on Module::Install::Repository, so it should feel familiar to users of that tool.

Math::GMPf is a Perl binding to the GNU MP (GMP) library's mpf floating‑point facility that gives you arbitrary precision "bigfloat" arithmetic from Perl. It wraps GMP's mpf API as Perl functions and methods for creating and assigning high‑precision floats, controlling precision, performing arithmetic and comparisons, converting to strings and native numeric types, formatted I/O, and generating random floats, and it overloads common numeric operators so Math::GMPf objects behave like native numbers. The module requires the GMP C library to be installed and returns blessed objects that are automatically cleaned up when they go out of scope, with alternative nobless functions if you want manual memory control. Use Math::GMPf when you need accurate floating point calculations beyond built-in doubles or when you want direct access to GMP functionality from Perl. Note that incorrect argument types can cause interpreter crashes, so follow the documented argument conventions and consult the GMP manual and the module test suite for examples.

Apache2::API is a developer-friendly Perl framework that sits on top of Apache/mod_perl2 and makes the server API much easier to use. It wraps request, response and server objects and provides ready-made helpers for JSON encoding and decoding, URL and UTF-8 handling, base64, UUID generation, htpasswd-style password hashing, logging and localized messages, plus convenient reply and bailout methods that format HTTP and JSON responses and errors for you. The module also manages handler registration, supports Server-Sent Events replies and optional response compression based on client capabilities and a configurable threshold. It exports Apache and APR constants for convenience and is designed to be extended, for example to provide custom gettext localization. If you are building mod_perl handlers or embedding Perl in Apache this module will save a lot of boilerplate and make common tasks straightforward, but it is only relevant in an Apache/mod_perl environment.

Git::Server is a drop-in replacement for a standard Git server that adds far more flexible server-side hooks, fine-grained access control and deployment tooling so you can enforce who can push what and trigger automated actions on every push or pull. It installs alongside SSH using an authorized_keys command and provides features like ACLs for writers, forcers and file-level push restrictions, IP and author-email whitelists, customizable pre/post hooks, webhook notifications, a git-client wrapper and a git-deploy helper for instant or background deployments. The module also supports proxy syncing to external remotes, detailed logging and safer defaults for bare repositories, and it includes helpers to verify SSH keys and client behavior. Recent releases improved the proxy functionality to allow multiple remote targets and syncing to empty repos, beefed up git-verify and git-deploy key handling and options, tightened a few security behaviors and added nicer diagnostics such as showing which public key connected; the project is actively maintained on GitHub with ongoing enhancements and bug fixes.

Perl::Critic::Policy::Security::RandBytesFromHash is a Perl::Critic policy that scans your code for the old and unsafe habit of generating "random" bytes by hashing predictable values such as rand, time, process id, reference addresses or internal counters and warns when it finds patterns like md5(rand() . time() . $$). It helps developers catch this subtle security footgun and points them toward proper sources of randomness such as Crypt::URandom, Crypt::SysRandom or Crypt::PRNG. You enable it in your perlcriticrc and adjust severity as needed. Be aware it will conservatively flag any hash or join that includes insecure inputs and can sometimes report the same construct more than once. This module requires Perl 5.24 or newer.

MARC::Leader::L10N is a lightweight localization helper for projects that work with MARC leader labels and need translated text. You request a language handle with get_handle using an ISO 639-1 code or let it pick the locale default and then call maketext with a key to get the localized string. If a requested language is not available get_handle returns undef. The module builds on Locale::Maketext and is intended for library or metadata tools that want simple, consistent translations of leader-related labels. It is BSD 2-Clause licensed, available on GitHub, and this 0.01 release is the initial public version.

RT::Client::REST is a Perl library that lets your application talk to a Request Tracker (RT) server using its REST API, effectively converting the old command-line "rt" tool into an object you can script against. You can authenticate, fetch, create and edit objects like tickets, users and queues, post comments and correspondence, attach files, search and sort results, inspect transactions and links, merge or link tickets, and take or steal ownership, all while errors are delivered as catchable exceptions so you can handle them with Try::Tiny or eval. The API mirrors the original rt tool so simple tasks are quick to script and there are also more object-oriented companion classes such as RT::Client::REST::Ticket and RT::Client::REST::User for nicer OO usage. Note that show() and edit() operate on a single object at a time and the module currently does not retrieve RT forms, and recent maintenance releases such as 0.73 focus on bug fixes including correcting a get_links URL bug and other small namespace and typo fixes. If you need to automate or integrate RT operations from Perl programs this module is a practical, well maintained choice.