CPANscan

Clean::Eval is a thin, safer wrapper around Perl's eval that prevents clobbering of the global $@ and always returns a blessed result object that tells you whether the eval succeeded and contains useful diagnostics. The returned object is true on success and false on failure and stringifies to the trapped error, so you can check it directly in conditions and die or warn with it on failure. The block form captures the block's scalar return value in an out field on success while the string form runs code with adjusted #line information but never records a return value or sees the caller's lexical variables. A global last_error helper can retrieve the most recent failure, and the module documents a few practical caveats to watch for such as the scalar-context capture of block returns, a lexical scoping gotcha when declaring and checking the result in a single statement, and the inherent limitations of the string-eval and last_error globals.

Random::Simple replaces Perl's built-in pseudorandom generator with a modern PCG engine and gives you easy, ready-to-use helpers for common tasks like unbiased integer ranges, floating values between 0 and 1, random byte buffers, picking a random array element, and shuffling arrays. It automatically seeds from your operating system entropy so it is safe for general use and it upgrades rand() and srand() to use the better PRNG under the hood while still letting you manually seed two 64 bit values when you need reproducible results for tests. The module is designed to be fast, statistically robust, and simple to use for tasks such as coin flips, die rolls, sampling and secure-looking random bytes, and recent changes improved automatic seeding, corrected 32 bit behavior, switched to a 64 bit PCG variant for larger random values and now require Perl 5.14 or later. Note that PCG needs high quality 64 bit seeds if you choose to seed manually so use large nonzero numbers for repeatable output.

App::cpan2arch is the library behind the cpan2arch command that automates creating Arch Linux PKGBUILD files from CPAN metadata. It reads environment variables and command line options, queries MetaCPAN for distribution metadata and Arch repositories for existing packages, translates CPAN prerequisite declarations into Arch dependency syntax, and then generates a PKGBUILD which it writes to standard output or a file. The module is aimed at packagers and maintainers who want to convert Perl distributions into Arch packages and it handles the common failure modes such as missing runtime modules, network or API errors, tarball or Perl version problems, and file permission issues by reporting to standard error and exiting with appropriate codes. This is the initial v1.0.0 release.

Data::Printer::Filter::EscapeNonPrintable is a small plugin for Data::Printer that makes sure ASCII control and other nonprintable characters are visibly escaped when you dump data. When Data::Printer's print_escapes option misses certain controls like vertical tab or DEL this filter converts those characters to octal escape sequences and applies the "escaped" color styling so they are obvious in output. You enable it by adding the filter to your Data::Printer configuration or importing DDP with print_escapes and the filter name, and you can also call its parse function from another filter if you need to chain processing. This module is a pragmatic workaround rather than a core fix for Data::Printer, so use it when you need complete, colorized escaping of nonprintable ASCII while awaiting an upstream patch.

Software::License::MIT_0 is a small Perl module that supplies the text of the MIT No Attribution (MIT-0) license as a Software::License subclass, making it easy for CPAN authors to attach or print the SPDX-approved, attribution-free MIT-0 license from Perl code by providing holder information. It is focused on a single job and integrates with the familiar Software::License API so you can include a permissive, attribution-free license in your distributions without hand-copying license text. Recent maintenance updates corrected script shebangs, added a minimum Perl version and other metadata fixes, and now require a newer Software::License dependency. Report bugs on the project's GitHub page.

App::pod2gfm is a lightweight Perl helper that implements the logic behind the pod2gfm command-line tool to convert Perl POD documentation into GitHub Flavored Markdown. You create an instance with new, parse command-line options with init(@ARGV), and call run to set up filehandles and invoke Pod::Markdown::Githubert for the actual conversion. The module uses UTF-8 by default, supports writing to multiple output files without clobbering existing files, and deliberately does not attempt to handle POD encoding options the way pod2markdown does. Errors are reported to STDERR and the program exits with a nonzero status for problems like file access or invalid options. The recent 1.1.0 update added optional bash completion and various small fixes and test tidy-ups, making it a handy choice for Perl authors who want to publish POD as Markdown on GitHub.

OpenAPI::Modern is a Perl toolkit that validates HTTP requests and responses against an OpenAPI specification (v3.0, v3.1 or v3.2), letting you check that incoming or outgoing messages match the API contract and get detailed, machine-readable error reports and deserialized parameter and body data. You construct it with your OpenAPI document and optionally a JSON::Schema::Modern evaluator, then call validate_request or validate_response to receive a JSON::Schema::Modern::Result object that contains validation errors, absolute locations into the spec, and a nested data structure of parsed path, query, header, cookie and body values. The module bundles up-to-date metaschemas, supports OpenAPI-specific schema dialects, media-type matching and many parameter styles including cookie and query parsing, and it can populate defaults and be cached for fast startup in preforked apps. It works best with Mojolicious request/response objects and converts several other frameworks’ request/response types on a best-effort basis, but some features are not yet implemented such as multipart and application/x-www-form-urlencoded message bodies and automatic checking of Authorization headers. Recent releases improve OpenAPI 3.2 support and media-type handling and make internal JSON::Schema::Modern configuration updates for more robust behavior.

TUI::Vision is a top-level Perl module that brings a Turbo Vision 2.0 style text user interface toolkit to Perl projects, making it easy to build console applications with windows, dialogs, menus and widgets. It acts as an umbrella that re-exports the framework's main subsystems so you can pull in the common API with a single use TUI::Vision statement instead of importing many modules individually. The module is a Perl implementation and maintenance effort by J. Schneider based on the original Borland Turbo Vision design and is distributed under the permissive MIT license, so it is a practical choice if you want a structured, reusable toolkit for creating rich terminal interfaces in Perl.

LWP::ConsoleLogger is a lightweight debugging helper for Perl HTTP clients such as LWP::UserAgent and WWW::Mechanize that prints readable, configurable traces of requests and responses to your console. It quickly shows URIs, query and POST params, headers, cookies, HTTP status and optionally page titles and response bodies, and includes one-line wrappers (LWP::ConsoleLogger::Easy and ::Everywhere) to get started immediately. You can redact sensitive headers or params, hook in a custom Log::Dispatch logger, and apply content and text pre-filters or HTML::Restrict to transform or clean output before it is displayed. The default output is pretty, table-based formatting but can be switched to raw dumps for easy copy/paste, and all options are mutable at runtime so you can turn parts on or off as needed. The author notes it was written for common text formats like HTML, JSON and XML and that test coverage is not exhaustive, so you may need to tweak filters for unusual content.

WWW::Bizowie::API is a lightweight Perl client for Bizowie's cloud ERP that lets Perl programs make authenticated HTTP calls to the Bizowie API. You construct an object with your api_key, secret_key and site hostname and then call methods by passing a path string and a hashref of parameters. The module supports both the legacy v1 endpoint and the newer v2 endpoint, allows setting an api_version for v2 and a debug flag to help with JSON decoding problems. It handles the HTTP and JSON details using common Perl networking and JSON libraries so you can automate, integrate or script Bizowie operations from Perl without writing low level HTTP code.

EV::cares is a high-performance asynchronous DNS resolver for Perl that embeds the c-ares library directly into the EV event loop so DNS socket I/O and timers run at the C level with no Perl-level event overhead. It gives you nonblocking resolve, reverse, getaddrinfo, raw query and search operations, optional per-record TTL results for cache-friendly behaviour, bulk helpers for firing many queries in parallel, and conveniences for setting servers, local bind addresses, timeouts and retries. The module parses a wide range of record types including MX, SRV, HTTPS/SVCB, TLSA and DNSSEC-related records when your c-ares build is new enough, and falls back to returning the raw DNS packet otherwise. Callbacks are safe to cancel or destroy from within and there are introspection helpers such as active_queries, next_timeout and wait_idle for mostly synchronous workflows. Note that while DNSSEC records are parsed into Perl structures EV::cares does not perform cryptographic validation so rely on a validating recursive resolver and the AD bit if you need authenticated answers. Requires c-ares >= 1.24 and c-ares >= 1.28 for the newest record parsing, and the recent 0.02 release added bulk helpers, DNSSEC and SVCB parsing, custom EV::Loop support and useful utilities like ptr_name and parse_header.

LWP, the libwww-perl collection, is a mature suite of Perl modules that makes it easy to write web clients and simple HTTP servers by modelling web traffic as HTTP::Request and HTTP::Response objects processed by an LWP::UserAgent. It supports common schemes like http, https, ftp, gopher, news, file and mailto, and provides higher level conveniences such as cookie handling, proxy support, basic and digest authentication, HTML form parsing, robots.txt parsing and content negotiation, plus simple command line tools like lwp-request and lwp-download. The API is object oriented but also offers simple procedural helpers so it works well for scripts and larger applications alike. The project is actively maintained on CPAN and recently hardened redirect behavior in version 6.83 to avoid credential leakage by stripping Authorization headers on cross-origin redirects and by refusing https-to-http downgrades by default, with opt-outs available for legacy use. If you need to fetch, submit or negotiate web resources from Perl code, LWP is a solid, widely used choice.

Mojo::Pg is a lightweight Perl module that wraps DBD::Pg to make PostgreSQL easy and productive to use with the Mojolicious web framework. It gives simple APIs for running blocking and non-blocking queries, automatic connection caching and pooling, and integration with SQL::Abstract for generating CRUD statements. It also includes transaction support, built-in migrations for schema management, and a PubSub facility for PostgreSQL notifications so you can build real-time, multi-process apps. Sensible default DBI options and automatic connection handling after forks make it practical for web apps, services and projects that need scalable database access and real-time messaging.

Git::Server is a drop-in replacement for a standard Git server that gives administrators more powerful server-side hooks and much more granular access control than Git’s defaults. It operates via the SSH command in authorized_keys so you can bind actions and enforce per-user ACLs, enable richer hook behavior, and trigger simple push-notification deployments for instant updates. It is aimed at teams and operators who need flexible server logic without heavy dependencies and is similar in purpose to Git::Hooks but designed to be more capable and lighter weight. The project is actively maintained on GitHub and accepts issues and pull requests.

Object::HashBase is a lightweight utility for quickly building hash-based Perl objects by auto-generating a new() constructor, attribute constants and accessor methods from a simple list of field names. You declare attributes when you use the module and it creates getters, set_foo setters and FOO constants, with modifiers for read-only, write-only, deprecated setters, constant-only fields and the ability to opt out of XS generation. It supports hashref and arrayref constructors, single inheritance with inherited constants, class-level hooks for pre- and post-init initialization, and a helper to list a class's attributes. If Class::XSAccessor is installed accessors are generated in XS for speed but that can interfere with taking direct scalar references to the underlying hash slots in rare cases. Recent changes added Class::XSAccessor support, expanded init hook functionality and fixed a double-import bug.

Sys::OsRelease is a lightweight Perl helper that reads the standard /etc/os-release file defined by freedesktop.org and exposes the system or distribution identity to Perl programs, providing a singleton instance with auto-generated read-only accessors for common fields like ID, NAME, VERSION_ID and ID_LIKE plus methods to check and retrieve arbitrary attributes and the file path. It keeps dependencies minimal, lets you tweak the search path or recognized common platform names, and is useful for installers, container tooling and scripts that need to detect OS type on Linux and BSD systems while falling back to Perl's $Config{osname} if no os-release file is present.

Qmail::Deliverable is a Perl module for qmail-based SMTP servers that quickly checks whether a local email address is actually deliverable by applying the same address-to-user and .qmail logic qmail uses. It exports handy functions like qmail_local, qmail_user, dot_qmail and deliverable, and ships with a root-run daemon (qmail-deliverabled) plus a client for use from unprivileged SMTP daemons, so you can reject unknown recipients early and avoid wasting resources on spam scans or generating backscatter. The deliverable call returns fine-grained status codes that indicate not deliverable, temporarily undeliverable, unknown, or various positive delivery indications, and it includes special handling for vpopmail and common Plesk bouncesaying cases. The module intentionally fails safe for .qmail files that run programs so catch-all or program-based deliveries are treated as deliverable, and it has some limitations such as no support for user+ext syntax beyond hyphen, no percent-hack handling, plain-text control file use rather than CDB, refusal of non-ASCII addresses, and relatively limited production history. It is fast in normal setups with thousands of checks per second and offers an experimental caching path for much higher throughput.

Time::Str is a compact toolkit for parsing and formatting date and time strings across many internet and standard formats. It exposes str2time to convert textual timestamps into Unix seconds (optionally with fractional seconds), str2date to return validated components including nanoseconds and timezone annotations, and time2str to render Unix timestamps into standards such as ISO 8601 / RFC 3339, RFC 2822, HTTP, SQL, ASN.1, common log formats and more. The module handles fractional seconds with configurable precision, rounds or truncates predictably and offers a nanosecond override for exact output. For timezone handling it requires a numeric offset or a UTC designator (Z, UTC, GMT) to produce a timestamp and will capture ambiguous abbreviations like EST or IST without resolving them. Limitations include English-only month and day names, no ISO week or ordinal dates, a supported year range of 0001–9999, and deliberate non-resolution of timezone abbreviations. If you need reliable, standards-compliant parsing and formatting across many common timestamp forms with precise fractional-second control, Time::Str is a good fit.

Dist::AutomationPolicy is a small helper for Perl distribution maintainers who want to publish machine-readable policies about automated code and contribution workflows, making it easy to generate and validate the CPAN-META/automation-policy.json file that describes how code is produced, whether third-party bots may file issues or patches, and what repository actions automated agents are allowed to perform. The module provides a simple constructor, a set of predefined templates for common stances such as no_automation, human_supervised or full_automation, validation against the schema, and convenient to_json and from_json methods so you can produce or read the policy file from your build or release tooling. It supports the initial v1 policy schema, complements human-readable AI_POLICY.md or CONTRIBUTING.md files, and is aimed at projects that want a clear, machine-readable signal of their automation practices. This is an initial prototype released to CPAN with source and issue tracking on GitHub and requires Perl 5.24 or later.

Text::JSCalendar is a small Perl utility that maps between traditional iCalendar (RFC 5545) and the newer JSCalendar format so you can parse, compare, normalize, and serialize calendar events in Perl. It converts vCalendar text into Perl event structures and turns one or more events back into an iCal string, provides a cached timezone lookup for speed, a NormaliseEvent helper that removes default-valued fields, and a CompareEvents routine to test equality. This module is useful when you need to bridge CalDAV or iCalendar-based systems with JSCalendar-aware clients or tooling, and it aims to make format conversions and simple event operations straightforward.

Matplotlib::Simple is a Perl convenience layer that turns Perl data structures into Python3 matplotlib scripts and images, saving editable Python files (by default under /tmp) and optionally running them, so you only need python3 and matplotlib installed. It exposes a compact Perl API for common chart types — bar, barh, boxplot, hexbin, hist, hist2d, imshow, pie, plot, scatter, violinplot and colored tables — and supports single plots and multi subplot layouts, colorbars, labels, log scales, shared colorbars, and many matplotlib options via a Perl-friendly options hash. You supply hashes, arrays or nested structures as data and configure per-plot settings like colors, figure size, axis labels and annotations without writing Python code. The module aims to make common plotting tasks much easier than using raw matplotlib and lets you either execute the generated script or keep it for manual editing and faster batch generation.

Mail::Make is a strict, RFC-aware MIME email builder for Perl that gives you a fluent, chainable API to assemble messages with plain text, HTML, inline images and file attachments. It automatically picks the correct MIME structure for alternatives, related inline parts and mixed attachments, encodes non-ASCII headers correctly, and can rewrite and embed external HTML assets into cid inline parts or fetch and cache them for you. You can produce the message as a string, a scalar reference or stream it directly to a filehandle to avoid memory bloat, and the module can submit mail via SMTP with authentication and TLS options. It also provides OpenPGP and S/MIME helpers for signing and encryption, with GPG delegated to the gpg executable and S/MIME using Crypt::SMIME which requires the full message in memory. If you want a high level, validating way to build and deliver complex MIME emails from Perl, Mail::Make is a practical and well featured choice.

RT-Extension-ToggleTheme is a small RT 6 plugin that adds a light/dark mode toggle to the web interface navigation bar so users can switch the UI between light and dark appearances. It works with any Bootstrap 5 theme and displays for users who hold the ModifySelf right, appearing in both the privileged and self-service portals. The extension is installed as a standard RT plugin and enabled in RT_SiteConfig so users can choose their preferred theme without altering system styles. Recent updates removed an Elevator-only restriction and ensured the toggle works across all Bootstrap 5 themes and in the self-service interface as well.

WWW::Vonage::API is a lightweight Perl client that simplifies calling Vonage's REST APIs by wrapping endpoint construction, HTTP verbs, JSON encoding, and basic authentication into a single object. You create a WWW::Vonage::API instance with your API_Key and API_Secret and then call GET, POST, PATCH, PUT or DELETE with the resource path and a Perl hashref payload; GET payloads become query strings and other verbs send JSON bodies. The module understands Vonage's varied domain, region and version patterns and lets you set API_Domain, API_Region or API_Version globally or per call, and responses are returned as a hashref containing the raw content, HTTP code and message for you to inspect. Most features in the Vonage platform are accessible, including messaging, reports, accounts and voice, but note that only Basic Authentication is implemented at this time and JSON Web Token based calls are not yet supported. This release is the initial import of WWW::Vonage::API.

Mojo::SQL is a small Perl helper for building SQL queries safely and modularly. It converts each ? in your SQL into a bound parameter to prevent SQL injection and lets you compose partial statements recursively so you can build dynamic WHERE clauses and reusable fragments. Use sql() to create safe, bindable statements and sql_unsafe only when you need to insert already-escaped SQL, with provided PostgreSQL helpers escape_literal and escape_identifier to help with that. You can also change the placeholder character for databases that do not use numbered placeholders. The module produces objects exposing final SQL text and bound values for use with DBI or other drivers and is part of the Mojolicious ecosystem under the MIT license.

Getopt::WonderBra is a small Perl utility that parses command line arguments the way the classic Unix getopt program does, which makes it useful when porting shell scripts to Perl or when you need traditional getopt behavior. It provides a single exported getopt function that separates short flags, options with arguments, and long options and returns the leftover parameters, and it wraps your main::help and main::version handlers so that --help and --version produce the expected output on the correct stream and then exit. Note that the module deliberately replaces main::help with a wrapper that exits the program, so calling help after using getopt will terminate execution by design to ensure correct behavior with piping and error messages. The module is lightweight and was first released as version 0.01.

GDPR::IAB::TCFv2 is a Perl library for decoding and inspecting IAB Transparency & Consent (TCF) version 2 strings, returning an immutable object with easy access to fields like creation time, CMP id and version, language, policy version, vendor list version, and predicates for purpose consent, legitimate interest, vendor consent, disclosed or allowed vendors, special-feature opt-ins, and publisher restrictions. It provides TO_JSON serialization with configurable output shapes, a companion Validator class for policy-driven checks against vendor profiles, and a command-line tool (iabtcfv2) with dump and validate subcommands plus a Docker image for pipeline use. Parse validates base64url strings, supports a strict TCF v2.3 mode, vendor prefetching for range-based encodings, and JSON formatting options for compactness, booleans, and date handling. The project entered maintenance mode with the v0.400 release on 2026-05-09, marking the core parser, validator, and CMP-validator surfaces as feature-complete for TCF v2.3 while continuing to receive bug and security fixes and accept community patches for the remaining roadmap items. If you need to programmatically read, serialize, or validate TCF v2 consent strings or integrate consent checks into tooling and CI, this module is a direct fit.

Module::Generic is a heavyweight base class and utility toolkit you can inherit from to build feature-rich Perl objects quickly, with a consistent error and logging model, typed accessors, dynamic object creation and convenient serialization. It supplies dozens of helper "_set_get_*" methods for common types such as scalars, numbers, booleans, datetimes, UUIDs, IPs, URIs, files, arrays and nested object classes and it can generate full Perl packages on the fly via create_class so you can declare methods and nested types with very little boilerplate. The module also provides AUTOLOAD-based dynamic accessors that map hash keys to methods, an as_hash exporter for JSON-friendly data, robust serialize/deserialise support for Sereal, CBOR, Storable::Improved and JSON, flexible coloured terminal output and message logging helpers, and an error/exception system that returns exception objects and a null object for safe chaining. Recent releases added an XS backend that accelerates a dozen hot helper routines while falling back to pure Perl when no shared library is available and the latest release added small file-related helpers in Module::Generic::File. Note that some metaprogramming features such as dynamic class creation and symbol injection carry thread-safety caveats and are intended to be used during initialization rather than concurrently at runtime.

IPC::Manager is a lightweight framework for local interprocess messaging that lets processes on a single machine create or connect to a shared data store and exchange message objects without a central broker. You create a datastore with ipcm_spawn and share the returned connection string so other processes can ipcm_connect and send or receive IPC::Manager::Message instances, with the store able to be temporary or persistent. The module picks a suitable transport automatically or lets you choose from several client protocols including filesystem pipes and unix sockets or DB-backed stores for MySQL, PostgreSQL, SQLite and others, and it supports pluggable serializers with sensible defaults such as JSON::Zstd when available. It also provides helpers to fork managed service and worker processes that join the IPC bus and it will notify clients and clean up when a temporary store is shut down. Use it when you need reliable local message passing between multiple processes without running an external messaging server.

EMDIS::ECS is a mature Perl implementation of the EMDIS Communication System that automates secure, auditable exchange of structured messages and documents using encrypted email and, optionally, AMQP messaging. It wraps PGP/GnuPG encryption, SMTP for sending and POP3/IMAP or DIRECTORY for receiving, and provides utilities like ecstool and ecs_scan_mail plus Docker setups for testing and deployment, while managing node state, sequencing, retransmit requests, and document exchange. The module is useful if you need an interoperable, configurable messaging transport for partner-to-partner data transfer where encryption, message sequencing, and administrator notifications matter; it expects you to provide or configure mail servers and OpenPGP key material. Recent updates added AMQP and document exchange support, modern OAuth2/SASL options for cloud mail providers, improved gpg pinentry handling, and timing controls (T_INBOUND) to make short-lived runs such as Lambda-friendly executions behave predictably.