CPANscan

Tk::ListBrowser is a Perl/Tk canvas widget that gives you a highly configurable, graphical list browser for desktop GUIs, letting you display items as a simple vertical list, a horizontal bar, a grid of rows or columns, or a hierarchical tree or hlist. It supports images and multiline text per item, sortable and draggable headers, optional side columns, keyboard and mouse selection, on-the-fly filtering, and a wide range of layout and cell-size options so you can tune appearance and behavior. You manipulate content programmatically with intuitive methods to add, remove, hide, show, sort, and refresh entries, and you can switch arrange modes without losing data, though tree-style hierarchies need a one-character separator to work properly. The widget is optimized for small to medium lists of a few hundred items, custom fonts can slow refresh, and there is an autorefresh mode and tools to control background refresh cycles to balance responsiveness.

SPVM::Go brings the Go programming language's concurrency model to SPVM by providing lightweight goroutines and typed channels so you can spawn many concurrent tasks and coordinate them with selects, wait groups, contexts, timers and signal helpers. The runtime uses the libuv event loop so blocked goroutines do not busy-wait but are suspended efficiently, keeping CPU usage low and allowing thousands of concurrent routines in a single process. It offers simple APIs to create goroutines, make buffered channels, wait on I/O with timeouts and sleep in nanoseconds, and notes that certain scheduler and I/O wait methods must be called from the main thread. A SPVM_GO_DEBUG environment switch is available for debugging.

Net::Connection is a lightweight Perl class for representing a single network connection as an object, letting scripts encapsulate local and remote host and port, protocol, state, process id and owner, send/receive queue sizes, and optional metadata like PID start time or wait channel. You construct instances from a hash reference and then use simple accessor methods to get values such as local_host, foreign_port, proto, pid, username, pctcpu and pctmem, with optional features to resolve numeric UIDs to usernames, perform PTR lookups for IPs, and translate port numbers to service names. The module keeps things simple and pragmatic so some fields may be undefined if not supplied and protocol and state strings are not strictly validated due to OS differences. It is a handy building block for tools that collect, normalize or display netstat-style connection information in Perl.

Proc::ProcessTable::ncps is a Perl module for producing an enhanced, optionally colorized ps-style process listing with flexible filtering, formatting and an easy string output you can print or embed in scripts. It builds on Proc::ProcessTable and uses Proc::ProcessTable::InfoString for its info column and Proc::ProcessTable::Match for advanced selection, and you control which columns appear via a simple args hash to its constructor such as showing faults, thread counts, TTY, JIDs or a final stats summary for CPU, memory and runtime. The module tries to be portable across platforms by detecting physical memory with POSIX::sysconf or sysctl and by hiding or erroring on columns the OS does not provide so it behaves sensibly on systems like OpenBSD and Linux. Recent releases improved robustness and portability by computing missing pctmem and RSS when the OS omits them, fixing OpenBSD crashes, tightening command line and option handling, and addressing Linux pctcpu inf or NaN issues in the latest update. The code is actively maintained on GitHub and is released under the Artistic License 2.0.

Google::Cloud::Kms::V1 is an auto-generated Perl client for Google Cloud Key Management Service that lets Perl applications manage keys, key rings, external key manager (EKM) connections, autokey settings and single-tenant HSM instances. It supports both high-performance gRPC over HTTP/2 and a REST transport and integrates with Google::Auth to use Application Default Credentials automatically, while handling requests and responses as typed Protocol Buffers. You construct the client with new and invoke RPC-like methods such as list_key_rings, create_key_handle, list_ekm_connections and update_autokey_config to perform KMS operations. The library is generated from the official proto definitions and is released under the Apache 2.0 license, making it a ready-to-use option for Perl developers who need authenticated programmatic access to Cloud KMS.

Proc::ProcessTable::InfoString is a small helper for producing a compact, ps-like status string from Proc::ProcessTable process objects, showing a one-letter process state code, symbolic process flags, and the wait channel. You instantiate it and optionally supply ANSI color names for the flags and wchan sections, then call info($proc) to get a human-friendly status snippet for each Proc::ProcessTable::Process; invalid input returns an empty string. Flag detail varies by platform with FreeBSD providing the richest set and Linux a subset, otherwise only state and wchan are shown. This module is handy when you want a concise readable status column for monitoring scripts or custom process-listing tools.

Proc::ProcessTable::Match provides a lightweight, composable way to test Proc::ProcessTable::Process objects against a stack of reusable checks. You construct it with an ordered list of check specifications, each naming a checker module (resolved under Proc::ProcessTable::Match::), supplying that checker's arguments, and optionally inverting its result. The match method evaluates the checks and returns true only when the full stack of checks passes and it will die if given an undefined or non Process object. This module is useful when you need to filter or search process tables programmatically and it is easy to extend by adding new checker modules in the Proc::ProcessTable::Match:: namespace.

PDF::Reuse::Barcode is a companion to PDF::Reuse that renders barcodes and QR codes directly into PDF pages so you can place machine-readable symbols at precise coordinates. It delegates pattern generation to existing barcode libraries like GD::Barcode and Barcode::Code128 and supports common symbologies such as Code128, Code39, EAN13, EAN8, UPC, several 2-of-5 variants, NW7 and QR codes, with options to scale, stretch, rotate, add or suppress human readable text, and draw a colored background box. For EAN and UPC types it can compute the check digit when not supplied, and QR generation exposes error correction level, version, module size and padding controls. You call the module from Perl alongside PDF::Reuse and pass parameters like x, y, size, xSize, ySize, prolong, text and drawbackground to control placement and appearance. Be aware that some longer "guard" bars or rotated images can look blurred on-screen though they print correctly at sufficient DPI, and you should test scanners if you change bar proportions. If you need barcode images embedded into PDFs with flexible layout and minimal fuss, this module provides a straightforward, library-backed way to do it.

PDF::Reuse is a Perl library for fast, programmatic reuse and mass production of PDF files that lets you assemble new documents from existing pages, forms and images while adding text, bookmarks, links and JavaScript, so it is ideal for templated output, mail‑merge and stamping workflows. It exposes both convenient high level routines and low level PDF operators so you can import pages or images, embed TrueType fonts with UTF‑8 support via prTTFont, attach or run JavaScript, create compact reusable XObjects and log document changes for archiving. The module targets PDF‑1.4 with some experimental PDF‑1.5 features, so complex newer features and JavaScript behavior can vary by Acrobat version, and some metadata, encryption and other PDF features are not handled by the module itself.

CGI::Lingua helps CGI applications choose the best language, region, and locale settings for each visitor by negotiating Accept-Language headers, inspecting user agent hints, and falling back to IP-based geolocation; you tell it which language codes your site supports and it returns a human readable language name, a two letter language or country code, a sublanguage name, a Locale::Object::Country, an IANA time zone, text direction, and CLDR-style plural categories so you can show the correct wording and layout for users. It integrates with CHI for caching and can use local Geo::IP or IP::Country databases or online services for country and timezone lookup, and it also offers a helper to find the best translation file on disk for the negotiated language. The module covers many real-world cases like sublanguage fallback (for example US versus UK English), right-to-left detection for major RTL languages, and plural rules for roughly 70 languages, while documenting a few practical limitations such as embedded plural rules that truncate fractions and are not a full Locale::CLDR replacement, is_rtl only covering primary-script RTL languages, slower and less reliable Whois fallbacks when local geo modules are absent, and the requirement that any logger you pass in be a blessed object with warn/info/error methods. If you need robust, request-level language and region negotiation for a Perl web app and can provide or tolerate local geo libraries and a CHI cache, CGI::Lingua is a pragmatic and well-documented choice.

OpenAPI::Modern validates HTTP requests and responses against OpenAPI v3.0, v3.1 and v3.2 documents and uses JSON::Schema::Modern to perform full, spec‑compliant JSON Schema evaluation. It converts incoming request and response objects into Mojolicious message types and returns rich result objects that include deserialized parameter, header, cookie and body data along with precise error locations, making it easy to see why a message failed validation. The module understands many OpenAPI features such as path, query and cookie parameter styles, media‑type decoding (including application/json and application/x-www-form-urlencoded), content encodings and default population, and it bundles up‑to‑date metaschemas so you can validate or extend schemas immediately. You can preload and cache documents for faster startup in preforked apps. Be aware that multipart bodies are not yet implemented and the Authorization header is not automatically checked against security schemes, and conversions from non‑Mojolicious message types are best‑effort and may reveal differences in header handling. Recent updates improved path matching for URL‑escaped characters and fixed edge cases involving the root path.

Alien::NLopt is a helper module that makes it easy for Perl code to find or install the NLopt C library, a widely used toolkit for nonlinear optimization. If you are a Perl developer who needs NLopt functionality or a user installing a Perl distribution that depends on NLopt, this module automates locating an existing system installation or building and installing the library for you so you do not have to manage the native dependency by hand. It is built on the Alien::Build ecosystem and is suitable for packaging or deployment workflows where native libraries must be provided to Perl modules. The project is open source under the GPLv3 and its source and bug tracker are available on Codeberg.

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::Dataflow::V1Beta3 is a Perl client for the Google Cloud Dataflow V1Beta3 API that uses a high-performance gRPC transport to let Perl applications create, manage, and monitor Dataflow jobs and pipelines programmatically. It integrates with Google::Auth for authentication and is designed for developers who want to embed Dataflow operations into scripts, automation, or backend services. The module targets the V1Beta3 API surface and is distributed under the Apache 2.0 license.

Google::Cloud::Bigquery::Storage::V1 is a Perl client library that lets Perl programs access the Google Cloud BigQuery Storage API over a high-performance gRPC transport. It is designed for efficient, low-latency access to large BigQuery result sets and streaming reads, integrates with Google::Auth for credential handling, and is useful when you need to move sizable datasets between BigQuery and Perl applications. The module is distributed under the Apache 2.0 license.

Net::WebSocket::EVx is a lightweight Perl binding that hooks the wslay WebSocket C library into the EV event loop so you can drive WebSocket I/O from nonblocking sockets with low overhead. It expects you to perform the HTTP upgrade yourself and then hand it a socket, and it provides high level features such as message and frame callbacks, optional buffering for large payloads, fragmented message streaming, send-queue management, explicit RSV bit control for extensions like permessage-deflate, and convenient start/stop flow control. The API mirrors wslay semantics so you can queue normal or control frames, stream big binary data from callbacks, and wait for the send queue to drain before closing. The module duplicates the file descriptor so ownership is clear and it ties the object to the EV loop it was created on. Note that it is Unix focused and has incomplete Win32 support and that you must handle the WebSocket handshake yourself and set allowed RSV bits appropriately when using compression.

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.