CPANscan

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.

Text::Hogan is a Perl implementation of the Mustache templating engine that is a statement-for-statement port of Twitter's hogan.js. It lets you compile Mustache templates into pure Perl code so templates render very quickly while remaining fully compliant with the Mustache specification. You work with a Compiler to produce Template objects and then render those templates against your data, making this a good fit for Perl projects that need portable, fast, and hogan.js-compatible templating.

Tvh::Htsp::Client is a compact Perl library for talking to a Tvheadend server over its HTSP protocol, intended for scripts that need to query channels, control the server, or extract the electronic program guide. It provides a simple constructor and methods to send and receive HTSP messages and to call Tvheadend's JSON API through HTSP, plus helpers to look up channel names and IDs so you can easily build queries or map results back to channels. The module also includes a raw deserialization routine that can decode HTSP message blobs and can be used to unpack epgdb.v3 dumps, which makes it handy for exporting EPG data to JSON. Recent releases added a channel UUID/ID lookup and the htsmsg_deserialise method to simplify parsing stored or streamed HTSP data. If you need to integrate Tvheadend into Perl tools or automate EPG and channel access, this module provides a straightforward, ready-to-use client.

Catalyst::Plugin::Authorization::ACL adds simple, path-oriented ACL support to Catalyst applications by letting you attach allow and deny rules to private action paths. You can express rules as role lists (when used with Catalyst::Plugin::Authorization::Roles), predicate subs or methods, or constant true/false, and there is also a flexible rule API that can use exceptions to explicitly allow or deny. Rules are checked from the most specific path outward and short circuit when a rule explicitly permits or blocks access, otherwise access is allowed by default. Denials can be handled by providing a private access_denied action, by using the provided acl_access_denied and acl_access_allowed hooks, or by calling forcibly_allow_access from the handler to continue execution. If you need straightforward per-path access control integrated into Catalyst private namespaces this module is a light, well maintained option and recent releases added convenience helpers for role-any checks and routine maintenance fixes.

Dist::Zilla::Plugin::GenerateFile::FromShareDir is a Dist::Zilla plugin that creates files in your distribution or repository from Text::Template templates stored in another distribution's sharedir. You give it the source template name and a destination filename, choose whether the generated file goes into the build or directly into the repo, and any extra configuration keys are passed into the template alongside handy objects like $zilla and $plugin. It supports specifying the source encoding (defaults to UTF-8) and lets you control when repository writes happen with a phase option. This is handy when you want bundles or other reusable dists to provide ready-made templates for multiple projects; if your template lives only in the current dist you can instead use GatherDir::Template or GenerateFile. The most recent release made a documentation fix to the -dist option.

Database::Abstraction is a lightweight, read-only ORM-like layer for Perl that lets you access CSV, PSV, XML, SQLite and BerkeleyDB data without writing SQL by providing a single, consistent API for fetching rows, columns and counts. You typically subclass it per dataset and then call methods such as fetchrow_hashref, selectall_arrayref or use the AUTOLOAD feature to retrieve a column by name, and it includes configurable caching, flexible logging and a "slurp" mode that keeps small files in memory for speed. It is useful when you need to switch underlying storage formats without changing application logic or when you want simple, read-heavy data access with minimal code. A few legacy quirks remain to be aware of, notably the default CSV delimiter is '!' rather than ',' and the module uses an "entry" column name by default, and XML slurping can be fragile on some files, but recent maintenance continues to improve reliability. The latest release fixed path handling for safer file opens and addressed a DBD::File safety check by canonicalizing directory paths.

HTTP::Tiny is a small, dependency-light HTTP/1.1 client for Perl that makes simple web requests without the overhead of a full user-agent like LWP::UserAgent. It supplies convenient methods for GET/POST/PUT/HEAD/PATCH/DELETE requests, a post_form helper, mirror for saving responses to files, streaming data callbacks, proxy and cookie-jar support, connection keep-alive and timeouts, and basic HTTPS when IO::Socket::SSL and Net::SSLeay are available. The module focuses on correct transport behavior and safe defaults, including TLS certificate verification turned on by default and recent security hardening that strips caller-supplied Authorization, Cookie and Proxy-Authorization headers on cross-origin redirects and prevents automatic https-to-http downgrades unless explicitly allowed. HTTP::Tiny is ideal when you need a reliable, simple HTTP client for scripting and small programs but not a full-featured browser emulator, and callers are expected to provide properly escaped URLs and handle higher-level features themselves.