CPANscan

Data::SortedSet::Shared provides a Redis-like sorted set that lives in shared memory so multiple processes can read and update the same ordered collection without an external server. Members are 64-bit integers and carry double scores, ties are broken by member id, and the implementation combines an order-statistics B+tree with a fast member-to-score index so common operations are fast: score lookups and existence checks are constant time while rank, range, pop and updates are logarithmic and ranges scan sequentially. You can back the set with a file, create an anonymous mapping to be shared across forked children, or use a memfd to hand the object to unrelated processes, and a companion Data::SortedSet::Shared::Strings class offers string-keyed sets via interned ids. The module exposes convenient APIs for adding, incrementing, ranged queries, popping min/max, iteration, and an eventfd-based notification mechanism for waiters, and it includes stats, sync, and unlink helpers. It requires Linux and 64-bit Perl and uses a futex rwlock that recovers if a lock holder dies, but note that recovery fixes locking only and a writer killed mid-mutation can leave the B+tree inconsistent and there is an unlikely reader-slot exhaustion edge case described in the docs. If you need a high-performance, in-process shared sorted index for leaderboards, priority queues, or cross-process rank queries, this module is a good fit.

Data::PubSub::Shared provides a fast interprocess publish/subscribe channel built on shared memory for Linux 64-bit Perl. Publishers write into a fixed-size ring buffer while each subscriber keeps its own read cursor so messages are broadcast instead of consumed. Integer variants (Int, Int32, Int16) use lock-free atomic publishes for very high throughput and compact memory use while the Str variant stores variable-length messages in an arena and serializes publishers with a mutex. The module supports file-backed, anonymous, or memfd mappings, futex-based blocking waits, eventfd notifications for event-loop integration, batch operations and per-subscriber overflow counting. The ring overwrites old data when full and slow subscribers are auto-reset to the oldest available position with lost messages accounted in overflow stats. Use the integer types for counters, timestamps and small event IDs and use Str for log lines or JSON when you need arbitrary bytes and can accept a capped message size and serialized publishers. Note that it is Linux-only, requires 64-bit Perl, and clearing a ring while lock-free publishes are in flight can cause brief duplicate or stalled deliveries.

Data::MinHash::Shared implements a compact, shared-memory MinHash sketch for estimating Jaccard similarity between sets in a fixed amount of memory and with safe concurrent access from multiple processes. You create a sketch with a chosen number of registers k, fold elements in by hashing them once, and estimate similarity as the fraction of registers that agree so accuracy improves predictably as k grows. The sketch lives in a shared mapping backed by a file, an inherited anonymous mapping across fork, or a memfd that can be reopened in another process, and supports add, merge, export of raw registers, and on-disk syncing while guarding mutations with a futex-based rwlock and dead-process recovery. The recent release adds b-bit MinHash support so you can export very compact signatures and compare snapshots cheaply using only the low b bits per register, trading a small correction for much lower storage and bandwidth. Note that the module is Linux-only, requires 64-bit Perl, treats elements as raw bytes so wide characters must be encoded first, and has documented corner cases such as PID reuse and extreme reader counts that are unlikely in normal use.

Data::IntervalTree::Shared is a fast, shared-memory index for integer intervals that lets multiple processes answer containment and overlap queries without scanning every interval. It stores signed 64-bit endpoints and a user 64-bit id per interval, supports appending intervals and then performs fast stabbing and overlap searches by bulk-building a balanced tree on first query so queries run in roughly O(log n + k) time. The index is designed for practical uses like scheduling and calendar conflict detection, IP range ownership lookup, and genomic feature overlap. Multiple processes can share the same index via a backing file, an inherited anonymous mapping after fork, or a memfd passed between processes, and a futex-based read/write lock with dead-process recovery protects mutation and query concurrency. The module is Linux-only and requires 64-bit Perl, the index has a fixed capacity set at creation and will croak if you exceed it, and crash safety preserves consistency up to the last completed operation while noting rare corner cases such as PID reuse not being detected and potential writer blocking if more than 1024 concurrent readers produce a crashed slotless reader.

Data::Fenwick2D::Shared implements a two-dimensional Fenwick tree in shared memory so multiple Linux processes can efficiently update and query a fixed rows-by-cols grid of signed 64-bit integers. It supports atomic point updates and fast rectangle-sum queries in O(log rows * log cols) time, making it useful for cumulative-frequency tables, running heatmaps, image area sums, and other grid-based counters. The grid can be backed by a file, an anonymous mapping inherited across fork, or a memfd passed between processes, and queries take only a read lock so many readers run concurrently while a futex-based write-preferring rwlock with dead-process recovery protects writers. Values and totals are native 64-bit integers and wrap on overflow, and the implementation requires Linux and 64-bit Perl. A few practical limits are documented such as possible writer blocking if more than 1024 concurrent reader processes crash while holding read locks and the lack of PID-reuse detection on recovery, but these are rare in normal use. This is the initial release.

Data::CuckooFilter::Shared implements a compact, fixed-size cuckoo filter in shared memory for Linux so multiple processes can efficiently share an approximate membership set that supports add, contains, and remove. It stores 16-bit fingerprints rather than the items themselves so memory use scales with configured capacity, not item size, and for items you actually added contains returns true while the false positive rate is very small. The table is sized from a user capacity and uses four 16-bit slots per bucket, supports counting up to eight copies of an item, and add returns false only when the table is full so failed inserts are a true no-op. The mapping can be a backing file, an anonymous mapping inherited across fork, or a memfd passed between processes, and a futex read/write lock with dead-process recovery lets many processes safely add, remove, and test concurrently. Important caveats are that remove must only be used on items you added because fingerprint collisions can delete the wrong entry and corrupt counts, wide characters must be encoded to bytes before use, and a writer killed mid-eviction can leave the table in a state that permits a false negative so recreate the filter if that matters. The module is Linux-only, requires 64-bit Perl, and provides introspection, sync, unlink, and memfd helpers for sharing and lifecycle management.

Data::BitSet::Shared provides a fixed-size bitset that lives in shared memory on 64-bit Linux, letting multiple processes read and update individual bits without locks. It exposes file-backed, anonymous (fork-inherited), memfd and attach-by-fd constructors so you can share a bitmap across processes for flags, membership tracking, bloom-filter storage or resource allocation. Per-bit operations are atomic and lock-free using CAS on 64-bit words, so set, clear, test and toggle are fast and safe to run concurrently, and there are helper queries like count, first_set and stringification plus bulk fill and zero operations for whole-bitset changes. Note that full-word bulk stores are not safe to call at the same time as per-bit CAS operations on the same words. Backing files are created with owner-only permissions by default to improve security and a recent release also hardened robustness and fixed a few argument and memory-pointer handling issues while adding memfd improvements.

Cucumber::TagExpressions is a lightweight Perl parser and evaluator for the tag filter syntax used in Cucumber/Gherkin. It turns a human readable expression like "@fast and not @wip" into an ExpressionNode object and lets you call evaluate with a scenario's tags to get a true or false answer, so you can easily select which scenarios to run in custom runners or tooling. The module is MIT licensed and is based on the prior Ruby cucumber-tag-expressions library.

Net::SNMP::QueryEngine::AnyEvent is a lightweight AnyEvent-based client for the snmp-query-engine daemon that lets Perl programs perform non‑blocking, multiplexed SNMP queries and manage per-destination options via simple callback APIs. It provides get, gettable, info, dest_info, setopt and the newer getopt calls, plus utility methods like when_done and wait for integrating with an event loop. The client queues requests while the daemon connection is down and will retry connecting automatically by default, calling request callbacks with failure if an in‑flight query was lost; you can customize reconnect timing or disable reconnects. Version 1.1.0 adds on_connect and on_disconnect constructor callbacks so you can react to connection events and re-establish per-destination state, and introduces the getopt method for querying destination options. This module is a good fit when you need asynchronous SNMP access in an AnyEvent application and already use or can deploy an snmp-query-engine daemon.

EV::Pg is a non‑blocking PostgreSQL client for Perl that plugs libpq into the EV event loop so your database I/O never blocks the rest of an evented application. It exposes a familiar async API for parameterized queries, prepared statements, pipeline mode, COPY IN/OUT, LISTEN/NOTIFY, single‑row and chunked row delivery, async cancel when supported by libpq, protocol tracing, and a handful of handy utilities for quoting and bytea handling. Use it when you need high throughput or low latency inside an EV‑based program and want direct libpq behavior without spawning threads or blocking the loop. It requires libpq >= 14 and EV and will enable newer features automatically when linked against libpq >= 17. Recent 0.08 fixes address skip_pending accounting bugs and a segfault when a custom EV loop is freed before the EV::Pg object, and they improve result metadata handling.

EV::MariaDB is an asynchronous MariaDB/MySQL client that plugs into the EV event loop and uses MariaDB Connector/C's non‑blocking API to perform connects, queries, and prepared statements without blocking your program. It supports pipelined queries for high throughput, server-side prepared statements with automatic buffer handling, row‑by‑row streaming for very large result sets, async transaction and connection control, BLOB/TEXT streaming, and optional UTF‑8/utf8mb4 handling so Perl strings round‑trip correctly. The API is callback driven and distinguishes simple pipelinable queries from exclusive operations like prepare/execute or streaming reads so you can batch many queries safely while preserving correctness for stateful commands. Convenience features include column metadata, escape routines, and graceful async close. Be aware it is not safe to share a connection across Perl ithreads so use one interpreter thread or separate processes per thread. Recent fixes harden statement handle validation to avoid use‑after‑free bugs and segfaults, ensure the object holds the EV loop reference to prevent dangling pointers with custom loops, and make change_user with an undef database preserve the current database.

CryptX is a full-featured Perl cryptography distribution that bundles the LibTomCrypt library and exposes a large family of focused modules for hashing, symmetric and stream ciphers, authenticated encryption (AEAD), MACs, secure random generation, public-key operations, key derivation and ASN.1 helpers. It acts as the top-level documentation hub rather than a single API, so you pick the concrete modules you need such as Crypt::AuthEnc::ChaCha20Poly1305 for modern AEAD, Crypt::Digest for hashes, Crypt::PRNG for secure randoms, or Crypt::PK::Ed25519 and Crypt::PK::X25519 for modern public-key work. The distribution also ships Math::BigInt::LTM, a big-integer backend used internally, and includes diagnostic helpers that report how the bundled LibTomCrypt was built. Recent updates introduced AES-GCMSIV support plus ARIA cipher, the SM3 digest and KMAC, and an updated LibTomCrypt bundle, making this a good choice if you want a broad, actively maintained cryptographic toolkit for Perl with many modern algorithm choices.

Perl::Critic::TooMuchCode is an add-on for Perl::Critic that hunts down trivial dead code and no-op constructs that bloat maintenance and obscure intent. It adds configurable policies to flag things like unused imports and constants, duplicate subroutines and duplicate literal values, unnecessary include statements, overly large code or try blocks, excessive colons and redundant or extra strictures so you can catch cleanup opportunities during linting or in CI. Recent releases improved duplicate-literal reporting to show the literal itself and refined duplicate-sub handling to allow multiple BEGIN, UNITCHECK, CHECK, INIT and END blocks. The module is maintained by Kang-min Liu and is distributed under the MIT license.

Captcha::reCAPTCHA::V3 is a small Perl module that makes it easy to verify Google reCAPTCHA v3 tokens on the server side, letting you construct an object with your secret key (sitekey is optional) and then call verify(response) to get the decoded JSON result from Google. It exposes a deny_by_score method to evaluate the v3 risk score against a threshold (default 0.5) and will add a 'too-low-score' error code when the score is insufficient, plus a verify_or_die convenience wrapper that aborts on failure. The module also provides a scripts helper to generate the client-side snippet that fetches tokens for a given form id and supports toggling simple debug output, and the object stringifies to the query parameter name (defaults to "g-recaptcha-response") so you can easily pull the right POST field. Note that reCAPTCHA v3 does not accept a remote address and the module follows that API, and strict testing of the client-side flow requires running JavaScript. In the latest release the verification backend was switched to HTTP::Tiny and the generated script tags were adjusted for async loading.

LWP::Protocol::https is a small plug-in that enables LWP::UserAgent to fetch HTTPS URLs by using HTTP over SSL/TLS, so you do not call it directly but install it to give LWP builtin https support. It honors LWP::UserAgent ssl_opts such as hostname verification and lets you supply SSL_ca_file or SSL_ca_path for certificate validation, and when verification is enabled it will fall back to the CA bundle provided by Mozilla::CA unless you override it. The module was split out of libwww-perl so applications can simply depend on it rather than on its lower-level SSL libraries. Recent releases improved proxy handling to support TLS-enabled (https://) proxies and contain small test-suite fixes to make installation more robust.

Tree::RB::XS is a fast, feature-rich red/black tree implemented in C that gives you an ordered key/value store with log-time lookups and inserts and some array-like operations such as O(log N) nth-node access. It supports optional duplicate keys with preserved insertion order, case-folded comparisons while keeping the original key, a built-in natural-number-aware comparator, and an optional insertion-order linked list for LRU or MRU caches so you can inspect or trim the most or least recently used items. The module exposes smart bi-directional iterators that advance safely when nodes are removed, convenient get/put/insert APIs (including GET_OR_ADD and lvalue access to values), bulk operations, a rekey facility, and a tie interface for using the tree as a hash. It is optimized with several built-in comparison modes but note that supplying a custom Perl coderef for comparison will forfeit most XS speed benefits. Recent releases made node objects persist once created so you can hold weak references to them and added conveniences like node-returning put/insert methods and automatic pruning of recent lists when a recent_limit is set. If you need a fast, ordered map, natural sorting, or an LRU-capable container in Perl, Tree::RB::XS is likely a good fit.

Params::Validate::Strict is a Perl input-validation library that checks a hash of named parameters against a declarative schema and returns a new hash of validated and coerced values or dies with a clear error. Its schema language covers common types such as strings, integers, numbers, booleans, arrayrefs, hashrefs, objects and coderefs and also supports nested schemas, element-level checks, custom reusable types, union types, transformations, callbacks, cross-field rules and relationship constraints like mutually exclusive or required groups. The module handles optional and default values, positional arguments, case-sensitive or case-insensitive membership checks and custom error messages, so it is useful for routine argument checking, web form or WAF input sanitization and even driving black‑box test generation. Recent releases added a stringref type, expanded union-type support and improved integer handling so scientific notation and trailing .0 decimals are accepted when appropriate while still rejecting non‑finite values. If you need a flexible, feature-rich validator with detailed error reporting and coercion for Perl APIs or services, this module is worth considering.

App::makefilepl2cpanfile is a small utility that reads a Makefile.PL without running it and emits a ready-to-use cpanfile listing runtime, build, test and configure dependencies, while optionally injecting common developer tools from a user config or built-in defaults. It captures both simple PREREQ_PM entries and structured prereqs blocks, preserves inline comments on dependency lines, and can merge hand-edited develop entries from an existing cpanfile so you do not lose curated content. The module exposes parse_prereqs as a public function so other tools or CI checks can reuse the parser, and it is careful not to evaluate arbitrary code in Makefile.PL so it is safe to run. If your distribution still uses Makefile.PL and you want to move to or maintain a cpanfile this will automate most of the work, but note that dynamically generated dependencies created only at runtime or inside conditional code cannot be detected because the parser is regex based. Recent changes (v0.03) make parse_prereqs available as an API, add support for structured prereqs nested under META_MERGE, preserve inline comments, and include recommends and suggests relationships in the output.

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.