CPANscan

IO::Compress is the umbrella Perl distribution for reading and writing compressed data in many common formats. The file shown here is a stub with no code, but the IO::Compress family (for example IO::Compress::Gzip, ::Zip, ::Bzip2 and the matching IO::Uncompress::* modules) provides simple procedural and object interfaces for compressing and uncompressing streams, files and in-memory buffers, with support for streaming operation, automatic format detection, Zip features like Zip64 and extra fields, and a wide set of compression back ends including gzip, bzip2, lzma/xz and zstd. The distribution is actively maintained by Paul Marquess and recent updates (June 2026) include refreshed zip metadata tooling and portability improvements such as better EBCDIC handling and wildcard fixes. If you need robust, cross-format compression support in Perl, the IO::Compress modules are the ones to use.

App::zipdetails supplies a simple command line utility for inspecting the internal structure of ZIP archives, letting you peek at headers, directory entries, compression methods, stored sizes and offsets so you can debug, verify or learn about how a ZIP file is laid out. The CPAN distribution primarily provides a stub module that installs the zipdetails script, so consult the bin/zipdetails script for usage and options if you want to run it.

Mojolicious::Plugin::Fondation::Model::DBIx::Async is a Fondation plugin that gives Mojolicious apps native, nonblocking access to DBIx::Class via DBIx::Class::Async so you can run DBIC queries without blocking the event loop. You configure one or more backends (each with a DSN and schema class) and named models that map to table sources, and the plugin exposes simple helpers like schema_class, schema and model to get async DBIC ResultSet objects that return Future objects for queries and DML. Workers are forked into a background pool per backend on first use so the web process stays responsive, Result and ResultSet classes from plugins are auto-registered, and shutdown triggers graceful disconnects of worker pools. Note that async calls return Future chains and you should call ->retain to avoid premature garbage collection of the promise. This initial release provides the schema, schema_class and model helpers and the basic backend and model plumbing to integrate DBIx::Class::Async into Fondation-based Mojolicious apps.

Pod::Coverage::TrustMe checks that the functions and methods a Perl package provides are documented and extends the familiar Pod::Coverage workflow with practical extras for real projects. It lets you mark subs as private with regexes or literal names, explicitly trust individual methods as documented even without POD, pull documentation coverage from parent classes, roles, or other packages, honor in-POD Pod::Coverage lists, require nonempty documentation sections, restrict checks to exported symbols, and ignore imported subs so helper imports do not force you to document them. The module reports coverage as a percentage, lists covered and uncovered symbols, and can produce human readable reports for tests or CI. It uses Pod::Simple instead of the old Pod::Parser, avoids providing an import hook, and is designed to be subclassed for custom symbol or POD discovery. If you run documentation coverage checks in your test suite or want stricter control over what counts as documented API, this module is a drop-in, more flexible replacement for Pod::Coverage. A recent maintenance update fixed option forwarding when using all_pod_coverage_ok in test harnesses.

Amazon::API is a lightweight, generic Perl base class that makes it possible to call AWS services without a full SDK. You can use it directly as a DIY gateway, subclass it with a small list of methods, or generate complete, documented service classes and data shape serializers from Botocore metadata using the included amazon-api tool. It handles signing, multiple content types and protocols, credential discovery via Amazon::Credentials, automatic pagination for Botocore-based calls, and optional response decoding so you normally get Perl data structures rather than raw XML or JSON. The module favors small deployments and targeted use of single services and will return raw responses instead of failing when serialization has edge-case problems unless you enable stricter error behavior. It is not a drop-in replacement for a full SDK like Paws and some services such as S3 are better served by dedicated modules, but if you want a simple, scriptable way to call only the APIs you need this module is a good fit. Recent updates added a --localstack option and improved Botocore serialization and response unwrapping, and the latest 2.2.4 release fixed URL encoding for the top-level Version key in query content.

DateTime::Fiction::JRRTolkien::Shire is a DateTime-compatible Perl calendar class that models the hobbits' Shire calendar from Tolkien's Lord of the Rings, letting you represent dates with twelve 30-day months plus the five special holidays and a sixth holiday in leap years. It plugs into the DateTime ecosystem so you can construct dates from epochs or other DateTime objects, compare and stringify them, do date math with a custom Shire duration class, format with a Shire-aware strftime, and retrieve week, quarter, holiday and day-of-week information while handling Shire-specific rules such as Midyear's Day falling outside any week. The module intentionally uses a Gregorian-style leap-year rule to keep years aligned with our calendar and preserves time and locale attributes for conversion to other calendars, though format_cldr() is not implemented. Recent maintenance improved documentation, tests and metadata and added CONTRIBUTING and SECURITY files along with small fixes and examples.

Date::Tolkien::Shire is an object oriented Perl module that converts standard epoch or calendar dates into J.R.R. Tolkien's Shire Calendar and gives you friendly ways to inspect and format them. You can build a Shire date from epoch seconds or from Shire year/month/day or holiday values, convert back to epoch midnight, query the Shire year, month, day, holiday and weekday using either modern or traditional names, and compare dates with normal numeric and string operators. It includes a strftime-like formatter and an on_date method that returns themed historical events from The Lord of the Rings, plus options for accented or traditional output. The module intentionally matches modern leap year rules so common dates map sensibly across eras, and its methods favor safe error reporting rather than dying on failure. Note that because it currently relies on epoch time it may be limited by your system's epoch range, which can restrict very old or very future dates on some platforms.

Date::Tolkien::Shire::Data provides the core utilities for handling J.R.R. Tolkien's Shire calendar and is the shared implementation used by Date::Tolkien::Shire and DateTime::Fiction::JRRTolkien::Shire. It models a calendar of twelve 30-day months plus five or six intercalary holidays, including two days that are not part of any week, and supplies routines to convert between month/day, day-of-year and Rata Die, compute leap years, weekday and week numbers, quarters, and to translate month and holiday names and abbreviations. The module also offers a rich strftime-style formatter extended with %E patterns and padding flags to produce Shire-specific names and holiday-aware output, plus lookup and search functions that return the Appendix B event text for particular dates. It is subroutine-based, provides export tags and manifest constants for common holiday identifiers, and is intended mainly as a shared backend for the higher-level modules rather than as a standalone interface. Support comes from the author and bug reports are handled on the project GitHub.

Perl::Critic::Policy::Misc::ProhibitMethodsInStringConcat is a lint rule for Perl that flags method calls used directly inside string concatenation with the "." operator because if a method returns undef Perl's warning does not identify which call produced the undef, making the resulting bug difficult to track down. It encourages you to assign method results to named scalars first or to use sprintf/printf so diagnostics can point to a specific variable or keep template and values separate. The policy also digs into parenthesized subexpressions and will flag inner concatenations used with ".=" when they include method calls while allowing a single method as the sole right-hand operand of ".=". There are no configuration options for this policy.

Data::URIID is a helper for turning a URL, QR code payload, barcode or similar object into the identifiers and human-friendly metadata you need to display, link or integrate that resource in your application. You create an extractor, call lookup on a URI or supported object and get back a Data::URIID::Result that can provide canonical IDs, display names, icons, thumbnails and other attributes. The extractor supports both offline and optional online lookups, configurable user agent and preferred language tags, and accepts many input types including Data::Identifier objects and tag or file wrappers. It knows about a wide range of services (see Data::URIID::Service) and exposes utilities to map between well known names and ISE identifiers. Recent releases added wider identifier coverage and new service support including Denkxweb and initial ni:// URL handling, plus ongoing updates to the registry of known IDs. This module is useful if your app needs reliable, consistent identifiers or user-facing metadata extracted from URIs or codes.

Crypt::OpenPGP is a pure-Perl implementation of the OpenPGP standard that lets Perl programs create and verify digital signatures, encrypt and decrypt messages, manage keyrings, and even generate key pairs without needing an external gpg binary. It exposes a simple high level API with methods such as new, encrypt, decrypt, sign, verify and handle, supports detached and cleartext signatures as well as ASCII armour, and offers compatibility modes for older PGP versions and GnuPG so you can interoperate with other implementations. The module supports common public key types and ciphers including RSA, DSA, ElGamal, 3DES, Blowfish, IDEA, Twofish, CAST5 and AES, plus MD5, SHA1 and RIPEMD160 digests and ZIP and Zlib compression, and provides features like MDC protection, passphrase callbacks, recipient callbacks and optional automatic key retrieval from an HKP keyserver. It requires a secure random source such as Bytes::Random::Secure or Crypt::Random and reports errors via errstr, and note that the key generation interface is labelled alpha. If you need to add OpenPGP capabilities directly inside Perl code or a web application, this module gives a comprehensive, portable toolkit.

Log::Report is a unified Perl framework for producing, routing and translating program messages so you can treat logging, exceptions and internationalization as one coherent system. It provides convenient message constructors like __, __x and __n that build lazily translated, interpolated message objects, a set of reasoned report levels such as trace, info, warning, error and fault, and a dispatcher system that sends each report to one or more back ends such as files, syslog or other logging frameworks with configurable modes like DEBUG or NORMAL. You can throw exceptions with familiar short helpers like error() and fault(), capture and inspect them with try(), and selectively control what gets processed with filters and the needs() test to avoid expensive work when unnecessary. Because translations are postponed until dispatch time, the same report can be logged in one language and shown to the user in another. The module also supports a lightweight Optional mode for low-overhead use inside libraries and offers domain-based configuration and tools to manage translation catalogs, making it a good fit for applications that need flexible routing, structured report reasons and multilingual output.

CallBackery is a Mojolicious-based framework for quickly building appliance-style web frontends that pair a Perl backend with a Qooxdoo JavaScript client. It provides ready-to-use wiring for configuration (default etc/callbackery.cfg or overridden via CALLBACKERY_CONF), a pluggable database object, RPC service namespace and controller, and application-wide security headers, and exposes a startup hook that mounts the Mojolicious app and routes. Use it when you want to deliver a rich single-page management UI driven by Perl without building the plumbing yourself. Note: a recent release switched the RPC layer to JSON-RPC 2.0, so you must use Qooxdoo 7.x and the matching Mojolicious::Plugin::Qooxdoo update and upgrade frontend and backend together.

Chemistry::OpenSMILES is a Perl toolkit for reading and writing SMILES chemical identifiers that follows the OpenSMILES v1.0 specification and is aimed at developers who need to convert SMILES strings into manipulable molecular graphs or produce SMILES from graph data. Its parser turns SMILES into Graph::Undirected objects where each atom is a Perl hash with fields for element, isotope, charge, hydrogen count, chirality and position, and its writer converts those graphs back to SMILES with a range of options to control hydrogen, aromatic and parentheses output. The module handles disconnected moieties, ring and cis/trans stereo, a variety of chiral types, valence calculations and aromaticity checks, and recent releases added explicit ring-detection utilities including rings() and can_be_aromatic_ring() to improve aromaticity handling. If you need a configurable, OpenSMILES-compliant SMILES reader/writer in Perl for cheminformatics tasks, this module provides a ready-to-use, well-evolved implementation.

Template::Sluz is a minimal Perl templating engine with a Smarty-like syntax that makes it easy to separate presentation from code in small to medium Perl projects. You instantiate it, assign scalars, arrays or hashes, and render templates from files with fetch or from strings with parse_string. The template language supports variable interpolation, chained modifiers and default values, if/elseif/else conditionals, foreach loops, include files, literal blocks and comments. A convenient feature is that any Perl built-in or user function can be used as a modifier so templates can call functions like ucfirst, join or substr with the template variable passed as the first argument. Its simple API and lightweight design suit cases where you want straightforward templating without a heavy framework.

CPAN::MetaPackager is a small utility for building and managing a local SQLite mirror of the CPAN package index, cpan.metapackager.sqlite, by converting the canonical CPAN package-list file (02packages.details.txt.gz) into a searchable SQL database. It is useful if you need a local, machine-friendly copy of CPAN metadata for offline querying, custom tooling, packaging workflows, or fast lookups without hitting the network for every query. The module is maintained by Ron Savage under the Perl 5 license and is production-ready at version 1.00 and above. Recent releases make it easier to keep the database current by downloading the latest 02packages.details.txt.gz and rebuilding the DB automatically, and include clearer instructions and timing information during import to help you monitor updates.

CPAN::MetaCurator is a toolkit for building, inspecting and exporting a local SQLite database of CPAN metadata derived from Perl.Wiki and related sources, with utilities to turn that data into a jsTree-style HTML site map and other reports. It bundles modules and command-line scripts to import 02packages.details.txt or CPAN::MetaPackager databases, gather and validate module and topic statistics, search for module names, and produce web-ready exports with clickable nodes and hover text. The project is aimed at maintainers who want to curate, rebuild or publish a browsable Perl module catalogue and includes validation and parsing helpers to keep the tree accurate. The latest release rebuilt the database and rewrote the usage instructions in MetaCurator.pm to simplify rebuilding and exporting workflows.

Test::MockModule lets you temporarily override subroutines in other Perl packages so you can stub or fake behavior during unit tests. It records the original routines and restores them automatically when the mock objects go out of scope or when you call unmock, which makes cleanup simple and reliable. You can use mock to replace functions with code refs or scalars, redefine to assert the function already exists, define to assert it does not, and original or original_for to call the real implementation from inside a mock. The module also offers convenience helpers such as noop to install harmless methods that return true and mock_all to catch unexpected calls, and it supports lexical strict and global-strict modes to avoid masking interface changes. It integrates with Moose and Mouse metaobjects so mocked methods participate in MOP checks but does not special-case Moo or Role::Tiny and will warn if the target class is immutable. If you need to fake exported functions, remember to mock them in the importing package or use fully qualified names to get the effect you expect.

Git::Server is a drop-in replacement for a standard Git server that adds powerful, server-side control features so teams can run secure, policy-driven repositories without adopting a heavy platform. It gives fine-grained ACLs and hooks so you can restrict who can push, who can rewrite history, which files can be changed, and even whitelist IPs or author emails, while providing tools like a git-client wrapper and git-deploy to automate pushes and deployments. The module also supports flexible webhook callbacks, proxying/sync to external remotes, access logging and rotation, and a variety of deployment and compatibility fixes for older Git and non-Linux systems. Recent updates focus on reliability and operational load, running webhooks serially and retrying failed callbacks, plus improvements to the client/deploy shims and proxy sync behavior. The project is actively maintained on GitHub and is intended to be an easy replacement for ssh-based Git hosting when you need stronger hooks and access control.

Map::Metro::Plugin::Map::Berlin is a small plugin for the Map::Metro Perl toolkit that provides a ready-made model of Berlin's transit network. It returns a parsed graph of stations and links encompassing both the U-Bahn and S-Bahn so you can perform route finding, visualization, or scripting without assembling the network data yourself. Use it via Map::Metro->new('Berlin')->parse or the map-metro.pl command line and it integrates with the rest of the Map::Metro ecosystem.

Map::Tube::Berlin is a lightweight Perl module that gives you a programmatic way to query Berlin's S‑ and U‑Bahn network. You create a Map::Tube::Berlin object and call get_shortest_route with a start and end station name to get back the sequence of stations along the shortest path. Station names are case insensitive and the map includes both U‑ and S‑Bahn stops. The route data comes from an XML file generated from BBBike project data and a Makefile rule is provided to rebuild the map if you have a local BBBike copy.

Business::GoCardless is the top-level Perl library for talking to the GoCardless payments API, providing a collection of modules that let your app create and manage resources like payments, payouts, mandates, redirect flows and merchants while handling lower-level concerns such as webhooks, signature checking, nonce management and parameter normalization. You normally start with Business::GoCardless::Pro rather than using this module directly. The distribution aims to mirror the GoCardless API so you can work with bills, payouts, payments and related objects, and it includes conveniences and bug fixes around JSON encoding, legacy webhook handling and API compatibility. It does not implement partner account handling yet. The recent 0.45 release adds richer Mandate support including a mandate_type attribute, helper methods for common mandate kinds, new attributes for authorisation_source and next possible ACH charge date, and additional mandate status checks such as consumed, blocked and suspended_by_payer.

File::Symlink::Relative is a small Perl module that makes it easy to create relative symbolic links by converting a given source path into a path relative to the link location and then calling Perl's symlink built-in. It exports a symlink_r function by default and provides a SYMLINK_SUPPORTED constant so you can detect whether the current platform supports symlinks. The module will still install on systems without symlink support but will throw an exception when you attempt to create a link. Use it when you want a simple, tested helper to produce relative symlinks without writing your own path manipulation code.

Encode::RAD50 is a small Perl Encode module that converts strings to and from the vintage RAD50 character set used on PDP-11 systems such as RSX‑11, RT‑11 and RSTS. It implements Encode-compatible encode and decode operations and a PerlIO encoding layer so you can pack and unpack RAD50 data streams, where three limited characters (uppercase letters, digits, space, period and dollar) are squeezed into two bytes and invalid characters are represented by a substitution marker. The module pads inputs that are not a multiple of three with trailing spaces and will emit warnings about invalid input unless you explicitly silence them for testing, and because RAD50 is nonstandard you must explicitly load Encode::RAD50 before use. The test suite has been exercised across multiple platforms and the author maintains support via GitHub, and the most recent release (0.019) updated bug tracker and contact metadata and repackaged license files without changing functionality.

Date::ManipX::Almanac extends the Date::Manip family with almanac-style date and time operations so you can ask about events like sunrise, full moon, or when a planet sets. It currently implements date-level features through Date::ManipX::Almanac::Date and serves as the top-level module in the almanac hierarchy while remaining a subclass of Date::Manip so code can test for DM5 or DM6 compatibility via isa. Recent releases were maintenance-focused, improving licensing and GitHub packaging, adding a SECURITY policy and CI workflows, and updating contact information without changing functionality. If you need astronomical event times integrated with Date::Manip, this module is relevant and issues can be reported on the project's GitHub page.

Lingua::famibeib is the top-level Perl interface for working with famibeib, an artificial language, providing a simple entry point into the family of modules that handle parsing and manipulation. It delegates concrete tasks to companion modules like Lingua::famibeib::Text for text handling and parsing, Lingua::famibeib::Sentence for sentence-level actions, and Lingua::famibeib::Word for word-level operations, and it inherits behavior from Data::Identifier::Interface::Known. Use this module if you need to parse, analyze, or generate famibeib content from Perl code and want a convenient hub that connects to the higher-level components you will actually use.

Test::MixedScripts helps you catch potentially malicious or confusing Unicode in source and text files by checking that the characters used belong only to an expected set of Unicode scripts. It provides file_scripts_ok to validate a specific file and all_perl_files_scripts_ok to scan the Perl files in a distribution, defaulting to Common and Latin but allowing overrides per file, per line with a special comment, or for larger sections via a POD directive. The module reports the unexpected script together with the character name and the exact file, line and character position to make fixes straightforward. It can also be asked to enforce strict ASCII and will skip or warn when asked to test scripts not supported by your Perl build. This requires Perl 5.16 or later and does not try to detect confusable characters that come from the same script. The project is maintained on GitHub and recent releases added ASCII testing and a number of documentation and test-suite improvements.

SPVM::Sys is a comprehensive, cross-platform system interface for SPVM that exposes POSIX-style operations for file I/O, directories and stat, sockets, time, process control, signals, environment variables and user/group queries, with many convenience methods that mirror Perl idioms like the -X file tests. It wraps low level calls such as open/read/write, sysopen/sysread/syswrite, socket/connect/accept, fork/exec/wait and utime while providing supporting classes for socket addresses, timeval/timespec, directory and file streams and more. Windows Unicode is handled automatically by converting between SPVM strings and UTF-16 filenames so you can use the same APIs on Windows and Unix, and the distribution includes utilities such as globbing, portable TCP keepalive configuration and environment manipulation. Recent updates added MSVC build support, improved Sys#glob for UTF-8 and Windows Unicode case folding, and enhanced set_tcp_keepalive with an optional interval parameter while fixing several Windows and memory bugs, so this is a good fit if you need low-level, portable system primitives from SPVM code.

Minion::Backend::mysql is a MySQL storage backend for the Minion job queue that plugs into Mojolicious apps and uses Mojo::mysql to persist jobs, schedules and worker state. It creates the necessary tables automatically via migrations and provides the full Minion API for enqueuing, dequeuing, retries, priorities, dependencies, scheduled jobs, worker registration and job metadata, so you can manage background tasks with familiar Minion primitives. The backend includes a prefetch cache to improve throughput when jobs are short and lets you tune cache size and expiry. It requires MySQL 5.6.5 or later and may need extra privileges when installing on MySQL 8 if binary logging is enabled, which can block the database migrations. If you use Minion with MySQL and Mojolicious this module is the ready-made connector to store and dispatch your background work.

Net::HTTP2::nghttp2 is a Perl XS wrapper around the mature nghttp2 C library that brings full HTTP/2 support to Perl programs, letting you build both clients and servers that use streams, header compression, server push, and flow-controlled streaming bodies. It exposes a session-based API with callbacks for headers, data, and stream events so you can handle requests and responses incrementally and implement features like large uploads, streaming downloads, and WebSocket bootstrapping over HTTP/2 (RFC 8441). The module requires the nghttp2 library to be installed and offers an available method to check that linkage, and users can simplify installation via Alien::nghttp2. It has been conformance tested against h2spec with a high pass rate and documents a few intentional, lenient behaviors inherited from nghttp2 that improve interoperability rather than strict RFC enforcement. If you need production-ready HTTP/2 primitives in Perl and are comfortable wiring socket or TLS I/O into a callback loop, this module gives you a direct, low-level bridge to a widely used C implementation.