CPANscan

EV::Memcached is a high-performance, asynchronous memcached client for Perl that plugs into the EV event loop and implements the memcached binary protocol in pure XS so no external C client library is required. It provides non-blocking commands with pipelining, multi-get and fire-and-forget "quiet" operations, supports TCP and Unix sockets, optional SASL PLAIN authentication with automatic re-auth on reconnect, and offers configurable timeouts, flow control and reconnection behavior to keep your application responsive under load. Callbacks always run with a consistent (result, error) signature and pending callbacks are guaranteed to fire on teardown so cleanup and error handling are predictable. This is a good fit if you need low-latency, evented access to memcached from Perl or want AnyEvent compatibility without code changes. Recent releases improve robustness, notably fixing a use-after-free bug when a callback clears its own handler.

EV::cares connects the high-performance c-ares asynchronous DNS library directly into the EV event loop at the C level so your Perl program can perform fast, concurrent DNS work with essentially no Perl-level event overhead. It offers a full range of operations from simple A/AAAA resolves, getaddrinfo and reverse lookups to raw DNS queries and typed searches that auto-parse MX, SRV, HTTPS/SVCB, TLSA and DNSSEC record formats and can return per-record TTLs for cache-aware applications. The API includes bulk helpers, lifecycle and introspection utilities such as active_queries and wait_idle, options for custom servers, ports and local binding, and an optional in-memory result cache. EV::cares parses DNSSEC-related records but does not validate the cryptographic chain so use a validating resolver or check the AD bit if you require authenticated answers. It requires c-ares 1.24 or newer and note that HTTPS/SVCB/TLSA parsing needs c-ares 1.28 or later; the recent 0.04 release fixed use-after-free crashes when a resolver is destroyed or dropped inside a callback and made the c-ares minimum a hard requirement.

Pod::POM::View::Restructured converts Perl POD into reStructuredText suitable for Sphinx, so you can generate .rst files (or strings) from individual POD files or batches and optionally produce an index with a table of contents. It plugs into Pod::POM so you can present a parsed POD object with this view or call convert_file/convert_files to write output, set titles, and supply link callbacks for custom handling of L<> links. Verbatim sections are emitted as syntax highlighted code blocks by default using Perl but you can change the language for a specific block from POD with the =for pod2rst next-code-block directive. The constructor also accepts a namespace option to create anchors and cross references. The authors note a couple of limitations worth knowing about: there is not yet a constructor option to change the default code-block language globally, and some text escaping is imperfect and can accidentally trigger reStructuredText directives.

HTTP::XSHeaders is a drop-in, C-backed replacement for the Perl HTTP header libraries HTTP::Headers and HTTP::Headers::Fast that gives existing Perl code a big speed boost simply by loading the module. It preserves the familiar public API so you can keep using the same methods for getting, setting, scanning and serializing headers while benefiting from a lightweight, thread-safe native implementation. The module intentionally normalizes header names to standard casing, converts underscores to hyphens, and makes a few small compatibility changes such as not supporting leading-colon literal names or the old $TRANSLATE_UNDERSCORE behavior, and it always loads Storable but performs cloning at the C level. Benchmarks included with the distribution show substantial improvements across common operations, making this a good choice when you need lower-overhead HTTP header handling. Recent releases fixed a heap-buffer-overflow issue and marked the project stable, and the most recent patch added an explicit dependency on HTTP::Headers and a fix for older Perl package declarations.

Google::Ads::GoogleAds::Client is the central Perl client for interacting with the Google Ads API, handling credentials, configuration and exposing each API service as a method so you can call things like GoogleAdsService->search to run queries and mutate resources. It reads credentials from a googleads.properties file or from environment variables and includes built in OAuth handlers for both web/desktop applications and service accounts, plus options for developer token, login or linked customer IDs, proxy and HTTP timeout settings. The client offers convenient features for debugging such as last_request and last_response, and a configurable die_on_faults mode so you can choose between exception-like die behavior or explicit fault objects. Load this module before other Google::Ads::* modules to avoid warnings and use it when you need a ready-made, up-to-date Perl interface to the Google Ads API; recent releases add support for the newest API versions, including v25_0.

Data::Commons::Image is a small, focused Perl data object for representing Wikimedia Commons images and their metadata. It gives you simple accessors for fields like commons_name (required), author, comment, dt_created and dt_uploaded (as DateTime objects), width, height, size, url, license and page_id, and it supports a url callback for computed URLs. The constructor enforces basic type and length checks and the class inherits common behavior from Data::Image while using Mo for attribute handling. Use this module when you need a validated, structured container for Commons image metadata in Perl scripts or applications.

Convert::Pheno is a Perl toolkit for translating phenotypic data between common clinical and research formats so teams can move data smoothly between Phenopackets, BFF/Beacon-style JSON, OMOP, REDCap, CSV and related models. You can use it as a Perl module or from the command line and it relies on configurable mapping files to preserve key fields while synthesizing individuals, cohorts and biosamples as needed, making it useful for bioinformaticians and clinical data engineers working on data integration and interoperability. Recent releases refactored the Perl and Python APIs to support structured multi-entity JSON outputs, added experimental OMOP specimen-to-BFF biosamples conversion and initial openEHR canonical JSON to BFF support, and updated the Python bindings, so it now better handles multi-entity datasets and modern workflows. The project is actively maintained, documented online, and the author requests citation in published work that uses the package.

RT-Extension-MandatoryOnTransition is a plugin for Request Tracker that stops ticket status changes until specified core fields, custom fields, or role assignments have been filled in. Install it as a standard RT plugin and then declare per-queue or global rules in the %MandatoryOnTransition configuration to require things like reply text, time worked, a particular custom field value, or that a role is set before moving to a target status or into another queue. It can also demand specific allowed or disallowed values and can require that a role member belong to particular groups. When a transition is attempted the extension surfaces the required fields on the update page and blocks the action until they are provided, making it useful for enforcing workflow and data quality. Caveats include limited coverage of some RT pages such as SelfService and QuickCreate, the fact that custom field validation patterns are applied first, and that multi-value custom fields are only checked by their first entry in some rule types.

EV::Websockets is a Perl binding to the libwebsockets C library that gives you high-performance WebSocket client and server capabilities integrated into the EV event loop, so it fits cleanly into applications already using EV and avoids blocking other watchers. It exposes a Context for managing sockets and TLS, connect() and listen() helpers for clients and servers, adopt() to take over existing sockets, and a Connection object with convenient methods for sending text, binary, pings/pongs, fragmented streams, backpressure monitoring, pausing/resuming receive and storing per-connection metadata. The module supports TLS, proxy auto-detection, configurable handshake timeouts, full reassembly of fragmented and compressed frames for on_message callbacks, and is designed for low latency and high throughput by leveraging libwebsockets. Note that server-side listeners do not negotiate permessage-deflate for outgoing messages. Recent fixes in version 0.10 improve robustness by replying 426 to plain HTTP sent to a WebSocket listener, by making listen() croak if you supply an ssl_cert without an ssl_key, and by adding stricter validation of close codes, option values, URL ports and adopted handles.

Alien::libwebsockets is a helper for Perl modules that need the libwebsockets C library, making it easy to either use a system-installed libwebsockets or download and compile it for you. When it builds from source it enables SSL, zlib and the permessage-deflate extension, and it will enable libev support automatically if libev development headers are present. The module is based on Alien::Base so it exposes compiler flags and linker flags you can drop into ExtUtils::MakeMaker or other build tools, letting XS or C-linked Perl code find and link against libwebsockets without manual setup. It also provides a has_extensions method to detect whether permessage-deflate support is present, though that detection is reliable only for builds the module manages itself and will report false for some system installs where the shared library path is not tracked.

POSIX::2008 is a comprehensive Perl extension that brings modern POSIX.1-2008 and newer interfaces into Perl, along with many useful Linux, BSD and Solaris extensions that the core POSIX module omits or mangles. It exposes low-level system calls and constants for file and directory operations (openat, openat2, fdopen, fdopendir, pread/pwrite, readv/writev, statvfs, removeat and more), process and credential control, timers and clocks, secure entropy, and a wide set of math and classification functions, all usable with either numeric file descriptors or Perl handles where supported. The module does not export anything by default but offers grouped export tags for convenience, and it aims to behave more faithfully than core POSIX in return values and data types. This is a tool for system-level or performance-sensitive Perl code rather than everyday scripting, and it is provided "as is" with a very permissive WTFPL license, so be aware that maintenance and support are informal.

EV::Redis is a high-performance asynchronous Redis client for Perl that uses hiredis and libev with a C-level integration for speed and low overhead. It is a drop-in replacement for EV::Hiredis and adds practical features like automatic reconnection, flow control and command queuing, TLS and RESP3 support, server-push handlers, and configurable timeouts and priorities. You send commands via command or the AUTOLOAD Redis methods and can run in fire-and-forget mode for maximum throughput or use callbacks for results, while pub/sub and monitor modes follow hiredis semantics. It integrates smoothly with AnyEvent when EV is used as the backend and exposes hooks for on_error, on_connect, on_disconnect and on_push so you can manage lifecycle and errors from your event loop. One important caveat is that EV::Redis treats all data as raw bytes and does not perform UTF-8 decoding or encoding, so you must encode/decode text yourself and passing characters above 0xFF will croak. If you need a fast, event-driven Redis client for Perl with control over reconnection, queuing and TLS, EV::Redis is a solid choice.

Crypt::Argon2 is a Perl wrapper around the Argon2 key derivation function that makes it easy to turn passwords into secure cryptographic keys or safely store password hashes. It supports all Argon2 variants (argon2id, argon2i and argon2d) and exposes simple functions to produce encoded password strings, verify passwords, get raw digests, and check whether an existing hash needs rehashing when your parameters change. You control time cost, memory cost, parallelism and output size, and the distribution includes an argon2-calibrate helper to help pick sensible parameters for your environment. Recent releases added a way to report the optimized implementation in use, fixed an out‑of‑bounds read that became a CVE and corrected a Unicode handling bug in the pass functions, so it is both featureful and actively maintained. If you need modern, memory‑hard password hashing or key derivation from Perl and pair it with a good random salt source, this module is a practical choice.

Config::Perl::V parses the output of perl -V and returns a structured Perl data object so you can programmatically inspect both the usual %Config settings and the binary-specific details that perl prints but does not store in %Config. The module’s myconfig function returns a hashref with four main sections: build, which captures compile-time options, locally applied patches, build host and compile timestamp; environment, which by default collects PERL* environment variables but can be expanded via an option; config, which mirrors the variables reported by perl -V and Config::myconfig; and inc, the default @INC paths. You can also convert a saved perl -V text block into that same structure with plv2hash, get a compact summary with summary, and produce a reproducible MD5 signature of the summary with signature, which falls back to a zero string if Digest::MD5 is unavailable. This is useful for tooling, testing, or packaging systems that need to know the exact characteristics of the running perl binary, but note it does not detect uninstalled perls when only given -I paths on the command line.

OpenTelemetry is the Perl implementation of the OpenTelemetry API that gives Perl applications a standard, backend-agnostic way to create traces, manage context, and wire in logging and propagation tools for distributed observability. It provides a single entry point to get or set global components like tracer providers, logger providers, propagators and an error handler, plus convenience functions you can import with an otel_ prefix to work with contexts and spans. Instrumentation code uses this API to record performance and operational data but you will need an SDK such as OpenTelemetry::SDK to actually process or export those telemetry records. The module supports both method and functional styles and exposes lvalue accessors for global state, making it easy to swap providers at runtime while keeping instrumentation simple and consistent. Recent updates include fixes to span parent handling in the tracer and improvements to HTTP integrations so the user_agent attribute is only added when available, which reduces spurious warnings.

Cavil::Matcher is a high-performance pattern matcher used by the Cavil license scanner to turn source files into license and keyword hits. It keeps the proven token-hash prefix-tree approach of the prior engine but stores compiled patterns as immutable, memory-mapped segments described by a small manifest so you can add or remove patterns without rebuilding the whole cache and multiple workers on one host can share a single physical copy. The tokenizer and hashing are a frozen C++ core that preserves bit-for-bit compatibility with the old engine while the segment lifecycle and manifest handling are implemented in Perl. The module provides a simple engine API (init_matcher, add_pattern, find_matches) plus helper routines to parse pattern text into tokens (parse_tokens supports $SKIPn wildcards), normalize text into token/line/hash rows, and read raw file lines with a 1 MiB cap per physical line. There is also a streaming 128-bit hash API and a tf-idf "bag of patterns" model for closest-match queries, and the module deliberately reproduces the previous engine’s token-level edit-distance behavior (including an off-by-one quirk). Note that parse_tokens and normalize accept text and treat embedded NUL as end of input, while add_pattern/find_matches and the file reader are NUL-tolerant. This module is a good fit if you need scalable, incremental, and shareable pattern matching for license scanning or similar text-pattern tasks.

File::Unpack2 is a Perl module and command‑line unpacker that detects files by MIME type instead of trusting file name extensions and then recursively extracts a very wide range of archive and packaged formats (bz2, gz, zip, tar, cpio, rpm, deb, cab, lzma, 7z, rar, pdf, odf and more), including multiply wrapped archives. It produces a machine‑friendly JSON logfile describing each unpacked item, supports built‑in and external shellscript helpers for new MIME types, and offers controls for safe operation such as a maximum extracted file size, filesystem free‑space checks, jailed extraction options, exclude patterns, and configurable symlink handling. MIME recognition uses libmagic and shared‑mime‑info where available and can report stacked types like tar+bzip2 so helpers can unpack efficiently without unnecessary temporary files. Recent maintenance focused on robustness and safety with fixes for malicious archives, cleanup of temporary archives, a race condition that could corrupt the JSON log, and improved portability of tests.

GraphQL::Houtou is a high-performance, XS-backed GraphQL parser and execution toolkit for Perl that makes it easy to run GraphQL queries with production features and low overhead. It exposes a canonical Perl AST for parsing, an XS native runtime for execution, and multiple APIs so you can pick a simple one-off entry point or build a long-lived runtime for repeated queries. The library includes efficient batching via a bundled DataLoader and an on_stall hook to collapse N+1 database lookups, a direct JSON rendering path that emits UTF-8 bytes without building Perl data structures, a one-line PSGI adapter for HTTP endpoints, and support for persisted queries as compiled bundles or programs for maximum throughput. It also offers async schemas that recognize Promise::XS promises, program caching and cost limits for production safety, and utilities to import or emit SDL. Limitations noted by the author include no subscription execution or streaming transports in the 0.01 profile, no generic promise adapters, fixed native bundles cannot accept GraphQL variables, and the runtime is not compatible with Perl ithreads so use process-based concurrency.

Config::Model is a Perl framework for declaring the structure, constraints and migrations of application configuration so you can validate, upgrade and provide interactive editors without embedding all that logic in custom scripts. You express a configuration model as a declarative Perl data structure and the framework takes care of parsing and writing files through backends, validating values as they are edited, applying migrations and generating user interfaces including shell, curses or Tk front ends and a FUSE view. It is handy when you need a maintainable, reusable schema for system or application config, automated upgrade paths, on‑line help and auditable changes, and it integrates with the cme command and a GUI model editor to simplify building and running models. The project ships common backends for INI and Perl formats and supports Augeas for complex system files, and recent releases continue to polish validation and loader behavior, with the 2.166 update ensuring content checks run when fixes are applied and improving warning messages for undefined values.

Zonemaster::Backend is the server-side component that runs Zonemaster DNS zone tests asynchronously and exposes them over a JSON-RPC API so other tools or a web GUI can start tests, check progress and fetch results. It accepts single and batch test requests, schedules work to one or more test agent processes, and stores outcomes in a configurable database backend such as SQLite, MariaDB or PostgreSQL while providing command line helpers and integration for Docker and systemd. This module is useful if you need a scalable, queue-driven DNS testing service or want to embed Zonemaster testing into an automated workflow or web interface. Recent updates add an explicit schema version and GUI TLD URL support and fix a regression involving database handle reuse in child processes, so be aware that some upgrades require running the provided database migration.

Quote::LineProtocol is a small Perl helper that prepares and quotes measurement names, tag sets, field sets, and timestamps so they conform to the InfluxDB line protocol. It offers simple functions to quote a measurement, join and quote tags, format fields with automatic type guessing or explicit type/value hashrefs for floats, integers, unsigned integers, booleans, or strings, and to emit timestamps in ns, us, or ms precision with optional UTC. The module also documents a Telegraf-specific quoting mode you can enable via the QUOTE_TELEGRAF environment variable and it will skip keys with empty values. Recent updates added the ability to stringify blessed objects when building values and refreshed documentation and contact info.

Mojo::URL::Role::Auth is a tiny role for Mojo::URL that adds a single two-argument auth method to set URL userinfo, so after applying the role with with_roles('+Auth') you can call auth('username', 'password') and the URL will include credentials like https://username:password@example.com; it simply modifies the URL string rather than performing any HTTP authentication handshake. The module is minimal and focused, aimed at anyone who uses Mojo::URL and needs a quick, lightweight way to construct legacy basic-auth style URLs or to embed credentials for testing and scripting. It is distributed under the same license as Perl and recent minor updates adjusted contact info, runtime dependencies and a test path.

Scalar::ValueTags lets you attach small, propagated metadata items directly to Perl scalar values so that provenance, policy flags, or other annotations automatically follow a value as it is copied or combined. It works like Variable::Magic but tags the data rather than the container, and clients register a tags "type" that controls how tags are stored and merged so you can choose compact string sets, counted strings, append-only arrays, or unique reference-based sets depending on your needs. The API is simple: register a type, add or remove tags from a variable, read tags, and clear them, and the tags will be duplicated on assignment and merged when values are combined, which makes this useful for auditing, tracking data flow from external sources, or enforcing source-aware access rules. The module depends on the new scalar value magic in Perl core (Magic v2) so you should check value_tags_enabled before use and note that debugging facilities are minimal at present. The recent 0.004 release fixed a threading-related bug that broke threaded Perl builds.

Kwiki::Archive::Cvs is a plugin for the Kwiki wiki engine that stores page history by committing edits into a CVS repository, a direct adaptation of the original RCS-based archive module. It is intended for sites that prefer to keep wiki revisions under CVS and works by operating on a checked-out CVS sandbox placed in Kwiki's database directory, requiring a CVS client that supports the -Q option. Installation is straightforward: add Kwiki::Archive::Cvs to your plugins file and run the usual kwiki update, but be aware the module was marked deprecated in 2026 and was last updated to support newer Kwiki releases around 2008, so users should consider more modern, actively maintained version-control backends for new deployments.

Captcha::Cloudflare::Turnstile is a Perl module that makes it straightforward to integrate Cloudflare's Turnstile CAPTCHA into web applications by providing helpers to render the client widget and to verify responses on the server. It subclasses Captcha::reCAPTCHA::V3 and requires only your Turnstile secret key at construction with an optional sitekey and configurable form field name. Use scriptTag, widgetTag or the combined scripts method to inject the Turnstile JavaScript and widget into your form, and call verify to post the token to Cloudflare's siteverify endpoint and get the decoded JSON response; convenience methods verify_or_die and deny_by_score are provided but deny_by_score simply warns because Turnstile does not return a score. The module also exposes the Turnstile API URL and supports Cloudflare's dummy test keys for automated testing, though tests that exercise the client widget require running JavaScript.

SPVM::Go brings the Go language's goroutines and channels model into SPVM, letting you spawn lightweight concurrent tasks and communicate via buffered or unbuffered channels with familiar primitives like go, make, select, sleep and gosched. It integrates with the libuv event loop so waiting operations such as timers, socket I/O and channel reads/writes suspend without busy-waiting, keeping CPU usage minimal and enabling thousands of concurrent goroutines inside a single process. The distribution also provides helpers for select operations, wait groups, contexts, signal handling and time/duration utilities, and supports IO timeouts that raise specific exceptions when they occur. Note that some scheduling and sleep/IO methods must be called from the main thread and will raise exceptions otherwise. The module is actively maintained on GitHub and recent releases refactored and fully adopted libuv for timers and IO to improve scalability and reduce CPU overhead.

ExtUtils::MakeMaker::CPANfile lets authors drive ExtUtils::MakeMaker's WriteMakefile from a cpanfile so you can declare distribution prerequisites in a modern cpanfile and have them translated into Makefile.PL parameters automatically. It loads a cpanfile found next to Makefile.PL, converts its requires/recommends/suggests/conflicts into WriteMakefile arguments, and strips unknown parameters that older EUMM versions would warn about. It does not fully handle complex version ranges and it sets dynamic_config to false by default though you can enable dynamic configuration via META_ADD or META_MERGE when needed. Recent releases improve dependency handling by merging prerequisites with CPAN::Meta::Requirements so combined constraints are resolved more sensibly.

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.