CPANscan

Module::Generate::Hash is a small utility that builds Perl distributions and classes from a simple hash-based specification, exporting a single function named generate that accepts a hash describing the distribution name, author, version and the classes to create. You provide a declarative structure for each class including abstract text, package variables, begin blocks, accessors and subroutines with code references, POD and examples, and the module generates the corresponding module scaffolding for you. It is useful for authors, tooling and tests that need to produce multiple modules or boilerplate programmatically and saves time compared with hand-writing repetitive code.

Module::Generate is a Perl scaffolding tool that programmatically builds distributions, packages and their test files so you do not have to hand-write repetitive boilerplate. Via a fluent API you declare the distribution name, author and version, add classes and then define constructors, accessors, methods, POD with examples, tests and compile-phase blocks, and even create reusable macros and custom keywords to inject shared code across classes. It writes out ready-to-run module files and test skeletons to speed up module development and release preparation, so it is best suited to Perl authors and maintainers rather than end users of a library. The recent 1.03 update removes generated links to AnnoCPAN and CPAN Rating and fixes POD versioning so generated documentation reflects the module version.

Cpanel::JSON::XS is a fast, C-implemented JSON encoder/decoder for Perl that prioritizes correctness and full Unicode handling while offering a rich set of configuration options for common needs like pretty printing, ASCII/latin1/binary output, canonical key sorting, bignum support, and controlled handling of blessed objects. It preserves round-trip fidelity for JSON-representable data, supports incremental parsing and BOM detection, is thread-safe, and is the actively maintained cPanel fork with a public issue tracker so bugs get fixed promptly. It integrates cleanly with JSON::MaybeXS so you can get its speed transparently and offers defensive defaults and limits to avoid resource or security issues, though note the allow_nonref behavior was changed to permissive by default in a recent release and can be disabled if you require strict top-level array/object enforcement. The very latest updates include a canonical sort fix that now compares keys by UTF-16 code units to match RFC 8785 and a quadmath-related float formatting fix to avoid dropping “.0” on high-precision platforms, plus many practical bug and security fixes across platforms and Perl versions.

Net::DNS is a mature collection of Perl modules that give you full DNS resolver functionality beyond the simple gethostbyname/gethostbyaddr calls, letting Perl programs perform lookups, zone transfers, asynchronous queries, and dynamic DNS updates. It models DNS concepts with Resolver objects for query state, Packet/Header/Question objects for responses, and RR objects for resource records, and it provides convenient helpers such as rr() and mx() for common lookups, rrsort() for ordering records, and builders for update prerequisites and add/delete operations. The module also includes utilities for managing zone serial numbers and supports AXFR and background queries, so it is a good fit if you need to script DNS administration or implement protocol-aware DNS clients in Perl. Expect to be comfortable with basic DNS concepts and zone file formats to use it effectively. The project is actively maintained at NLnet Labs and is widely used, but the authors note that Net::DNS can be relatively slow compared with some lightweight alternatives.

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.

Perl::Critic::Policy::ErrorHandling::RequireReturnFromEval is a lint rule for Perl that insists you use an explicit return inside block-form eval expressions so the value returned by the eval is obvious and your intent is clear. It flags eval { ... } blocks that omit a return, helps make error handling and value capture more readable and less error prone, and only applies to eval blocks not to string eval. The policy is unconfigurable, is classified as medium severity under the style theme, and is useful if you want consistent, explicit coding style around eval-based value capture.

Music::VoicePhrase is a compact generator for measured musical phrases that combines pitch and rhythm to produce motif-based voices for algorithmic composition or live MIDI use. You create an object, tweak straightforward attributes like base note, scale, octave, phrase size, duration pool and motif count, then call build_motifs and build_voices to get rhythmic motifs and pitch lists generated via Music::Duration::Partition and Music::VoiceGen. The module also targets real-time workflows by exposing name, patch, channel, gate, volume, a note queue and a rest probability, and it includes a free-form metadata hash for external processing. Defaults are friendly for quick experiments, for example C major and a four beat phrase, and the API is intentionally simple. Recent updates improved the documentation and added the metadata and real-time friendly attributes to make integration easier.

App::CSVUtils is a bundle of command‑line tools for working with CSV data and a small framework for generating your own CSV utilities. It provides dozens of ready-made scripts for common tasks such as selecting, deleting and reordering fields, filtering and grepping rows, sorting, splitting, concatenating and transposing files, computing sums and averages, producing frequency tables, filling templates, converting to other formats like TSV or VCF, and many more, plus options for header handling, custom separators and quoting. If you are a Perl developer you can also use the supplied gen_csv_util helper to produce new Rinci-style CLI utilities with automatic help, tab completion and sensible input/output handling. The distribution is aimed at convenience and flexibility rather than maximum performance, so very large CSVs may be better handled by a C-based tool. Documentation and source are on CPAN and GitHub. In the latest release the shuffling utilities csv-shuf-rows and csv-shuf-fields were fixed to use List::Util::shuffle for better randomness.

sshca is a small, command-line SSH Certificate Authority that helps you create a CA directory and issue SSH user and host certificates from public keys, making it easy to adopt short-lived certificate-based SSH authentication. The tool tracks issued certificates and serial numbers, supports adding principals and certificate options, can renew certificates using previous request data, list and filter certificates, and clean up expired certs. Configuration is handled with a YAML file and defaults to ed25519 keys and sensible validity windows, while environment variables and command-line flags let you override behavior. Storage is currently filesystem-based with planned support for database backends, and features like revocation and history are noted as future work. Overall it is a simple, practical choice for sysadmins who want a lightweight way to tighten SSH access without deploying a complex CA system.