CPANscan

Number::Phone is a Perl base class and factory for country-specific phone number modules that parses, validates and formats international and national numbers and picks the right country subclass for you. Call Number::Phone->new with a full international number or with a country code plus local number and it will load a Number::Phone::XX module or fall back to libphonenumber-derived stub data; subclasses provide methods to check number properties like is_valid, is_mobile or is_tollfree, to extract metadata such as country, area code, subscriber part, operator and timezones, to produce E.123-compliant or custom formats, and to compute how to dial from one number to another. The distribution is regularly updated from Google’s libphonenumber data, lets you disable stubs or force libphonenumber-derived behavior, and documents how to add new country modules, but it requires a 64-bit Perl and relatively recent Perl versions and some country modules such as Number::Phone::UK can be slower due to large local databases.

Gherkin is the Perl implementation of the Gherkin language parser and compiler used by Cucumber, letting you turn human-readable feature files into the standardized protobuf/NDJSON message stream that downstream tools consume. You use it when you need a programmatic, language-aware way to read feature files, handle international keywords, and produce Source, GherkinDocument (AST) and Pickle messages for tooling or test pipelines; it exposes simple streaming APIs such as from_paths and from_source that take an ID generator and a sink callback and offers options to include source text, the AST, or compiled pickles. The parser is generated from the official grammar and aligns with the Cucumber::Messages format, so modern versions emit Cucumber::Messages objects rather than plain hashes, and recent releases have continued to improve language support and performance while fixing memory and parsing issues, for example the latest 39.1.0 release expanded Turkish keywords and included parser optimizations and stability fixes.

DBD::D1 is a pure-Perl DBI driver that lets your Perl DBI code talk to Cloudflare D1, Cloudflare's serverless SQLite-compatible database, using the D1 REST API. It uses HTTP::Tiny and JSON::PP so no compiled extensions are required, and you connect by supplying your Cloudflare account_id and database_id in the DSN and your API token as the DBI password. Once connected you can prepare and execute SQL and fetch rows using the familiar DBI interface, but prefer fetchrow_hashref because results are returned as JSON objects and column order is not guaranteed. Be aware that the D1 REST API only supports AutoCommit so there is no multi-statement transaction support. The module integrates with typical Perl installations that provide DBI and TLS support.

Sys::Export helps you build a self-contained subset of a Unix filesystem for chroot, initrd or similar needs by copying only the files you request and automatically including needed interpreters and libraries. You can rewrite paths and users or groups so files work in their new locations, inject dynamically generated files, skip specific files, and recurse with filters when adding whole directories. The module is a thin front end that instantiates an OS-specific exporter such as Sys::Export::Linux and exports convenient functions so you can drive the export without dealing with objects directly. It also offers helpers for creating minimal /etc/passwd and group files, lazily loading or memory-mapping file data, expanding shorthand file specifications, and other small utilities for writing archive or image contents. Configuration is done on the use line and the interface supports producing a directory or a CPIO image as the destination. Currently only Linux is fully supported.

Sub::Abstract provides a lightweight way to declare abstract (virtual) methods in plain-Perl object systems without bringing in Moose or Moo. You mark a method with the :Abstract attribute or list method names in the import call and the module installs a runtime wrapper that croaks if the method is ever reached with no subclass implementation, which makes missing overrides fail loudly at runtime. It is easy to use in tests because you can temporarily disable the check with $Sub::Abstract::BYPASS or by the standard HARNESS_ACTIVE convention, and the harness bypass can be turned off via %Sub::Abstract::config. Be aware this works only at runtime so it cannot statically verify all subclasses, it replaces the stash entry so can() will return the stub rather than undef, and it installs the :Abstract attribute in UNIVERSAL which adds a global symbol. This is a focused tool for plain-Perl OO code rather than for Moo or Moose users, and this release is the initial 0.01.

WiringPi::API is a Perl XS wrapper for the wiringPi C library that lets you control Raspberry Pi hardware from Perl, including GPIO pin read/write, PWM, software PWM and tone, I2C, SPI, serial, ADCs, LCD displays, shift registers and sensors such as the BMP180. You can use it procedurally or as an object and must call one of the setup*() routines first to choose your pin-numbering scheme. The module provides a full interrupt subsystem with cooperative dispatch loops, optional signal-driven auto-dispatch, and convenient background handlers that run in their own process, plus a generic worker helper to run background tasks reliably without threads. It exports Perlish snake_case and C-style names and reuses RPi::Const for constants. It requires the wiringPi C library (version 3.18 or later) and the wiringPiDev shared library to be installed. A recent 3.18-era release rewrote and hardened interrupt handling to use a self-pipe model, added background_interrupt(s) and worker() facilities, improved validation and error handling, and expanded I2C/SPI and other wrappers. Note a few hardware-specific caveats such as the byte-bank read/write operations being unsupported on Raspberry Pi 5 and that lcd_init() can return -1 on failure so you should check its return before calling other LCD functions.

Dancer2::Plugin::Auth::OAuth is a lightweight plugin for the Dancer2 web framework that adds third‑party OAuth login with almost no code, letting you enable providers by configuration and automatically creating the standard routes like /auth/<provider> and /auth/<provider>/callback. After a successful login the provider response is saved in the session under the "oauth" key so your app can read id_token and access/refresh tokens for API calls, and the plugin also offers a refresh route to renew tokens without forcing users back to the login page. It ships with built‑in providers (Facebook, Google, Twitter, GitHub, LinkedIn, StackExchange, and more) and simple config options for prefix, success/error URLs, scopes and provider-specific parameters, making it a good choice for adding social login or delegated identity to Dancer2 apps. The module is actively maintained and recent releases include security improvements such as switching nonce generation to a secure random source to address CVE-2026-11832.

Sub::Private lets you mark Perl subs and methods as strictly private so they can only be called from the package that defines them. You can use the :Private attribute on a subroutine or, in the newer enforce mode, declare names with use Sub::Private qw(_helper) to have the module wrap those subs and enforce caller checks at runtime. The module supports two modes: the default "namespace" mode removes the sub from the symbol table for backward compatibility, while the new "enforce" mode (added in 0.05) installs wrapper closures so private routines also work with OO method dispatch. There are convenient test bypasses and configuration hooks exposed via $Sub::Private::BYPASS and %Sub::Private::config so tests can temporarily disable checks and so you can turn off the HARNESS_ACTIVE bypass. Known caveats are documented by the author and include runtime-only enforcement in enforce mode, the possibility of bypass via raw coderefs obtained before wrapping, and that ->can() may reveal private methods in enforce mode; the attribute form and the namespace mode avoid some of those issues. If you need package-level privacy for helper functions or want strict owner-only access for methods, Sub::Private is a small, focused solution that now includes an OO-safe enforcement option and a declarative import form.

Astro::SpaceTrack is a Perl client for fetching satellite orbital data such as TLEs from Space-Track.org and other public sources like CelesTrak and Mike McCants' archives. It gives you high-level methods to log in, search by name, launch date or NORAD ID, retrieve predefined catalogs or supplemental CelesTrak sets, and get results as HTTP::Response objects or parsed lists while also offering an interactive shell and credential support via a Config::Identity file. The module supports JSON output, can update local JSON TLE files, includes simple caching and rate‑throttling to avoid overloading remote APIs, and exposes metadata about the source and type of returned data. Be aware that a Space-Track account is required for many operations and some scraping-based features can be fragile or deprecated, for example AMSAT and legacy Iridium functionality are no longer reliable and some Space-Track favorites were removed. Recent maintenance added CelesTrak's new 'sar' catalog and EUMETSAT supplemental data and included an emergency update to adapt to Space-Track's newer gp/gp_history data classes.

Astro::App::Satpass2 is a Perl application and library for predicting satellite visibility and related events, either from an interactive satpass2 shell or programmatically by instantiating an object. It loads orbital elements (TLEs) and background objects, computes visible passes, flares, almanac items, positions and brightness estimates, and can format output via templates or export iCal; it also supports scripting, macros, and configurable time and geocoding services. Core functionality works out of the box but a few optional CPAN modules greatly expand its capabilities, for example Astro::SpaceTrack to fetch TLEs, Date::Manip for flexible time parsing, Geo::Coder::OSM for geocoding and a USGS elevation client for heights. The package is a modern, tested rewrite of the old satpass tool with most compatibility preserved and clear configuration via an init file, making it a good choice for amateur astronomers, satellite observers, and developers who need programmable, scriptable satellite pass predictions.

Test::Prereq::Meta is a testing helper for Perl distribution authors that checks whether the modules a distribution actually uses are declared in its CPAN meta files (META.* or MYMETA.*). It scans your distribution's Perl files to find use/require lines and then compares those discovered dependencies against the distribution's metadata and provided modules, letting you accept specific modules, treat core modules as covered for a chosen Perl version, and report unused prerequisites as well. The tool works without relying on a particular build system, integrates with Test::More, and offers both per-file and whole-distribution checks, but it uses static analysis so dynamically constructed require or eval'd module names may be missed and it requires Perl 5.10 or newer. Recent changes are purely administrative, updating contact and license packaging and removing references to the RT bug tracker, with no functional changes.

Cucumber::Messages is a Perl library that implements the standard Cucumber message protocol and provides typed classes for every message used in that protocol together with JSON/NDJSON serialization and deserialization. It gives you an in-memory representation of envelopes, pickles, test cases, steps, attachments and related objects so Perl tools can read, write and transform the same event streams other Cucumber components use. You would use it to build or integrate Perl-based formatters, reporters, runners or tooling that must exchange Cucumber messages, including support for large external attachments and timestamps. The module follows the canonical Cucumber messages spec and is available under the MIT license.

Backblaze::B2V4 is a lightweight Perl client for Backblaze B2's V4 API that makes it easy to create buckets and upload, download, list, and delete files from Perl code or from the bundled b2_client command line tool. It supports uploads from disk or from an in-memory scalar, a special path for large-file uploads (recommended for files over 100 MB), downloads by file name or by the B2 file GUID, bucket creation and deletion, listing and file metadata retrieval, and deleting specific file versions while returning B2 responses or file IDs as appropriate. You instantiate the client with your Backblaze application key and key ID and the module handles authorization token exchange and per-bucket upload info, and it exposes a send_request method if you need to call API methods not wrapped by the library. The installer can optionally test credentials by downloading a small file so store your keys securely, and if you prefer Backblaze’s S3-compatible API you may instead use generic S3 clients, but this module is focused on the native B2 API; recent updates improved the documentation and added a convenience current_status_is_ok method.

Map::Tube::CLI is a simple command-line frontend for the Map::Tube family that exposes map data and routing via the supplied map-tube script. It makes it easy to ask for shortest or preferred routes between stations, print results as plain lists or neat tables, enumerate supported maps, lines, or stations, and produce PNG images of entire maps or single lines with a selectable background color. The tool supports many city metro maps out of the box, accepts local or experimental maps with a force option, and offers conveniences like line mappings, line notes, debug output, and short and long command switches. If you need quick terminal access to transit routing or want to generate visual map output from Map::Tube data this module is a practical choice. The latest release adds short option aliases, a --version flag, explicit list options, improved Unicode-aware sorting, and better handling of non-printable characters.

Map::Tube::Exception is a small Moo role that centralizes and standardizes the error conditions used across the Map::Tube family of modules so they all throw the same named exceptions for problems like missing or invalid station and line data, bad color or map formats, plugin or map discovery failures, and route lookup errors. It is intended for module authors and integrators who want consistent, machine-friendly error reporting from map and transit-related code rather than ad hoc die strings. The bundle exposes a comprehensive set of status codes for specific problems so callers can detect and handle precise failure modes programmatically. Recent updates added an explicit exception for a missing map specification and expanded the test coverage and documentation.

Test::Simple is a tiny, no-frills testing toolkit for Perl that lets you write TAP-compatible tests with a single primitive. You declare how many tests you plan to run then use ok to record pass or fail and output lines like "ok 1" or "not ok 2", and the module produces sensible exit codes so harnesses and CI can tell success from failure. It is intentionally minimal to get you started quickly and is fully forward compatible with Test::More when you need richer assertions and diagnostics. Test::Simple is mature and well maintained across many Perl versions, and recent work has modernized its internals to use the newer Test2 infrastructure and cleaned up packaging and test reporting so diagnostics and line numbers are more accurate.

Stats::LikeR brings a compact, R-like statistics toolkit into Perl by providing common summary and distribution functions, random generators, many hypothesis tests (t, chi-square, Fisher, Wilcoxon, KS, Shapiro, Kruskal), modeling tools (lm, glm, aov), PCA and matrix utilities, and convenient table I/O and reshaping helpers such as read_table, write_table, filter, group_by, hoh2hoa, col2col, add_data, ljoin, and transpose. It accepts familiar data shapes like array‑of‑hashes, hash‑of‑arrays and hash‑of‑hashes, returns structured Perl hashrefs that mirror R outputs, and is implemented with XS for speed so it is useful when you want R-style analysis directly in Perl without external dependencies. The module aims to match R semantics including formula syntax and handles many edge cases, though some routines assume normality, several functions will die when given undefined values by default, cor fails on zero variance, and the KS p‑value precision is modest. If you are a Perl developer doing exploratory data analysis, statistical testing or table manipulation and prefer staying in Perl for performance and portability, this module is likely to be relevant and helpful.

Data::HashMap::Shared is a high-performance, Linux-only Perl module that provides file-backed, memory-mapped hash maps for sharing typed keys and values between processes on 64-bit Perl. It offers many tuned features for concurrent use including a fast lock-free read path, futex-based writer locks, atomic increment/decrement and compare-and-swap for integer maps, optional LRU eviction and per-key TTLs, an arena for string storage, and a keyword XS API for top speed. The distribution includes multiple type-specialized variants for integer-to-integer, string-to-string and mixed maps, supports memfd and sharded maps for parallelism, and exposes iteration, batch operations, diagnostics and explicit sync/unlink controls. Be aware that integer variants store fixed-width two's-complement values and silently truncate out-of-range numbers, TTL and LRU behavior is configured at creation time, and crash recovery uses PID liveness checks so sharing across different PID namespaces is not supported. The author documents robust stale-lock recovery and automatic resizing, but warns that a writer crash can leave a single entry with partial bytes and recommends a clear after recovery for safety-critical uses.

GD is the canonical Perl interface to the libgd graphics library that lets you create, modify and export bitmap images from Perl scripts without needing a full graphics application. It provides core classes like GD::Image for pixel-level drawing and copying, GD::Font for bitmap fonts, GD::Polygon for shape building and GD::Simple for a higher-level, easier API, and it can read and write a wide range of formats including PNG, JPEG, GIF and newer types such as WEBP, HEIF and AVIF when libgd supports them. You can draw primitives, text with TrueType support, filled shapes, brushes and styled lines, apply filters and interpolation, work with alpha transparency and tiled patterns, and build animated GIFs or do scaled and rotated copies for thumbnails or transformations. If you write server side image generators, charting scripts, simple image editors or automated thumbnailers in Perl, GD gives a compact, well tested toolset to do that. This is a mature module with ongoing fixes and format autodetection improvements, and the recent 2.86 release includes an important security patch addressing a command injection issue in a two-argument open call.

Novel::Robot is a small Perl toolkit for automating the collection, cleanup, and packaging of serialized web fiction; it gives you a Browser component to fetch chapters from web sites, a Parser to extract and sanitize chapter content, and a Packer to assemble those chapters into distributable files such as plain text or e-book packages. The suite is geared toward developers who need predictable, programmatic control to gather multi-chapter novels from the web and convert them into single readable outputs. If you want to automate scraping and conversion of online fiction rather than read it manually, this module set is directly relevant.

NetAddr::MAC is a small library for parsing, validating, formatting and manipulating hardware MAC addresses with both an object oriented API and a set of simple functional helpers. It understands EUI‑48 and EUI‑64 forms, accepts many common input styles, and can normalize addresses into Cisco, IEEE, Microsoft, PostgreSQL, Token Ring and other vendor formats or produce the IPv6 autoconfiguration suffix. You can query address properties such as unicast, multicast, broadcast, locally versus universally administered, VRRP and HSRP patterns, convert between EUI‑48 and EUI‑64, and generate random addresses from a given OUI or prefix. Error handling defaults to returning undef with an accessible error string but can be configured to croak instead. The module deliberately omits vendor OUI lookups so use Net::MAC::Vendor for that task. This is a practical utility for network scripts and tools that need reliable MAC address parsing and formatting.

IP::Country::DB_File is a lightweight Perl module that maps IPv4 and IPv6 addresses to country codes by looking them up in a local Berkeley DB file. You build the database first with the included builder or the build_ipcc.pl script which compiles regional internet registry statistics into the DB and now fetches those files via HTTPS. Lookups are fast and done in pure Perl so the runtime has minimal dependencies and Math::Int64 is only needed when building IPv6 databases. The module mirrors the familiar IP::Country API and provides methods like inet_atocc and inet6_atocc as well as packed-address variants. Results are typically ISO‑3166 two-letter codes with a few generic codes like EU or AP, private ranges return "**", and failures return undef. This is a good fit if you want an offline, dependency-light, reasonably accurate IP-to-country solution without relying on third-party services.

IPC::Shareable lets you tie Perl variables to System V shared memory so multiple processes can share the same scalar, array, hash or complex data structure with minimal fuss. By default it serializes data as JSON for cross-language interoperability and portability, with Storable as an option when you need Perl-specific features like blessed objects, and it will automatically use JSON::XS if available for much better speed. Nested references are stored in separate child segments so deeply nested structures work naturally, but that increases the number of OS shared-memory segments and semaphores used so you should be aware of system limits. The module exposes lock and unlock methods and optional enforcement and warning flags to protect against concurrent read and write races while still relying on advisory locking among cooperating processes. It also includes conveniences such as a singleton helper to prevent multiple script instances, tools to inspect segments and semaphores, and targeted cleanup and testing helpers to remove orphaned segments left by crashed runs. Note that locks are inherited across forked children and that automatic segment destruction runs only on clean exits so you may need signal handlers when using the destroy option. If you need to share configuration or runtime state between Perl programs or across languages, IPC::Shareable gives you a pragmatic, feature rich way to do it while surfacing useful diagnostics and cleanup controls.

SPVM is a compact, statically typed language that uses a Perl-like syntax and is aimed at high performance and easy integration with existing Perl and C/C++ code. You can run short programs with the spvm command, compile scripts into standalone binaries or libraries with spvmcc, and call SPVM methods directly from Perl using the SPVM module, so SPVM is useful both for standalone apps and for embedding fast components in Perl programs. The language offers static types with inference and analysis, ahead-of-time and just-in-time compilation, native threading and coroutine-style goroutines, a resource and builder system to produce and link native code, and hooks to bind C and C++ libraries. Development is active and the distribution includes examples, a tutorial and a builder toolchain for producing executables and extension libraries. Note that SPVM has not reached a stable 1.0 release and the project does not guarantee backward compatibility between releases. A recent notable improvement added a group of native C function APIs such as getenv, setenv, malloc, free and localtime to make native bindings and platform interoperability more complete.

List::Search is a compact Perl utility for very fast lookups in sorted arrays, using a binary search to return the index of the first element equal to or greater than a given key and -1 when there is no match. It provides string, numeric and custom-comparator entry points so you can search lists sorted with cmp, <=> or any user supplied comparison routine, and it also offers convenience functions that just test membership. The module is ideal when you keep data in sorted order and need either quick membership checks or the correct insertion point without scanning the whole list. Recent maintenance moved the source to Codeberg and fixed packaging and export issues while ensuring the contains helpers reliably return false on misses, so the module remains small, well tested and easy to drop into existing Perl scripts.

Sub::Protected provides Java/C++ style protected access control for Perl subs so you can mark helper methods as callable only from their defining package or from subclasses. You enable it by adding the :Protected attribute to a subroutine or by listing sub names in use Sub::Protected qw(...), and the module wraps those subs at CHECK time so out-of-scope calls croak with a clear error. It offers test-friendly bypasses via $Sub::Protected::BYPASS or the HARNESS_ACTIVE convention and has a simple runtime configuration hash for disabling the harness bypass. Note that enforcement is runtime only, a raw coderef captured before wrapping can bypass the check, applying method modifiers afterwards may wrap the wrapper, the attribute is installed in UNIVERSAL so it affects the global namespace, and the implementation uses unguarded package globals so concurrent use across threads is not recommended.

Log::Abstraction is a compact logging layer for Perl that gives you a single, familiar API with standard levels like trace, debug, info, notice, warn and error/fatal while letting you send messages to many different backends such as code references, arrays, files or file descriptors, syslog, or a built‑in sendmail helper for alert emails. You configure it via constructor arguments, a config file or environment variables and can customize output with a format string that expands tokens like timestamp, level, message and environment values. The object keeps a per‑instance history of emitted messages, supports cloning with overrides and method chaining, and falls back to initializing Log::Log4perl when no backend is supplied. Options let you escalate warn and error to Carp carp or croak behavior and the sendmail backend supports rate limiting so you do not flood recipients. The module is GPL2 licensed, provided as‑is without warranty, and is handy whenever you need a flexible, backend‑agnostic logging solution for Perl applications.

Strada is a Perl interface for loading and calling functions compiled into Strada shared libraries so you can call native Strada code from Perl with minimal friction. It provides both a low level handle-and-function API and a higher level Strada::Library object that loads a .so, lists and describes exported functions, reports the library version, and calls functions by name using either C-style or package::function syntax. Common Strada types map automatically to Perl scalars and references so ints, numbers, strings, arrays, hashes and undef convert back and forth, and variadic functions are supported by passing an array reference. Argument limits are removed when built with libffi otherwise calls are limited to four arguments. The module requires the Strada runtime headers and Perl development headers to build and is distributed under GPLv2.

Geo::Address::Formatter converts a structured postal address (a Perl hash of components) into a readable, correctly ordered multiline address for the appropriate country using community-maintained templates. You supply a configuration path to the OpenCage address-formatting templates and then call format_address with your components and options such as country override, language-aware abbreviations, a custom template, or an only_address mode to omit non-address POI text. The module also provides instance creation for reuse in long-running processes and a final_components method to inspect the cleaned and normalized components produced during formatting. It is designed to handle the quirks of 200+ countries and comes with extensive test coverage via the templates repository at GitHub. The most recent updates bump required versions of Text::Hogan, Clone, and YAML::LibYAML for compatibility and earlier releases added speed improvements and a reusable instance method.

Atomic::Pipe is a Perl utility that guarantees whole, non-mangled messages when multiple processes or threads write into the same POSIX pipe. It breaks each message into PIPE_BUF-sized atomic chunks with a small header so readers can reassemble complete messages even when writers interleave, and it provides simple methods like pair(), write_message(), and read_message() for common use. There is a mixed-data mode that lets you mix ordinary stdout/stderr text with inline atomic bursts so you can extract structured payloads from noisy output, but it relies on three control characters so printing arbitrary binary data that includes those codes can confuse the parser. The module can also transparently compress messages and bursts with Zstandard to reduce wire size and often speed up large-message workloads, and it supports custom dictionaries and options for blocking, nonblocking, buffering, and pipe buffer resizing. It only works on POSIX-compliant pipes and platforms, and Zstd support is optional via Compress::Zstd and requires both ends to agree on settings. If you need robust inter-process message boundaries across multiple writers or want to embed atomic payloads inside normal output streams, Atomic::Pipe is a convenient, battle-tested solution.