CPANscan

Params::Validate::Strict is a schema-driven parameter validator for Perl that checks, coerces and documents input against a rich, reusable specification. You declare a schema (as a hash or ordered array of field specs) describing types like string, integer, number, boolean, arrayref, hashref, object, coderef, scalar, scalarref and the new void type, plus nested schemas, per-element rules, transformations, defaults, optional/nullable flags, callbacks, custom types, cross-field checks and relationship constraints, and the module returns a new hash or array of validated, coerced values or croaks with a clear error. Transformations run before validation so you can normalise input, and there are hooks for logging and handling unknown parameters. Note that the module does not untaint values and accepts caller-supplied regexes so you should avoid pathological patterns on untrusted data. The recent 0.37 release added a dedicated "void" type for asserting undef results and documented the existing unix_timestamp semantic check.

Termbox::PP is a lightweight, pure-Perl implementation of the termbox2 terminal UI library that makes it easy to build simple text-based interfaces. It gives you a small, consistent API for drawing into a cell-based back buffer, flushing updates to the screen, and receiving keyboard, mouse and resize events while supporting colors and terminal attributes. Because it is written entirely in Perl it requires no XS or external C libraries on Unix-like systems, though Windows support needs additional Win32 modules. The module can optionally enable extended grapheme cluster handling and varying color modes via compile-time options and it registers itself as Termbox.pm so you must load Termbox::PP before using Termbox. It is designed for portability and simplicity and aims to mirror the upstream C behavior, but it is still relatively new and may evolve as real-world usage reveals needs.

Sim::OPT is a Perl toolkit for automating optimization and parametric exploration of simulation models that use text files for input and output. It drives batch experiments by morphing model parameters, running block-based searches that can overlap, and mixing sequential and parallel update strategies analogous to Gauss-Seidel and Jacobi methods. The distribution includes modules to create metamodels from sparse results, to perform specialized search strategies such as star and factorial designs, and to manipulate models for specific platforms like the ESP-r building performance simulator, plus utilities for converting plots and tweaking shading calculations. You configure searches with simple text files and can run either new simulations or analyses from precomputed datasets, while example scripts and packaged demos show common workflows for ESP-r and EnergyPlus. The package installs via cpanm, exposes a convenient opt launcher, targets Linux environments, and is available under a dual open-source/proprietary license with the GPLv3 source on CPAN.

DateTime::Format::W3CDTF is a compact Perl module for parsing and formatting dates and times in the W3CDTF form, an ISO 8601 profile commonly used by RSS 1.0. It converts W3CDTF strings into DateTime objects and vice versa, and includes a strict mode that requires timezones as part of the input and output. It also offers a format_date helper to emit date-only strings. Note that the API is marked experimental and may change, parse_datetime may die on malformed input, and format_datetime no longer attempts to truncate DateTime objects that represent midnight because DateTime does not distinguish between a missing time and midnight.

Data::TopK::Shared provides a compact, shared-memory summary that tracks the most frequent keys in a stream using the Space-Saving algorithm so you can find top talkers like hot URLs, busy IPs, or popular search terms without storing a counter for every distinct key. It keeps a fixed number of counters (the capacity) so memory stays bounded, offers per-key estimated counts plus an error bound that gives a guaranteed interval for the true frequency, and supports sharing the same summary across processes via a backing file, an inherited anonymous mapping after fork, or a memfd. There is also an optional time-decay mode that weights recent observations more heavily by specifying a half-life and feeding timestamps. The API is simple: add keys or batches, request the top k as key/count/error rows, or query an individual estimate. Keys are handled as raw bytes and are truncated to a configurable key_size, so encode wide-character strings to bytes first and expect Linux-only, 64-bit Perl support. Accuracy improves with larger capacity and the module includes practical safeguards for concurrent writers and crash recovery, with a few edge-case caveats noted by the author such as PID reuse not being detected and an unlikely reader-slot exhaustion scenario.

PPI::App::ppi_version::BRIANDFOY is a small command-line tool for inspecting and updating Perl module $VERSION declarations using PPI so it understands real Perl syntax rather than relying on regexes. It is Brian d Foy's take on Adam Kennedy's PPI::App::Version and offers the same basic operations to show or change version strings with a default of "show" when called with no arguments and a shorthand that treats non-command arguments as a version change. It handles common forms like our $VERSION and will not warn on semantic versions such as v1.2.3. If you need a reliable way to report or bump version numbers across Perl files this module does that simply and safely, and recent updates include a namespace rename to PPI::App::ppi_version::BRIANDFOY while preserving the legacy BDFOY name plus packaging tweaks for PAUSE and version.pm compatibility.

Net::WoRMS is a Moo-based Perl wrapper around the World Register of Marine Species SOAP API that powers the query-worms tool, providing a simple way to query WoRMS for taxonomic data. It uses SOAP::Lite to fetch records and exposes methods to search species by name, retrieve a record by AphiaID, page through child taxa, and emit results in plain text, CSV, or SQL-ready formats while offering a debugging mode to dump raw responses. You can change output format, debugging and SOAP configuration but those change methods must be called before init and some namespace/endpoint tweaks are noted as untested by the author. The module performs basic SOAP error checking and will abort on communication errors so callers should be prepared to handle that, and it relies on common Perl modules such as Moo and SOAP::Lite.

Google::Cloud::Sql::V1 is a Perl client that lets you call the Google Cloud SQL Admin V1 API from Perl programs using a high-performance gRPC transport, making it easy to manage Cloud SQL resources programmatically. It is auto-generated from the protocol buffer schema and integrates with Google::Auth for credential handling, providing service-specific classes and example usage for both transport modes so you can match your environment; the package is newly released and maintained to track the upstream API. The module is distributed under the Apache 2.0 license and is most relevant if you need a direct, up-to-date Perl binding to Cloud SQL administration functions.

Google::Cloud::Secretmanager::V1 is a Perl client library for Google Cloud Secret Manager that lets Perl applications store, retrieve, and manage secrets through the V1 API. It uses a high-performance gRPC transport and integrates with Google::Auth for credentials so you can add centralized, auditable secret storage and programmatic access to secret versions in your server or cloud applications. The module is suitable when you need secure, cloud-native secret management from Perl code and is released under the Apache 2.0 license.

Google::Cloud::Privateca::V1 is a Perl client library for version 1 of Google Cloud's Certificate Authority Service (Private CA). It provides a straightforward way for Perl applications to talk to Google Private CA over a high-performance gRPC transport, enabling integration of certificate authority operations into automation and services such as creating and managing private CAs, issuing and revoking certificates, and querying certificate status. The module uses Google::Auth for authentication and follows the Google Cloud API surface for Private CA, and it is distributed under the Apache 2.0 license.

Google::Cloud::Iam::V1 is a Perl client library for interacting with Google Cloud Identity and Access Management (IAM) V1 over a high-performance gRPC transport. It integrates with Google::Auth for credentials and exposes the IAM API so you can manage roles, policies, permissions, and related access-control tasks from Perl code, making it useful for automating or embedding IAM operations in scripts and services. The module is focused on providing direct, programmatic access to Google Cloud IAM and is released under the Apache 2.0 license.

Google::Cloud::Datafusion::V1 is a Perl client library that lets Perl applications interact with the Google Cloud Data Fusion V1 API using a high-performance gRPC transport. Paired with Google::Auth credentials it enables you to perform Data Fusion operations from Perl code so you can automate and integrate tasks such as creating and managing Data Fusion instances and pipelines without working with raw HTTP calls. The module is intended for developers and administrators who need to control Data Fusion from Perl and is distributed under the Apache 2.0 license.

App::Tarotplane is the core Perl library behind tarotplane, a curses-based flashcard program, and it handles application initialization from command-line options and runs the interactive study session. It exposes simple methods to initialize and run the program and a testing-oriented accessor for inspecting internal settings, and it supports configurable card ordering including file order, random shuffle, and alphabetical order. If you need a terminal flashcard tool or want to embed, extend, or test tarotplane behavior from Perl, this module provides the essential interface.

Database::Abstraction is a lightweight, read-only Perl ORM-style layer that gives a consistent, SQL-free API for reading data from a variety of backends including CSV/PSV, XML, SQLite, BerkeleyDB, and now DBM::Deep or any DBI datasource via a DSN. You subclass it per table and call familiar methods like fetchrow_hashref, selectall_arrayref, count, or use the fluent query builder to compose where/order_by/limit chains, and AUTOLOAD provides quick column lookups; criteria support includes comparison operators, pattern matching, set membership, logical groupings, and automatic JOINs. Small files can be slurped into memory for very fast lookups and the module optionally caches results with a CHI-compatible cache and supports simple logging and schema introspection. Recent 0.37 enhancements add transparent remote file fetching via a host parameter (SSH/SCP into a temp dir), first-class DBM::Deep support with in-memory fast paths, and a security fix to validate key column names on object cloning. Note the module is read-only, the default CSV separator is "!" so set sep_char => "," for standard CSVs, XML slurp only handles simple flat structures, slurp mode assumes a unique key column, BerkeleyDB has limited features (no joins or chained queries), and column names must be valid SQL identifiers.

POE::Component::MetaCPAN::Recent is a small POE component that watches MetaCPAN for newly uploaded CPAN distributions and emits a POE event for each new upload. It polls the MetaCPAN recent feed and posts each discovered upload to an event name you supply when calling spawn so you can hook into existing POE sessions to log, notify, trigger tests, or update services. Spawn requires an event name and optionally a target session and the returned object provides session_id and shutdown methods. Each output event delivers the upload as a hashref in ARG0. Recent updates add a Digest::SHA prereq and a cache of seen AUTHOR/DIST pairs to avoid duplicate reports when the upstream feed provides buggy timestamps. This module is useful for CPAN authors, continuous integration, monitoring, or any automation that needs to react to newly published distributions.

Data::TimingWheel::Shared implements a shared-memory hashed timing wheel that lets you schedule and cancel large numbers of discrete-tick timers in constant time, making it useful for event loops, network stacks, and multi-process job schedulers where O(1) timer management matters. Timers carry a 64-bit payload and live in a fixed-size pool defined by a number of slots and a capacity, you add timers for a delay in ticks and call advance to move the clock and collect fired payloads in order. The wheel can be shared between processes via a backing file, an anonymous mapping inherited across fork, or a memfd passed between processes, and updates are protected by a futex-based write-preferring rwlock that provides crash-recovery for most cases. It is Linux-only and requires 64-bit Perl, and you should size the slots and capacity to your workload because the structure is fixed-size and will croak if full.

Data::Sync::Shared offers a compact suite of Linux-only, 64-bit-Perl synchronization primitives built on file-backed mmap and futexes so multiple processes can coordinate efficiently without pthreads. It implements five usable primitives—a counting Semaphore, a Barrier rendezvous, a reader-writer RWLock, a Condvar with a built-in mutex, and a Once one-time initialization gate—and supports anonymous, file-backed and memfd modes plus optional eventfd hooks for integration with event loops. The API gives timeouts on blocking ops, scope-based guard objects that auto-release locks, and crash-safety features that detect dead PIDs and recover most stuck locks, with a per-process reader-slot mechanism to prevent readers from pinning writers in normal use. If you need cross-process resource limiting, coordinated startup, reader/writer exclusivity, or condition waiting between forked workers, this module is directly relevant. Recent 0.07 fixes a bug where guards in forked children could release their parent’s lock and now ensure guards only release locks they acquired, and note that the on-disk format was bumped so older maps must be recreated and acquire_n now rejects requests above the configured maximum.

Data::Stack::Shared is a Linux-only, 64-bit-Perl module that provides a high-performance, shared-memory LIFO stack for multi-process programs. It offers int64 and fixed-length string variants and supports anonymous, memfd, or file-backed mappings so separate processes can push, pop, peek, and block with optional timeouts while sharing data without heavy locking. The implementation uses atomic operations and futex waits for multi-producer / multi-consumer safety, exposes capacity and statistics, supports eventfd notifications, and includes a concurrency-safe drain operation. Note that on-disk files use a new v2 format so older v1 stacks are incompatible. Recent releases hardened file permissions and fixed corner-case hangs and reclaim bugs so abandoned peers no longer block push/pop; drain can also force-recover slots stuck in "writing" after about two seconds, which in rare cases may discard a publish-in-flight.

Data::SpatialHash::Shared is a Linux-only, 64-bit Perl module that implements a concurrent, mmap-backed spatial hash so multiple processes can share a fast proximity index for 2D or 3D points. It stores positions in a cell grid and exposes efficient radius, k-nearest, box and cell queries, bulk insert/move operations, batched radius queries, and pair/collision emitters, with helpers for toroidal wrap, true 3D globe geometry and cube-sphere chunk/LOD ids. Access is synchronized with a futex read/write lock that supports crash recovery so readers and writers in separate processes can safely share the map, and it integrates with eventfd for external event loops. Maps may be anonymous, file-backed, or memfd-backed and include tuning knobs for cell size and bucket count plus runtime stats. Caveats the author notes are that it is Linux-only, requires 64-bit Perl, very old on-disk files are refused after a recent format upgrade so you must recreate prior maps, and the lock recovery has a rare PID-reuse edge case and a 1024-reader slot limit that can affect extreme deployments. Recent releases hardened security and robustness and changed the on-disk format while making newly created backing files private by default (mode 0600), with an option to supply a different file mode for cross-user sharing.

Data::SegmentTree::Shared provides a fast, shared-memory segment tree you can open from a file, memfd, or inherit across fork to hold a fixed array of signed 64-bit integers and perform range updates and queries in O(log n) time. It supports point set/add, range add, range assign, and range queries for sum, min, and max, and when built with assign-only updates it also offers gcd and product monoids; range_add/add permanently disable gcd/product and product will croak on 64-bit overflow. The structure uses lazy propagation so updates touch only a few nodes and a futex-based write-preferring rwlock lets many readers proceed concurrently while writers serialize, making it practical for multi-process use on Linux with 64-bit Perl. Be aware that mutations are not transactional so a writer killed mid-update can leave the tree internally inconsistent and should be treated as undefined until rebuilt, and the reader-slot table holds 1024 entries so extreme reader counts can create rare recovery issues. Recent 0.02 changes add range_assign and the gcd/product monoids and introduce an on-disk format change that prevents older files from being reopened.

Data::RoaringBitmap::Shared is a Linux-only, 64-bit-Perl module that implements a memory-shared Roaring bitmap — a compact, compressed set of 32-bit unsigned integers that can be accessed concurrently from multiple processes. It splits the 32-bit space into 16-bit buckets and stores the low 16 bits in per-bucket containers that are either sorted uint16 arrays or 65536-bit bitmaps, each occupying a fixed slot from a preallocated pool, so storage and performance adapt to sparse or dense data while capacity stays predictable. You can share a single bitmap across processes via a backing file, an inherited anonymous mapping after fork, or a memfd descriptor, and the API provides add, add_many, remove, contains, cardinality, min/max, to_array, and in-place union and intersect operations with a futex-based write-preferring rwlock that recovers from dead writers. Be aware that capacity is fixed at creation and pool exhaustion causes operations to croak, bitmap containers are not down-converted back to arrays in this version, xor/andnot and run containers are not yet supported, and there is a reader-slot table limit (1024) that makes a pathological crash scenario unlikely but possible. Recent 0.03 updates fixed a use-after-free bug in union/intersect, hardened security and robustness, and bumped the on-disk format to a new version so older 0.02 files are refused and must be recreated.

Google::gRPC is a high-performance gRPC client library for Perl that makes it easy to connect Perl applications to gRPC services. It provides the plumbing you need for reliable RPCs, including channel management and pooling, message framing and streams, deadline and status handling, and hooks for different transport engines. The distribution organises these capabilities into focused components such as Client, Channel, ChannelPool, Stream, Deadline, Status, and Engine so you can assemble a robust client for calling modern APIs like Google Cloud services. It is maintained under the Apache 2.0 license.

Protobuf is a Perl binding that brings high-performance Google Protocol Buffers to Perl by using the upb C library. It provides the familiar protobuf workflow for Perl developers, including generated message classes, a DescriptorPool for loading descriptors, and an Arena for efficient memory management, so you can create, serialize, and parse compact binary messages from Perl code with emphasis on speed and efficiency. The implementation aims to align closely with the official Python UPB-based extension, making it a strong choice when you need low-latency, high-throughput protobuf handling or interoperability with systems using Protocol Buffers.

Module::Starter::Protobuf is a Module::Starter plugin that automates creating skeletal CPAN distributions from proto3 files so you can quickly produce Perl client libraries for gRPC services. It runs protoc with the upb plugin to generate low level serialization classes and then scaffolds idiomatic, high level client wrapper modules with gRPC call methods, plus a dynamic integration test and a mocked Google::gRPC::Client constructor. The plugin also injects common runtime dependencies into the generated Makefile.PL and accepts protobuf input via arguments or the PROTOBUF_FILES environment variable, making it useful when you need a fast, consistent starting point for publishing Perl bindings for Protocol Buffers and gRPC services.

Google::Cloud::Storage::V2 is a Perl client for the Google Cloud Storage V2 API that talks to Google’s services over a high-performance gRPC transport. You instantiate it with Google::Auth credentials and then use the generated client classes to interact with buckets and objects from Perl programs, making it a good fit for server-side scripts and services that need efficient access to Cloud Storage. The client is auto-generated from the protocol buffer schema so it closely mirrors the official API, and it is released under the Apache 2.0 license. This distribution is new and actively generated from upstream protobufs, with the recent 0.03 update improving generated documentation and service class layout.

Google::Cloud::Spanner::V1::SpannerClient is a Perl client for the Google Cloud Spanner V1 API that lets Perl applications interact with Spanner databases to create sessions, run SQL queries, read and write rows, manage transactions and commits, and work with advanced features like change streams. It exposes the service surface and typed message objects you expect from Spanner such as Mutations, ResultSets, Transactions and QueryPlans so you can map your application operations directly to the database API. This module is a generated gRPC/protobuf client, so it is best suited for developers who need programmatic, low-level access to Cloud Spanner from Perl and who can supply Google Cloud credentials and network access to their Spanner instances.

Google::Cloud::PubSub::V1 is a Perl client for the Google Cloud Pub/Sub V1 API that uses a high-performance gRPC transport to let Perl programs publish messages, subscribe to topics, and manage subscriptions. The module is auto-generated from the protocol buffers schema and exposes service classes that mirror the Pub/Sub API, so you instantiate a client with Google::Auth credentials and call the usual publish and subscription methods without dealing with low-level gRPC plumbing. It is aimed at developers who need low-latency, programmatic access to Pub/Sub from Perl and includes documentation with dual-transport examples. The code is Apache 2.0 licensed and the recent 0.03 release notes indicate regenerated clients with separate service classes and improved POD documentation.

Google::Cloud::NetworkServices::V1 is a Perl client for Google Cloud Network Services V1 with a focus on Secure Web Proxy functionality. It gives Perl applications a straightforward way to call the Network Services API over high-performance gRPC and integrates with Google::Auth for credential handling. The package is auto-generated from Protocol Buffers so it exposes the service methods you need to manage proxy and network resources in Google Cloud while including usage examples for different transports. It is released under Apache 2.0 and is a new, actively maintained binding that is suitable for developers who need programmatic access to Google Cloud Network Services from Perl.

Google::Cloud::NetworkSecurity::V1 is a Perl client library for Google Cloud's Network Security V1 API that uses gRPC for high-performance, low-latency calls and integrates with Google::Auth for authentication. It provides generated service classes so your Perl code can manage Network Security resources such as address groups without working directly with protobufs or raw HTTP calls. The module is auto-generated from the protocol buffer schema, is available under the Apache 2.0 license, and includes example documentation showing gRPC and alternate transport usage. The recent 0.03 release added separate service classes, fixed regexes, and improved POD with dual-transport examples and encoded proto path information.

Google::Cloud::Metastore::V1 is a Perl client for the Google Cloud Dataproc Metastore V1 API that lets Perl programs manage Dataproc Metastore services and related metadata over a high-performance gRPC transport. It integrates with Google::Auth for obtaining credentials and is suitable for tasks like creating, inspecting and controlling metastore services and long‑running operations from Perl code. The client is autogenerated from Protocol Buffers so it follows the official API surface closely and includes generated documentation and examples for gRPC and alternate transports. The module is newly released (0.03), actively regenerated as the API evolves, and is distributed under the Apache 2.0 license.