CPANscan

DateTime::Format::Intl is a Perl port of the JavaScript Intl.DateTimeFormat API that formats DateTime or DateTime::Lite objects with CLDR-driven, browser-like locale rules. You create a formatter with a BCP 47 locale tag and options such as dateStyle, timeStyle, individual components, timeZone, numberingSystem or hourCycle, then call format, formatRange, formatToParts or formatRangeToParts to get localized strings or tokenized parts for custom rendering. It relies on CLDR and related Perl modules to deliver culturally sensible defaults and interval-aware formatting, including time zone name variants and day period wording. The module aims to closely match web browser behavior, so it can feel quite feature rich, but only the Gregorian calendar is supported and some options are constrained by CLDR and the underlying libraries. Because object creation does lookups and pattern resolution you should cache formatter objects rather than recreate them for every date, and note it requires Perl 5.10.1 plus several non-core dependencies.

DBI is the standard, database‑independent database access layer for Perl that gives your scripts a consistent API for connecting to databases, preparing and executing SQL, binding parameters, fetching rows, and managing transactions while leaving engine‑specific work to driver modules (DBD::...). It is the go‑to foundation for any Perl code that talks to SQL databases and adds convenience helpers and features like safe quoting and placeholders, cached prepares and connections, detailed tracing and profiling, and metadata/catalog methods so you can write portable code without learning each database’s quirks. DBI is mature, widely used and actively maintained, and is primarily relevant if you write Perl that interacts with relational databases or build libraries that must support multiple backends. Recent releases have focused on security hardening and robustness, fixing parsing and buffer issues and tightening placeholder handling, and the project now warns that the next release will require perl‑5.12, so upgrade planning and using up‑to‑date DBD drivers is recommended.

Acrux is a lightweight Perl toolkit that provides common application building blocks such as flexible logging, file locking, a Damm check-digit digest, simple word parsing, date formatting and interactive prompt helpers, plus config and path utilities that complement Acme::Crux. It is aimed at Perl developers who want ready-made, well scoped helpers for command-line and server programs rather than a full framework. Recent updates include a switch of the default logging backend from syslog to STDERR with explicit targets for stdout, stderr and syslog and safer fallback behavior, the addition of Acrux::FileLock and Acrux::Digest::Damm, and a fix to Plugin::Log configuration handling. The project is maintained under the Artistic License 2.0.

Protobuf is a high-performance Perl binding for Google Protocol Buffers that uses the C upb library to give fast, memory-efficient serialization and parsing from Perl code. It exposes the familiar building blocks you expect from protobufs, such as DescriptorPool, Message classes and Arena memory management, and supports binary, JSON and text formats, well-known types, length-prefixed streaming, and generated Perl classes for your schemas. The implementation is designed to mirror the behavior of the official UPB-based Python extension so you get predictable interop and production-grade speed while staying in Perl. If you need compact, cross-language data interchange or efficient on-the-wire message handling from Perl, this module is relevant. Recent releases focus on portability and build hardening, with the 0.05 update improving Windows build and linking support and fixing several XS and test-suite issues to make installation and use more robust across platforms.

Module::Starter::Protobuf is a Module::Starter plugin that automates building a Perl CPAN distribution from proto3 Protocol Buffers schemas. It invokes protoc with the upb plugin to generate low level serialization classes and then scaffolds high level, idiomatic gRPC client wrappers using Moo and the Google::gRPC::Client stack, with an optional REST transport via Google::Cloud::REST::Client and Google::Auth for credentials. The plugin also emits a schema container module, injects necessary dependencies into Makefile.PL, and creates a basic integration test so you get a publishable client library quickly for Google Cloud or any service defined by .proto files. This is useful if you need to turn protobuf definitions into usable Perl clients without hand writing boilerplate, though the generated POD in this snapshot showed a few minor documentation formatting warnings that may need a quick manual fix.

Google::Cloud::Storage::V2 is a Perl client that provides high-performance access to the Google Cloud Storage V2 API over gRPC. It lets Perl applications interact with Google Cloud Storage for common tasks such as managing buckets and objects, and is instantiated with credentials from Google::Auth to authenticate requests. This module is aimed at developers who need fast, direct programmatic access to Cloud Storage from Perl and is released under the Apache 2.0 license.

Google::Cloud::SecretManager::V1 is a Perl client for the Google Cloud Secret Manager V1 API that talks to the service over a high-performance gRPC transport. It gives Perl applications a straightforward way to programmatically create, store, access and manage secrets and their versions using Google Cloud credentials. The module integrates with Google::Auth for authentication and accepts standard credential objects when you construct the client. It is distributed under the Apache 2.0 license and this entry marks the initial release.

Google::Cloud::SQL::V1 is a Perl client library for the Google Cloud SQL Admin API v1 that lets you manage Cloud SQL resources from Perl programs. It uses a high-performance gRPC transport for efficient remote calls and pairs with Google::Auth to handle credentials, so you can construct a client with an auth object and script administrative tasks like creating or configuring instances, scheduling backups, and managing users. The module is aimed at developers who want to automate Cloud SQL operations from Perl with low-latency RPCs. This is the initial 0.01 release and the library is provided under the Apache 2.0 license.

Google::Cloud::PubSub::V1 is a Perl client library for the Google Cloud Pub/Sub v1 API that communicates over a high-performance gRPC transport. It provides a convenient way for Perl applications to publish and receive messages and to create and manage topics and subscriptions while using Google authentication modules such as Google::Auth. If you need native Perl access to Google Cloud messaging for event-driven systems, streaming pipelines, or background job coordination this module gives you the API surface and transport performance to integrate Pub/Sub into your app. The library is distributed under the Apache 2.0 license.

Google::Cloud::PrivateCA::V1 is a Perl client for Google Cloud's Certificate Authority Service that lets your code create and manage private certificate authorities and issued certificates through the V1 API using a high-performance gRPC transport. It integrates with Google::Auth for obtaining credentials so you can programmatically provision CAs, issue and revoke certificates, and automate private PKI tasks inside Google Cloud from Perl applications. The module is distributed under the Apache 2.0 license and is useful if you need to embed certificate lifecycle operations into scripts or services that interact with Google Cloud. This is the initial release of the client.

Google::Cloud::NetworkServices::V1 is a Perl client library for the Google Cloud Network Services V1 Secure Web Proxy API that lets Perl applications authenticate with Google::Auth and manage secure web proxy and related network resources programmatically. It talks to Google Cloud over a high-performance gRPC transport so you can automate creation, configuration, and management of proxy endpoints and policies from Perl code. The module is suitable for developers who need to integrate Google Cloud network service operations into scripts or applications and is released under the Apache 2.0 license; this listing is the initial 0.01 release.

Google::Cloud::NetworkSecurity::V1 is a Perl client library that lets Perl applications call the Google Cloud Network Security V1 API over a high-performance gRPC transport. It integrates with Google::Auth for credentials so your scripts can authenticate to Google Cloud and manage network security configuration and policies programmatically. Use this module when you need to control Network Security features from Perl code rather than using the web console or REST calls. The module is distributed under the Apache 2.0 license.

Google::Cloud::Metastore::V1 is a Perl client library that lets Perl applications talk to the Google Cloud Dataproc Metastore V1 service over a high-performance gRPC transport. It provides a straightforward way to authenticate with Google::Auth and programmatically create, configure, and manage Metastore services and their metadata for Hive and other big data workloads on Google Cloud. The module is aimed at developers who need to integrate Dataproc Metastore operations into Perl scripts or applications and is distributed under the Apache 2.0 license. This package was first released as version 0.01 on Jul 13, 2026.

Google::Cloud::IAM::V1 is a Perl client library that gives your Perl apps programmatic access to Google Cloud Identity and Access Management (IAM) v1 using a high-performance gRPC transport. It is designed for managing IAM concepts like roles, policies, service accounts and permissions from Perl code and works with Google::Auth to obtain credentials and authenticate calls. Use it when you need to perform IAM operations from a Perl service or script and prefer a gRPC-backed client for efficiency and parity with the Cloud IAM API.

Google::Cloud::Dataproc::V1 is a Perl client for the Google Cloud Dataproc V1 API that communicates over a high-performance gRPC transport, making it suitable for programs that need efficient, programmatic access to Dataproc from Perl. The module integrates with Google::Auth for authentication and provides a straightforward way to create and manage Dataproc resources such as clusters and jobs and to submit and monitor work from Perl code. It is licensed under Apache 2.0 and this listing is the initial distribution release.

Google::Cloud::Dataplex::V1 is a Perl client library for the Google Cloud Dataplex V1 API that uses a high-performance gRPC transport to let Perl applications programmatically interact with Dataplex services. It is intended for developers who need to automate or integrate Dataplex operations such as managing data lakes, assets, zones, and metadata from Perl code and it works with Google authentication libraries like Google::Auth to obtain credentials. The module is provided under the Apache 2.0 license.

Google::Cloud::Dataflow::V1Beta3 is a Perl client library for the Google Cloud Dataflow V1Beta3 API that communicates over high-performance gRPC. It lets Perl programs authenticate with Google credentials and interact with the Dataflow service to submit and manage pipelines, check job status, and retrieve runtime information, making it easy to integrate Dataflow operations into Perl-based tooling and automation. The module works with Google::Auth for credential management and is released under the Apache 2.0 license.

Google::Cloud::DataFusion::V1 is a Perl client for the Google Cloud Data Fusion V1 API that uses a high-performance gRPC transport to let Perl programs manage Data Fusion resources and automate data integration tasks. The module works with Google::Auth for authentication and provides a straightforward way to create and control Data Fusion instances, handle pipelines, and invoke other service operations from Perl code. It is intended for developers who need programmatic access to Google Cloud Data Fusion from Perl and is distributed under the Apache 2.0 license.

Google::Cloud::Compute::V1 is a Perl client for the Google Cloud Compute Engine V1 API that uses a high-performance gRPC transport to let Perl applications manage cloud resources. It is intended for developers who want to authenticate with Google::Auth and then programmatically create, list, update, or delete Compute Engine resources such as virtual machine instances, disks, networks, and related services. The module aims to provide a straightforward, modern interface for automating infrastructure tasks from Perl and is distributed under the Apache 2.0 license. This release is the initial distribution.

Google::Cloud::Composer::V1 is a Perl client for the Google Cloud Composer V1 API that communicates over a high-performance gRPC transport. It lets Perl applications and scripts call the Cloud Composer API to manage Composer resources, for example creating and configuring environments and working with associated operations. The module integrates with Google::Auth for authentication and is constructed by passing credentials into the new method, making it suitable for automation in services or command line tools. The library is open source and distributed under the Apache 2.0 license.

Google::Cloud::Build::V1 is a Perl client for the Google Cloud Build V1 API that uses a high-performance gRPC transport to let Perl applications authenticate with Google credentials and interact with Cloud Build. You can use it to trigger builds, check build status, and manage build-related resources from Perl code by supplying Google::Auth credentials when creating the client. The module is aimed at developers who need to automate CI/CD workflows on Google Cloud from Perl and is distributed under the Apache 2.0 license.

Google::Cloud::Bigquery::V2 is an auto-generated Perl client for Google BigQuery built on high-performance gRPC and Protocol Buffers that provides a direct mapping to the BigQuery RPCs. It exposes methods to manage datasets, tables, jobs, queries, models, routines, projects, property graphs and row access policies, letting you call operations like get_table, insert_dataset or query by passing a Perl hash of request parameters. You create the client with a Google::Auth credentials object and then use the provided methods to perform programmatic BigQuery operations from Perl. The module is aimed at developers who need reliable, low-level API access to BigQuery and is released under the Apache 2.0 license.

Google::Cloud::BigQuery::Storage::V1 is a Perl client library for the Google Cloud BigQuery Storage API v1 that uses high-performance gRPC transport to read large result sets from BigQuery. It helps Perl applications authenticate with Google services, create read sessions, and stream rows efficiently so you can build ETL, analytics, or data ingestion tools without handling low-level protocol details. The module is intended to be used with Google::Auth for credentials and is distributed under the Apache 2.0 license. This release is the initial distribution.

Google::Auth is a lightweight Perl library that locates and returns Google application default credentials and detects the current Google Cloud project ID so your code can authenticate to Google APIs without hardcoding keys. It provides a simple default($scopes, $options) call that picks the right credential source for the environment, whether that is local developer credentials, a service account key, or tokens from the Cloud metadata server, making it useful for any Perl code that needs to obtain OAuth scopes and sign requests. Recent work has reorganized the project layout and added a vendored Protocol Buffers submodule based on v22.3 with a Perl protobuf implementation in progress, improving the repository structure and laying groundwork for broader serialization support.

Google::Api::Common is an auto-generated Perl module that packages Protocol Buffers schema definitions used by Google Cloud services, providing the Perl-side message and enum types needed to serialize and deserialize protobuf data when working with Google APIs. It is not a standalone client library but a schema container intended to be used by other modules that implement API calls, and it should be treated as generated code rather than something to edit by hand. The module is distributed under the Apache License 2.0.

WWW::Pastebin::PastebinCa::Create is a small Perl helper for posting text to pastebin.ca directly from your code. You make an object, call paste(content, ...) and get back a URI object pointing to the new paste while errors are exposed via error(). The module posts anonymously through the site's API and automatically solves the Turnstile proof-of-work challenge so you do not need an account or API key. You can tune network behavior with a timeout or provide your own WWW::Mechanize instance. paste() accepts options like name, language (numeric codes for syntax highlighting), and expire, with anonymous pastes required to expire and any empty or over-90-day value capped at the 90-day maximum. The desc and tags arguments are accepted for backwards compatibility but the rebuilt site no longer uses them. The module also exposes helpers to list valid language codes and expire values, and notes that pastebin.ca enforces spam protection so avoid excessive automated pasting.

Mojolicious::Plugin::BarefootJS makes it easy to use the BarefootJS server runtime inside a Mojolicious app by registering a bf controller helper that lazily creates a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo. The helper lets you render compiled marked templates as native Mojolicious templates so you can integrate BarefootJS rendering into your controllers and views with minimal configuration. This plugin is useful for Mojolicious developers who want to adopt BarefootJS templating and runtime behavior; projects running on other PSGI hosts can use BarefootJS::Backend::Xslate for a comparable integration without Mojolicious.

BarefootJS::Backend::Xslate is a rendering backend that lets the BarefootJS runtime render Kolon (.tx) templates using Text::Xslate, without tying you to any web framework. It can take a prebuilt Text::Xslate instance or build one from a list of template paths and options, and it configures Xslate for HTML auto-escaping while providing a mark_raw helper for emitting raw markup. Templates compiled by the companion @barefootjs/xslate adapter call runtime helpers as methods on a bound bf object, so the backend needs no special function map and works equally well inside PSGI/Plack apps or in standalone scripts. The module exposes a small set of runtime operations such as render_named, encode_json (customizable), materialize, and mark_raw, making it a lightweight bridge between BarefootJS templates and Text::Xslate rendering.

BarefootJS is a lightweight server-side runtime that supports templates compiled from JSX/TSX into BarefootJS "marked" templates and accompanying client JavaScript. It supplies the runtime helpers those compiled templates call at render time, for tasks like JSON marshalling, marking raw strings, materializing JSX children, spreading attributes, and invoking named sub-templates. The design deliberately avoids locking you into a specific template engine or web framework by delegating engine- and framework-specific behavior to pluggable backends such as BarefootJS::Backend::Xslate for Text::Xslate or Mojolicious::Plugin::BarefootJS for Mojolicious, so the core itself only pulls in Perl core modules unless a chosen backend requires more. If you need to render JSX-style templates from Perl in a PSGI/Plack or Mojolicious app and want a minimal, backend-agnostic runtime, BarefootJS is a good fit and it is actively maintained under the MIT license.

Email::Abuse::Investigator examines the raw source of spam and phishing messages to answer the practical questions an abuse investigator asks: where the message was injected, which web hosts and URLs are implicated, and which parties should receive abuse reports. It walks the Received header chain to find the originating IP and enriches it with rDNS and RDAP/WHOIS ownership, extracts HTTP/HTTPS links from plain and HTML parts and resolves their hosting networks, and collects contact domains from headers and mailto links to assemble registrar, hosting and nameserver intelligence. The module produces both a detailed analyst report and a compact abuse-report body, collates email and web-form complaint targets, runs heuristic risk scoring, and caches lookups to reduce redundant WHOIS and DNS queries. Optional modules such as Net::DNS, LWP::UserAgent, Domain::PublicSuffix, AnyEvent::DNS and CHI improve DNS resolution, redirect-following, accurate registrable-domain handling and cross-message caching when present. The recent 0.13 release tightens security around WHOIS and RDAP lookups to prevent protocol injection and to validate IPv6 zone identifiers, and it adds stricter CLI path validation. Note the documented limitations: bodies are not charset-decoded, the built-in MIME parser is a pragmatic rather than fully RFC-compliant implementation, WHOIS rate-limiting is not retried, IPv6 CIDR entries for trusted_relays are not matched, and the class is not thread-safe so you should create separate objects per thread.