CPANscan

Protobuf is a Perl module that provides fast, low-overhead support for Google Protocol Buffers by binding to the upb C library. It lets you load descriptors or use generated message classes to create messages, serialize them to compact binary form, and parse binary data back into native Perl objects. The API includes helpers like DescriptorPool and Arena so it fits into standard protobuf workflows and emphasizes performance and compatibility with upb-based implementations. Choose this module when you need efficient protobuf serialization and deserialization in Perl for services, storage, or cross-language data interchange.

Google::gRPC is a high-performance gRPC client library for Perl that handles channel management, message framing, stream lifecycle, deadlines, status codes, and pluggable transport engines so Perl applications can talk to gRPC services such as Google APIs. It exposes focused components like a Client, Channel, Stream, Deadline, and Engine to make creating and managing gRPC connections straightforward, for example by instantiating Google::gRPC::Client->new with a target host and port. Recent work has improved portability and robustness by adding a native nghttp2 C/XS transport with a dynamic fallback to a pure-Perl Protocol::HTTP2 engine when libnghttp2 headers are not available, and the project now includes comprehensive POD documentation and test coverage to make adoption easier.

Google::Auth is a lightweight Perl library from Google that handles application default credentials and automatic project ID detection so your Perl programs can authenticate to Google APIs without custom credential plumbing. It provides a simple default($scopes, $options) entry point that returns the right credential type for the environment, whether that is a service account key, Compute Engine metadata tokens, or federated credentials, and it manages token refresh for you. Recent releases modernized the native crypto bindings for OpenSSL 3.0, expanded Workload Identity Federation and AWS IAM support, and fixed native memory handling issues in XS code to improve stability. The module is maintained by Google, documented via perldoc, and distributed under the Apache 2.0 license.

App::OrgUtils is a toolbox of small command-line utilities for working with Emacs Org‑mode files, offering scripts to list and count todos, headlines, tags, priorities and anniversaries, dump or inspect document structure, convert Org to HTML or plain text (including a Wordpress-targeted converter), sort or reverse headlines, and move or report on completed tasks. Built on Org::Parser, it is aimed at people who keep notes, task lists or calendars in Org files and want quick, scriptable ways to query, transform or export that data without writing their own parser. The distribution is script-focused and also serves as example code for integrating Org::Parser into other tools. The recent release makes parsing more robust by ignoring unknown drawers and settings by default so files with nonstandard metadata produce less noise.

Mail::Milter::Authentication is a Perl server framework that runs the authentication_milter service, providing the preforking process management and lifecycle hooks needed to apply email authentication standards from a single milter. It subclasses Net::Server::PreFork and supplies hooks for parent and child initialization, per-request processing, logging and debugging, and utilities for loading and managing modular protocol and handler components. The module also includes daemon control helpers such as start/stop/restart/status, PID and process discovery, panic email reporting, and convenience methods to inspect client details and queue IDs. Use this if you are deploying or developing an authentication milter in Perl and need a ready-made server backbone to load handlers that implement DKIM, SPF, DMARC, or other authentication logic.

POE::Component::Server::JSONUnix is a small event-driven server that listens on a Unix domain socket and speaks newline-delimited JSON, providing a simple local RPC or control endpoint for daemons, command line tools, and cron jobs. It is built on POE and exposes a pluggable command dispatch you can supply at spawn time, add at runtime, or expose by subclassing, and handlers may reply synchronously, raise errors, or answer asynchronously via a context object. The module includes handy built-ins like ping and commands and offers an ownership-based authentication handshake plus an optional per-command permission policy that can restrict access by user or group with group lookups cached per connection. It handles malformed requests and errors without disturbing other clients and will remove stale socket files on startup unless another process is actively listening.

Class::Factory is a small, practical base class for implementing the Factory Method pattern in Perl so you can map simple type names to implementation classes and create objects dynamically. You subclass it to define a common interface, then register or add types that the factory can build; add_factory_type brings a class in immediately while register_factory_type records a mapping and only loads the class when it is first requested. The module provides a standard new() constructor, helpers to list, remove or look up registered and loaded types and classes, and introspection methods so an instance can report which factory and type created it. You can override factory_log and factory_error to hook in your own logging or error handling. One important gotcha is that type mappings are stored under the class name used to register them, so register or add types on the original factory class to avoid surprises.

App::Test::Generator is a toolkit that helps Perl authors automatically create strong black‑box tests for routines and modules by turning formal input/output schemas or heuristically extracted signatures into ready‑to‑run Test::Most fuzzing harnesses. It combines randomized fuzzing, deterministic boundary cases, static corpus tests and optional property‑based checks via Test::LectroTest, and also bundles mutation testing, LCSAJ path metrics, a test‑quality dashboard, benchmark script generation, POD example round‑trip testing, and helpers to deploy CI workflows so you can run continuous fuzzing and mutation‑guided test generation in GitHub Actions. If you maintain CPAN modules or any Perl library and want to surface boundary errors, bad input handling, flaky behavior or surviving mutants without hand‑writing hundreds of cases, this module is directly relevant. The recent 0.44 release fixes side‑effect problems so generated runs no longer leave stray files, improves SchemaExtractor accuracy and robustness when inferring or respecting explicit POD types, and adds an end‑to‑end self‑fuzz test to validate the toolchain.

Data::Record::Serialize::Encode::table is a small Perl add-on that formats record data as a nicely aligned, human readable table and writes it to a file, a scalar, a GLOB, or any IO::Handle via the Data::Record::Serialize framework. It plugs into Data::Record::Serialize as an encoder and a sink and delegates the actual table layout to Term::Table, so you can control appearance with the usual Term::Table options like padding, width, and header behavior. You should not construct it directly but request it with encode => 'table' from Data::Record::Serialize and supply the required output parameter, which accepts a filename (use "-" for stdout), a scalar reference, a GLOB, or an IO::Handle; if you hand it an open handle it will not close that handle for you. There is an option to create the output directory automatically and any other Term::Table parameters are passed through unchanged. This is the initial 0.01 release.

Module::CoreList is a utility library and command-line tool that lets you look up which modules and versions shipped with specific Perl releases, helping you answer questions like whether a module is part of core, when it first appeared or was removed, and whether it has been deprecated. It offers a simple programmatic API for queries such as first_release, first_release_by_date, is_core, is_deprecated, removed_from and changes_between, plus a corelist command for quick checks from the shell. For power users it exposes data structures like %Module::CoreList::version, %delta, %released and %families and metadata about upstreams and bug trackers so you can script comparisons or audits of core module content. The module is actively maintained to follow new Perl releases and recent updates add data for the latest Perl versions, so it is a good choice if you need accurate, historical or current information about what shipped with any given Perl.

CPAN::Perl::Releases provides a static mapping from Perl release numbers to the CPAN authors/id path where that release's tarballs live, so you can look up where to download specific perl versions without scraping indices. Its perl_tarballs function takes a version string and returns a hashref of available archive types such as tar.gz, tar.bz2 or tar.xz pointing to their relative authors/id locations or undef if not found. The module also offers perl_versions to list all supported release numbers in order and perl_pumpkins to list the PAUSE IDs of Perl maintainers. The data is shipped with the module and is updated when new Perl releases are uploaded to CPAN, making this a simple, reliable helper for tools that need to locate Perl tarballs.

HTTP::Message is the core Perl class for representing an HTTP message as a set of headers plus a content body and is the base object used by higher level HTTP::Request and HTTP::Response classes. It provides constructors and parsing from strings, accessors for headers and raw content, efficient in-place content manipulation via content_ref, helpers for serializing or dumping messages, and support for multipart messages and message parts. The module also handles common content encodings and charset decoding for textual and XML media types and can apply or remove encodings like gzip, deflate, bzip2, brotli and base64 when the appropriate supporting modules are available. It delegates the wide range of header conveniences to HTTP::Headers and includes safeguards such as a configurable maximum decompressed body size to avoid unexpectedly large responses. The current release fixes a brotli decoding issue where responses could fail to decode when a maximum body size limit was set.

NBI::Slurm is a Perl toolkit that makes it easy to create, configure and submit jobs to SLURM on HPC clusters. It supplies NBI::Job to represent job scripts and NBI::Opts to declare queues, threads, memory, walltime and other SLURM options, and it includes command line utilities such as runjob, lsjobs and viewjobs so you can submit jobs, inspect output and track their status without writing raw sbatch scripts. The library wraps common tasks like generating SLURM headers, checking available queues and capturing command output so you can obtain job IDs and manage jobs programmatically. Recent updates added a slurm-status utility and improved support for job arrays to make monitoring and running array workloads simpler.

DBIx::QuickDB makes it trivial to spin up temporary database servers for testing and development so you can get a real PostgreSQL, MySQL/MariaDB/Percona, SQLite or optional DuckDB instance up and running in a disposable directory and connect to it with DBI. You can declare named databases at compile time that expose connectable constants or create them on the fly with build_db, and each instance can be tuned with a spec (autostart/autostop, bootstrap, cleanup, data directory, driver choice, SQL to preload, and more). It is designed for test suites and short-lived environments and will automatically manage startup, shutdown and optional cleanup of the data directory, so do not enable cleanup on any important persistent database. Environment variables like QDB_TMPDIR and DB_VERBOSE control temp locations and server output, and recent improvements added a no_disconnect_handles option for callers that keep live DBI handles and made teardown and Windows cleanup far more robust.

MooX::LazierAttributes provides a compact DSL for declaring Moo or Moose attributes so you can write far less boilerplate when building attribute-heavy classes. It exports an attributes() helper that turns concise array-style specifications into full has declarations and a set of small constants like is_ro, is_rw, lzy, bld and handy defaults such as lzy_array or dstr to reduce repetition when declaring read-only or read-write, lazy, typed, built or required attributes. The module understands Types::Standard and Type::Tiny constraints, accepts CODE-ref defaults and lazy builders, and includes support for extending parent attributes with a '+name' syntax. Recent notable improvements added attribute extension with '+', Type::Tiny support, defaulting to ro when omitted, and a coe constant for coercion, making it a simple way to keep attribute declarations clear and concise.

Eshu is an XS-powered tool that automatically fixes indentation and produces syntax-highlighted HTML for a wide range of programming and markup languages. It rewrites only leading whitespace while tracking language-specific nesting so your code content stays intact and the output is consistently formatted. You can call per-language methods from Perl or use the convenience dispatcher to detect language by filename, and there is a command-line tool and a vim plugin for editing workflows. The library supports many languages out of the box including C, Perl, JavaScript and TypeScript, Python, Go, Rust, Java, PHP, Ruby, Lua, Bash, SQL, YAML, JSON, XML/HTML, CSS and POD, and it offers options to use tabs or spaces and to set indent width. It also provides file and directory helpers that can run dry runs, produce diffs, write fixes back to disk, and skip binary or oversized files. The highlighting API returns HTML with span classes for tokens so it can be styled easily. Recent releases added an XS-backed highlighting pass and expanded language support to TypeScript, Python, Go, Rust, Java, PHP, Ruby, Lua, Bash, SQL, YAML and JSON.

Font::Metrics gives you accurate glyph advance widths, kerning adjustments, and basic typographic metrics for the PDF Standard 14 fonts and for TrueType/OpenType fonts loaded from disk, so you can measure text in points at any requested size. It exposes simple methods to get a single character's advance, the width of a string, ascender and descender distances, cap and x heights, natural line height, and the kerning adjustment for a pair of characters; note that string width does not apply kerning automatically so you can add kern_pair between pairs when you need exact layout. Standard 14 metrics come from Adobe AFM data and include the most visually important Latin kern pairs for Helvetica and Times families while Courier, Symbol and ZapfDingbats have no kerning. TrueType/OpenType loading reads the usual font tables including head, hhea, hmtx, cmap, OS/2, kern and GPOS and merges kerning from kern and GPOS with GPOS taking precedence, and cap/x height values come from OS/2 when available with sensible fallbacks for older fonts. This initial release implements the core measurements and table parsing needed for accurate typography and page layout.

Mnet is a compact toolkit of Perl modules for building testable network automation and reporting scripts with minimal fuss. It provides Expect-based CLI helpers for reliable SSH and device interaction, stanza parsing for indented device configs, a report table engine that can emit csv, json or sql, a test recorder/replayer to record expect sessions and replay them for offline regression tests, batch processing for concurrent device runs, and small helpers for logging, command line options with password redaction, and IP parsing. You can use the pieces independently or together to log into routers and switches, capture and parse configuration or interface data, aggregate results, and run repeatable tests during development. The project is actively maintained and the latest release removed parsed environment variables after option parsing to reduce credential exposure and fixed minor warnings.

Mojolicious::Plugin::Fondation::Menu is a small plugin for the Mojolicious Fondation framework that provides database-backed, declarative menu management for web applications. Menus are declared in a share/menus.json file inside each plugin and synchronized to the database with a single "menu sync" command. The system supports hierarchical menus, ordering, icons and colors, visibility conditions based on groups or permissions, open-tab flags and optional descriptions. It installs helpers to fetch and render menus and breadcrumbs and to check visibility conditions, and it exposes a simple REST API with CRUD endpoints and permission checks for admin tooling. This is a lightweight way to centralize and manage navigation items across plugins while keeping rendering ACL aware. The module is at version 0.02 and provides the initial feature set.

Mojolicious::Plugin::Fondation::MigrationDBIx adds an integrated "db" command suite to Mojolicious applications that use DBIx::Class via the Fondation DBIx::Async plugin, letting you generate and apply schema migrations, copy and load fixture data, and inspect or change the database version from the command line. It can bootstrap a minimal Schema class, produce migration SQL from your Result classes, discover and copy fixtures shipped by plugins into your app, run installs, incremental upgrades and downgrades, show migration status, and populate the database from versioned fixture sets. Backend selection and database driver are resolved from your configured DB backends so you do not need to hardcode drivers, and a schema drift helper warns if your live schema differs from prepared migration files while leaving the app running. Configure the target backend and migrations directory if you need nonstandard locations. This plugin is useful if you want a straightforward, plugin-aware workflow for managing DBIx::Class schema changes and test or seed data in Fondation-based Mojolicious apps.

Mojolicious::Plugin::Fondation::Perm is a small plugin that brings permission management into Fondation-based Mojolicious applications, letting developers centralize authorization logic and enforce access rules within their web app. It is aimed at projects using the Fondation stack that need a built-in way to check and apply permissions so you do not have to invent your own access-control wiring. The module is lightweight and focused on integration rather than changing Fondation itself and the recent 0.02 release simply cleans up the package by removing unnecessary fixtures.

Mojolicious::Plugin::Fondation::Setup provides an interactive web setup wizard at /setup to configure Fondation-based Mojolicious apps. It discovers Fondation plugins on MetaCPAN, shows which are installed and which are missing, and helps you select plugins while automatically including dependencies. For missing modules it displays the exact cpanm command to run and pauses configuration until they are installed. For each installed plugin that exposes a setup schema via fondation_meta the wizard presents a simple form with fields prefilled from any existing .conf file, then generates a final application configuration file (e.g. myapp.conf). All wizard state is stored in Mojolicious sessions so no database or files are required to track progress and a reset route clears the session. The plugin integrates with the Fondation workflow and uses Fondation::Layout::Bootstrap for its pages.

EV::Etcd is a high-performance asynchronous etcd v3 client that embeds the native gRPC Core C API into the EV/libev event loop to provide non-blocking access to the full etcd feature set. It supports key-value operations, watches, lease management and keepalives, distributed locks, authentication and role/user management, maintenance and cluster administration, leader election and transactions. Streaming operations return handle objects you can cancel and can optionally auto-reconnect with configurable retry limits and health callbacks. Callbacks receive structured response and error hashrefs with a retryable flag so you can implement application-level retry for unary RPCs which do not retry automatically. Keys and values are treated as raw bytes so you must encode and decode character data yourself. Be aware that callbacks are stored in C structures which can retain references until streams are cancelled and that client objects are not safe to use after fork.

Alien::SNMP is an "Alien" installer that downloads, builds, and exposes the Net‑SNMP C library and its Perl bindings so you do not have to provide libnetsnmp yourself. It makes the library available to other Perl modules and build scripts by providing bin_dir for the net‑snmp utilities, plus cflags and libs for compiling and linking against the installed library. The build is tuned for a client-side footprint with IPv6 and AES support enabled and with the SNMP agent, manuals, MIBs, embedded Perl, and extra scripts disabled, so it is a good choice if you only need the library and Perl extension for SNMP tasks rather than a full SNMP agent deployment.

BATsh is a pure-Perl bilingual shell interpreter that lets you mix Windows cmd.exe batch syntax and POSIX sh/bash syntax in the same script and switches between modes automatically on a line-by-line basis. CMD and SH sections share a common variable store so data set on one side is immediately visible to the other. The module implements many familiar shell features such as pipelines, I/O redirection, functions, arrays, tilde expansion, getopts and traps and runs entirely inside Perl so you do not need an external cmd.exe or bash to execute scripts. Non-builtins are still executed by the host operating system so availability of commands like FINDSTR or SORT depends on the platform. BATsh also supports CP932/Shift_JIS auto-detection and character-aware substring/length operations for Japanese Windows scripts. Recent 0.07 updates include important security hardening to make SH redirection and process-substitution safe against quoting and injection issues and fix several quoting and subshell bugs.

Devel::Cover::Report::Codecovbash converts Devel::Cover output into the JSON file the Codecov bash uploader expects, making it easy to push your Perl coverage results to codecov.io. By default it writes cover_db/codecov.json when you run cover -report codecovbash and that file can then be uploaded with the official Codecov bash script. The reporter bridges a small semantics gap between Devel::Cover, which reports statement coverage, and Codecov, which measures line coverage; by default a line is treated as covered if any statement on it is covered and you can opt in to require all statements on a line to be covered via the DEVEL_COVER_CODECOVBASH_COVER_ALL_STATEMENTS environment flag. The module is lightweight, MIT licensed, and its source is available on GitHub. Recent work added the per-line policy option so you can choose stricter line coverage semantics when needed.

DBI is the standard, database‑independent interface for Perl that gives your scripts a single, consistent way to connect to many different databases through driver modules (DBD::*) and to perform SQL work with a simple API: connect, prepare, execute, fetch, commit and disconnect. It supports prepared statements and placeholders for safe, efficient queries, transaction control, and convenience helpers such as selectrow_*/selectall_* and selectcol_arrayref, plus cached prepares and cached connections to reduce overhead. Error handling and behavior are configurable via handle attributes like RaiseError, PrintError and AutoCommit, and it also provides tracing and profiling facilities to diagnose performance or correctness issues. Because DBI is an API layer and not a database driver, the exact capabilities available to you depend on the DBD driver you choose, but DBI’s wide adoption and active community mean drivers exist for most mainstream databases. The recent 1.651 series includes important security and robustness fixes, addressing several CVEs, tightening placeholder handling and out‑of‑bounds checks, and improving DBD::File safety, and the project warns that the next release will require Perl 5.12, so plan upgrades and driver compatibility checks accordingly.

Crypt::SysRandom is a small, portable Perl module that gives you cryptographically secure random bytes straight from the operating system via a single function, random_bytes($count). It automatically selects the best available backend for your platform, trying an XS implementation first, then Windows RtlGenRandom via Win32::API, and finally /dev/urandom on Unix. Use it when you need true system randomness for keys, nonces, salts, session tokens or any other security-sensitive data. The API is minimal and easy to drop into existing code so you can rely on OS-provided entropy without implementing randomness algorithms yourself.

Test::CPANfile is a small test helper for Perl distributions that checks whether your cpanfile actually lists every module your code "use"s. It scans your source and test files and reports a failing test when a used module is only declared as a recommend or suggest instead of a require, while ignoring core modules by default unless you change perl_version or set exclude_core. You can tune its behavior to include test helper PMs, add extra library directories for private modules, ignore specific files or patterns, and extend checks to recommends, suggests or develop phases. For ambiguous cases you can pass a CPAN::Common::Index instance so a used module passes if its distribution contains a sibling module listed in cpanfile. It integrates with Test::More and exposes a single cpanfile_has_all_used_modules() call with options to customize scanning and matching.