CPANscan

This module bundle gives Perl programs a simple way to talk to the Aspose.Cells Cloud service by centralizing configuration and supplying a factory for API client objects. It provides a Configuration component for storing credentials and endpoint settings, an ApiFactory for creating configured API clients, and a Role that ties those pieces into your code so you can call Aspose.Cells Cloud operations from Perl without reimplementing authentication or client setup. Use it when you need to automate spreadsheet tasks in the cloud from Perl and want a ready-made integration layer.

Text::PO is a Perl library for reading, editing and writing GNU gettext PO and POT files, with companion Text::PO::MO for handling .mo binaries. It parses PO/POT files into object structures you can inspect and modify, then serialize back to valid PO text or export as JSON for use from JavaScript. The API provides convenient helpers such as as_hash, as_json and as_string, element-level operations like add_element and add_include, and higher-level sync and merge routines for reconciling files or updating targets. It understands standard PO metadata and plural forms, supports optional nonstandard include directives with recursive parsing and circular-include protection, and exposes controls for encoding, charset and recursion depth. The distribution also ships scripts and a small JavaScript helper to load exported JSON. Recent 1.0.0 changes improved plural handling and removed a non-thread-safe global to make gettext usage safer in threaded programs. If you need programmatic control of localization files from Perl without depending on external gettext tools, Text::PO is a practical choice.

Markdown::Parser is an object oriented Perl library that parses Markdown into a navigable document tree so you can programmatically inspect, modify, and re-render content. It supports strict Gruber Markdown or an extended mode compatible with PHP Markdown Extra and returns a Markdown::Parser::Document whose elements can be converted back to Markdown, to HTML, or to POD. The parser exposes hooks and options useful for real applications including a per-element callback, file parsing, table handling with an option to emit CSS Grid rules, footnotes, basic KaTeX delimiter support, email obfuscation options, and an import path from HTML objects. The recent 0.6.0 release added an encode_html_entities option to control whether HTML inside code blocks is encoded and updated dependencies. This module is a good fit if you need structured access to Markdown for conversion, custom rendering, or automated manipulation inside Perl programs.

HTML::Object is a Perl HTML parsing and manipulation toolkit that combines the speed of HTML::Parser's C engine with a safe, minimal-edit approach that only rewrites the parts of a document you change while preserving the rest exactly as found. It offers three use levels: a lightweight Element API for simple tasks, a full Web-API‑compatible DOM implementation for code that needs JavaScript-style document methods, and an XQuery layer that provides a jQuery-like interface for convenient DOM manipulation. The distribution ships a large set of classes mapped to the HTML spec and uses an external JSON tag dictionary so you can inspect tag metadata, parse from strings, files or URLs, and control UTF-8 handling. It can export global DOM helpers and XQuery-style functions for terse scripts, and supports options like fatal error handling and try/catch integration. If you need robust, Perl-native DOM work or want to port jQuery-style patterns into Perl, this module is a strong fit. The recent 0.6.1 update fixed a number of DOM and XQuery bugs and improved simple-query performance in XQuery.

DB::Object is an object oriented SQL API for Perl that wraps DBI to make building, preparing and running SQL easier and more readable. It gives you table and field objects so you can construct queries by chaining methods instead of hand‑writing SQL, supports common operations like select, insert, update and delete, and includes helpers for joins, aliases, JSON and datetime fields, RETURNING clauses and complex operators such as AND, OR, IN, ANY and ALL. You can connect via connection hash, URI or JSON config file and use drivers for PostgreSQL, MySQL, SQLite and others, manage transactions and last_insert_id, cache prepared queries and table metadata for speed, and even run asynchronous queries using Promise::Me. The module was created to avoid inheriting DBI directly and to give finer control over connections and statement formatting. It also documents a sensible caveat when using DBI cached connections together with begin_work because AutoCommit can be reset unexpectedly. If you want a higher level, chainable interface over DBI that keeps access to low level features and adds query caching, table introspection and convenience helpers, DB::Object is a relevant tool.

Cookie is a Perl object for creating and manipulating HTTP cookies in an RFC6265-compliant way, suitable for both simple session cookies and fully featured Set-Cookie headers. It provides easy setters and getters for name, value, domain, path, expires or max-age, secure, httpOnly and SameSite, integrates with DateTime for expiry handling, and stringifies to a proper header so you can print or send it directly. The module supports signing and encryption of cookie values for integrity and confidentiality, offers options for algorithm, key and IV, and exposes decrypt and is_valid helpers; these features rely on CryptX/Crypt::Cipher and related modules for performance. Cookie objects can be compared, converted to hash form for JSON, and managed alongside Cookie::Jar for server-side workflows. Methods return undef and set an error rather than dying on failure, and there are options to enforce strict name rules though SameSite values are not validated by the module. This module is useful for web developers who need robust, standards-aware cookie handling with optional cryptographic protection.

Module::Generic is a mature, catch-all base class for building Perl objects quickly that bundles a large collection of ready-made accessors, validators and helpers so you can expose properties and nested objects as methods without writing boilerplate. It gives you dynamic AUTOLOADed getters and setters, a create_class helper to generate classes and method types on the fly, rich typed setters for numbers, dates, UUIDs, files, IPs, arrays and nested object graphs, built-in error/exception handling that prefers returning error objects over dying, and convenient helpers for serialization, debugging and ANSI-coloured terminal output. The module is designed for performance and threaded use in normal workflows, and many operations have pure-Perl fallbacks so installation does not require a C toolchain. Noteworthy in the 1.3.0 release is an XS backend that accelerates a dozen frequently called utility routines for a measurable speedup while still falling back to the pure-Perl versions when the compiled library is not present. If you want a high-level foundation to speed development of consistent, feature-rich Perl classes and prefer a convention-over-boilerplate approach, Module::Generic is directly relevant, but be aware that some dynamic metaprogramming features such as runtime package symbol injection or on-the-fly class creation carry the usual caveats for multi-threaded environments.

Perinci::CmdLine is a Perl framework that helps you expose Rinci/Riap-described functions and services as command-line programs, automating argument parsing, help text, validation, and dispatch so you can avoid boilerplate when building CLIs. It ships multiple implementations such as Perinci::CmdLine::Plugin and Perinci::CmdLine::Inline and includes Perinci::CmdLine::Any to pick an appropriate backend for you, with older alternatives named Lite and Classic also available. If you work with the Rinci/Riap ecosystem and want a consistent, tested way to turn your function metadata into usable command-line tools, this module provides a practical, flexible solution.

Dist::Zilla::Plugin::InsertModulesList is a small Dist::Zilla plugin that automatically replaces a "# INSERT_MODULES_LIST" marker in your POD with a generated POD list of the modules in your distribution, making it easy to keep a distribution-level module index up to date. It scans for .pm and .pod files and emits an ordered or unordered list of L<> links, lets you exclude or include modules by name or regular expression, and supports forcing the list type with an "ordered" option. Recent releases added sorting by default and, in the latest 0.032, configuration flags to include or exclude .pm and .pod files individually, so you can tailor the generated list to your documentation needs.

Readonly::Values::Months is a tiny utility that provides read-only month constants and simple lookup tables so you do not have to hardcode month names or numbers in your scripts. It exports $JAN through $DEC for numeric month constants, a %months hash that maps case-insensitive month names to their numbers, arrays of full and three-letter month names, and a %month_names_to_short mapping (added in v0.03) for converting full names to abbreviations. The module is useful when you need stable, readable month constants or quick name/abbreviation lookups without pulling in larger date libraries. It is provided without warranty and uses a nonstandard licensing arrangement that limits personal single-user use under GPL2 and asks other users to contact the author for a licence.

Graphics::Framebuffer is a Perl library that lets you draw directly to a Linux console framebuffer, making it easy to build console graphics, simple GUIs, or media display utilities on devices like Raspberry Pi or VirtualBox without X. It exposes a straightforward API for pixels and primitives such as lines, circles, boxes and polygons, plus blitting, image loading and animation, TrueType text rendering via Imager, gradients, masks and a variety of draw modes like normal, XOR and alpha. The module can run in an emulation mode for offscreen testing, and it offers optional acceleration through the Imager library and compiled C helpers to improve performance on heavier tasks. It requires access to a framebuffer device and must be run on the real console, not inside X or Wayland, and it works best in 24/32 bit color modes while some proprietary GPU drivers may not be supported. If you need direct, software-driven framebuffer drawing from Perl for embedded or console-only applications, this module provides a complete and pragmatic toolkit.

Term::QRCode is a small Perl module that creates QR codes as plain text for display in a terminal. It offers a minimal object interface where new accepts optional parameters that are passed to Text::QRCode and plot($text) returns an ASCII/terminal-friendly representation of the QR code ready to print. It is useful for command line tools, scripts, or terminal UIs that need to present scannable QR codes without graphical output. The module is a thin wrapper around Text::QRCode, easy to drop into existing Perl programs, and is distributed under the same terms as Perl.

OpenAPI::Modern is a Perl toolkit for loading an OpenAPI v3.0, v3.1 or v3.2 document and validating HTTP requests and responses against that specification. It uses JSON::Schema::Modern for full JSON Schema evaluation and works directly with Mojolicious request and response objects or converts other common request/response types for best-effort validation. You construct it with your OpenAPI document or schema and an optional evaluator, then call validate_request or validate_response to get a detailed JSON::Schema::Modern::Result that lists validation errors and exact schema locations. The distribution bundles up-to-date metaschemas, supports draft2020-12 features and dialects, and includes guidance for caching large documents to speed startup. A few OpenAPI features are not yet implemented or are limited, for example cookie parameters, multipart and application/x-www-form-urlencoded bodies, some query styles, and automatic enforcement of security schemes, and parsing works most reliably when messages are provided as Mojolicious objects. If you need programmatic conformance checks between your HTTP traffic and an OpenAPI description in a Perl app or test suite, this module is a practical and standards-aware choice.

Hades::Realm::OO is a plugin for the Hades code-generation framework that provides a ready-made object-orientation realm. It exposes builders and helpers for creating classes and roles, generating constructors and inheritance, and emitting familiar OO keywords such as has, extends, with and requires. The module also produces attribute accessors with support for defaults, coercions, triggers and predicates and wires up method modifiers like before, after and around. You would use it when extending Hades or authoring a Hades-based language to translate high-level OO metadata into the Perl boilerplate and runtime pieces needed for object-oriented code.

Getopt::Yath is the command line option framework that powers the yath test harness and can be used standalone to define, parse and document rich, reusable CLI options. You declare options with option and option_group and can include option sets from other modules so plugins and libraries can share flags. It supports common types such as booleans, scalars, counters, lists and maps plus auto and auto-list/map variants, and provides hooks for defaults, environment variable sourcing and setting, normalization and triggers. parse_options turns an argv array into a structured result that records parsed settings, skipped or cleared items, stop tokens and leftover arguments and reports what environment changes would be made, and you can control behavior like stopping at non options, grouping ranges or skipping invalid flags. It also generates human friendly command line help and POD from the same option definitions. If you need a feature rich, modular and documentable option system for command line tools or test runners, Getopt::Yath is a practical and well integrated choice.

Crypt::HSM is a lightweight Perl wrapper around PKCS11 libraries that lets Perl programs talk to hardware security modules, smartcards, and other token-based cryptography providers. It exposes simple objects like Provider, Slot, Session, and Stream so you can load a PKCS11 library, open a session to a token, authenticate, find or use keys, generate random data, and perform encrypt, decrypt, sign, verify, or digest operations. If you need hardware-backed keys or want to offload cryptographic operations to an HSM from Perl code, this module gives a straightforward, object-oriented way to do that by delegating the heavy lifting to whatever PKCS11 implementation you supply.

LWP (libwww-perl) is a mature, widely used Perl library that makes it easy to write web clients by modeling network interactions as HTTP-style request and response objects; its core pieces are LWP::UserAgent for sending requests and HTTP::Request/HTTP::Response for representing messages. It supports HTTP and HTTPS plus a range of other schemes like FTP, file, gopher, news and mailto, and includes built‑in handling for redirects, proxies, cookies, basic and digest authentication, HTML form parsing, robots.txt rules, and content negotiation, while also offering a simpler procedural interface (LWP::Simple) and handy command line tools such as lwp-request and lwp-download. The API is designed to be extensible so you can customize behavior with handlers or subclass LWP::UserAgent for things like robots or specialized clients. Recent maintenance releases continue to refine behavior and address security and interoperability issues, and the project now includes a SECURITY.md policy to document its security practices.

Dancer2::Plugin::REST is a small plugin for the Dancer2 web framework that makes building RESTful APIs in Perl quick and tidy. It can automatically select a serializer (JSON, YAML, Dumper by default) when your routes include a :format parameter or a regex capture, so your route handlers can simply return data structures and let the plugin marshal them into the requested format. The resource keyword generates the usual RESTful routes for a named resource (GET, POST, PUT, DELETE with optional format extensions) and the module also provides convenient status_* helpers for all HTTP response codes, with niceties like turning simple error strings into { error => ... } responses. If you use Dancer2 to expose JSON, YAML or other serialized responses this plugin cuts boilerplate and keeps your handlers focused on business logic; the most recent release adjusted tests to be tolerant of JSON::PP occasionally serializing numbers as strings.

Module::CoreList is a reference library that tells you which modules and which module versions were bundled with each release of Perl, making it easy to check if a feature or library is part of core for a given Perl. You can use the included corelist command line tool or call the API from Perl to ask when a module first appeared, when it was deprecated or removed, whether a specific module version is core, or to search core modules with a regex and compare differences between two releases. The distribution also exposes hashes such as %Module::CoreList::version, ::delta, ::released, ::families, ::deprecated, ::upstream and ::bug_tracker so tools and packagers can inspect versions, release dates, deprecation notes and where to send patches or bug reports. Coverage includes all stable Perl releases since 5.6.0 and development releases since 5.9.0 with earlier legacy data, and the module is maintained by the Perl 5 Porters and distributed under the same license as Perl.

CPAN::Perl::Releases is a lightweight data module that maps Perl release numbers to the CPAN authors/id paths where the corresponding tarball files live. It exposes perl_tarballs($version) to return a hashref of available archive types such as tar.gz, tar.bz2 or tar.xz and their relative CPAN locations, plus perl_versions and perl_pumpkins to list supported releases and the PAUSE IDs of the Perl release authors. The mapping is static data but updated regularly as new Perl releases appear on CPAN, so it is handy for scripts that need to locate historical or current perl tarballs without scraping CPAN. Note that not every release has every compression format and some older tarballs may have been removed, which the module reflects. The latest update in March 2026 added mappings for v5.40.4 and v5.42.2.

mb.pm is a small "modulino" that lets you write Perl scripts using legacy multibyte encodings (Big5, Big5-HKSCS, EUC-JP, GB18030, GBK, Shift_JIS/CP932, UHC, UTF‑8 and WTF‑8) by transpiling your source into an octet-oriented Perl program before running it. It detects or accepts a chosen encoding and rewrites literals, regular expressions and string operations so multibyte codepoints behave sensibly while leaving traditional byte-oriented built-ins unchanged, and it supplies an mb:: namespace (mb::length, mb::substr, mb::tr, mb::chr, mb::ord, mb::do/mb::eval/mb::require/mb::use, etc.) for codepoint-aware operations. The tool handles tricky issues like multibyte anchoring and escaping of bytes that would otherwise act as Perl metacharacters, supports many platforms and very old Perls (back to 5.005_03), and is aimed at keeping "easy jobs easy" for people maintaining MBCS-era scripts. You do need to run scripts through the modulino (perl mb.pm script.pl) and it generates a translated .oo.pl file, and there are known limitations such as incomplete Unicode property support, no named codepoints, ASCII-only casing helpers, some regex/lookbehind and Windows chdir edge cases, and a few other intentional omissions; these tradeoffs are documented by the author. Recent updates added support for finally blocks and related syntax and smaller language fixes including support for the ^^ logical xor operator and raised regex limits on modern Perls, making the transpiler more compatible with contemporary Perl syntax.

Rex::LibSSH is a connection backend for the Rex automation framework that uses Net::LibSSH, the XS binding to libssh, to provide SSH, command execution and file operations without requiring an SFTP subsystem. It implements Rex connection, exec, fs and file interfaces and performs file operations over plain SSH exec channels, making it a good fit for minimal containers, embedded systems or any host that lacks SFTP support and would otherwise fail. Enable it by setting connection => 'LibSSH' in your Rexfile and authenticate with public keys via Rex::Config or by passing keys to Rex::connect. Host key checking is disabled by default to avoid blocking non-interactive deploys and can be enabled with strict_hostkeycheck.

File::StatX exposes the Linux statx system call to Perl so you can retrieve much richer and more modern file metadata than Perl's built-in stat provides, including creation time, mount and subvolume identifiers, direct-I/O alignment and atomic-write limits, device major/minor numbers, filesystem attributes like immutable, encrypted, verity and DAX, and block allocation details. You call statx, statxat or fstatx with a mask and flags to request only the fields you need and get back a File::StatX object with accessor methods such as size, mtime, btime, nlink, dio_mem_align and others; fields that your kernel or filesystem does not support will simply be absent or zero. This module is useful for system utilities, backup and verification tools, filesystem-aware applications and anyone needing precise performance and integrity-related file information on Linux. Note that some capabilities depend on kernel and filesystem support and may not be available everywhere. The recent 0.005 update fixes detection of available attributes and corrects a define used in optional methods.

Tlaloc is a small, playful utility for Perl that lets you attach an invisible "wetness" meter to scalars and to tied arrays or hashes so their wetness decays each time the value is read. You control wetness with simple functions like wet and drench, inspect it with wetness, is_wet and is_dry, and tune how fast it evaporates with evap_rate. By default a wet or drenched scalar loses a fixed amount on every access so the underlying string value never changes while the hidden metadata counts down. For arrays and hashes you can either track wetness only when you explicitly query it or use wet_tie to make element access and other operations cause passive evaporation. Useful for toy state, TTL-like behavior tied to reads, or adding ephemeral metadata to variables, Tlaloc is easy to use but has a few caveats: do not pass literals, magic is per-SV so assignments do not copy wetness, and it is not thread safe. This is an early stage module with only an initial release in its change log.

Apophis is a compact, high-performance content-addressable storage library for Perl that produces deterministic UUID v5 identifiers for blob content using the Horus RFC 9562 library. It guarantees identical content maps to the same UUID while different namespaces yield distinct UUIDs, making deduplication and logical partitioning straightforward. Objects are stored in a two-level hex-sharded directory layout for scalable filesystem performance, writes are atomic via temporary files and rename, and file identification is streamed in fixed-size chunks so large files use constant memory. The API is minimal and pragmatic: identify content or files, store and fetch by UUID, verify integrity, remove items, and run bulk operations like store_many and find_missing, with optional per-object metadata. The core is implemented in C with an XS Perl wrapper so you get C-level speed from simple Perl calls, making Apophis a good fit when you need deterministic, namespace-aware CAS with efficient on-disk layout and atomic semantics.

Colouring::In::XS is a fast, XS-backed Perl module for creating, converting and manipulating colors in a variety of common formats. You can instantiate colors from hex, RGB(A), HSL(A) or arrays and convert them to hex, rgb/rgba, hsl, hsv or Terminal::ANSIColor strings, with automatic CSS-friendly stringification. It also provides color operations such as mix, lighten, darken, tint, shade, saturate, desaturate, greyscale and opacity control via fade/fadein/fadeout, plus a validator for input colors. The implementation in XS makes it much faster than a pure-Perl equivalent, so it is a good fit for web or terminal applications and scripts that need reliable color math and high performance.

Horus is an ultra-fast 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 string, hex, braces, URN, base64, base32, Crockford base32 and raw binary. It is a pure XS module with no external C library dependencies and is optimized for high throughput and low Perl/C boundary overhead, with bulk generation, an object interface, and support for deterministic namespace UUIDs (v3 and v5), time and monotonic variants (v1, v6, v7), random v4, and custom v8 payloads. The module also includes utilities for validation, parsing, conversion, comparison and extracting timestamps, making it a good choice when you need fast, flexible UUID generation for high‑performance services, databases or distributed systems.

Litavis is a high‑performance CSS preprocessor and compiler for Perl that runs its engine in C via XS, designed to replace the older Crayon tool while keeping compatibility where useful. It accepts enhanced CSS with nested selectors, parent references, variables, mixins, and map variables and resolves colour functions like lighten, darken, mix and fade at compile time, then emits standard CSS either minified or pretty printed. The compiler preserves cascade rules and offers cascade‑aware deduplication with conservative and aggressive modes so you can balance safety and output size, and it supports file and directory parsing, import hoisting, hex shorthand, comment stripping and passthrough of CSS custom properties and calc expressions. Compilation is non‑destructive so you can call compile multiple times and reset state between projects, and the module also installs reusable C header files for downstream XS modules that want to embed the same engine. Use Litavis if you need a fast, spec conscious CSS build step in Perl or want a C‑level library for CSS preprocessing.

CPANSA::DB is a lightweight, data-only Perl module that provides the CPAN Security Advisory reports as a ready-to-use Perl data structure, primarily consumed by CPAN::Audit but available to any tool that needs a canonical list of CPAN security advisories. The module exposes a single subroutine, db, which returns a hash reference of the advisory records, and a JSON equivalent of the same dataset is also distributed for non-Perl consumers. Releases are signed with GPG and published on GitHub with attestations so you can verify the archive came from the official repository. The project is actively maintained with frequent CVE and report updates and recent work has reduced the database size by switching to a terser internal format, making it easier to bundle into auditing and deployment workflows.

Eshu is a fast, XS-powered tool for normalizing leading indentation in C, Perl and XS source files by tracking nesting and rewriting only the whitespace at the start of each line while leaving the rest of the code untouched. It understands language-specific constructs that affect indentation including C strings, comments and preprocessor directives, Perl heredocs, regexes and pod sections, and XS dual-mode files with XSUB boundaries and labels. The module exposes simple entry points to fix C, Perl or XS text or to auto-dispatch by language, and it can detect language from a filename. You can choose tabs or spaces and set the indentation width, and there is an option to indent preprocessor directives when desired. Eshu is implemented in C for single-pass speed and ships with a command line utility for in-place fixing, diffs, CI checks or stdin/stdout processing, making it a practical choice for keeping mixed-language codebases consistently indented.