CPANscan

Wildling is a Perl library that expands compact pattern strings into every possible combination according to a shared wildcard grammar, making it easy to generate wordlists, domain name ideas, test data, and similar sets. You feed it one or more pattern expressions and optional named dictionaries, and it returns a client object you can iterate with next(), fetch by index, inspect the total count, and rewind when needed. The module follows the same syntax and command line behavior as the cross-language Wildling project, so patterns are portable and a browser sandbox and docs are available upstream. A returned undef signals that enumeration is exhausted, and a bundled CLI lets you use Wildling from the command line as well.

OSLV::Monitor is a lightweight Perl extension for LibreNMS that gathers OS-level virtualization metrics from container and jail backends and returns them as JSON for easy integration. It auto-selects a backend based on the operating system or lets you pick FreeBSD or Linux cgroups explicitly, and it provides simple configuration options for cache location, time scaling, and include or exclude name filters using regular expressions so you only collect the containers you care about. Usage is straightforward: create a monitor object, call load to initialize the backend, and call run to perform a poll and get structured output suitable for further processing or ingestion into LibreNMS. This module is a practical choice if you need focused, configurable monitoring of OS-level virtual instances within a LibreNMS setup.

JQ::Lite is a pure-Perl, jq-compatible JSON query engine and command-line tool that brings familiar jq-style filters to environments where the jq binary or XS modules cannot be installed. You can use it as a library or via the bundled jq-lite CLI to traverse and transform JSON with dot notation, optional keys, array slicing and flattening, boolean select filters, pipes, map/walk and a large set of built-in helpers for aggregation, string and collection manipulation. It works with only core modules by default while allowing faster decoders like JSON::XS when available, and it is designed for minimal, locked-down, containerized, or air-gapped systems. The project is mature and actively maintained; current release 2.49 tightens argument validation for slice and bracket-slice operations and includes ongoing bug fixes and refinements to keep behavior aligned with jq.

Mail::DMARC is a Perl implementation of the DMARC email authentication and reporting standard that lets MTAs, spam filters and mail senders check whether incoming messages align with a sender domain's policy and handle reporting. You feed it connection metadata plus SPF and DKIM results, call validate, and it returns a Result object that indicates pass, fail and the policy disposition like reject, quarantine or none. The distribution implements current DMARCbis (RFC 9989) while remaining compatible with the original RFC, performs organizational domain discovery, and includes tools to send, receive, view and persist aggregate reports in an SQL-backed store tested with SQLite, MySQL and PostgreSQL. It offers a Pure Perl engine plus an optional XS binding to libopendmarc, aims to implement all MUSTs and SHOULDs in the spec, and keeps a small dependency footprint when reporting features are not used.

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

EV::Kafka is a high-performance, asynchronous Kafka client for Perl that implements the Kafka binary protocol in XS and integrates with the EV event loop, making it suitable for low-latency, high-throughput producers and consumers against Redpanda and Apache Kafka 0.11 and newer. It gives you a full cluster client with metadata discovery, broker connection pooling, key-based partitioning, producer features like configurable acks, idempotence and transactions, and consumer features including manual partition assignment or consumer groups with automatic rebalancing, offset commits and heartbeats. The module is pure XS and does not depend on librdkafka and it supports TLS and SASL (PLAIN and SCRAM) plus optional compression when the corresponding libraries are present. Usage follows an EV-style lifetime model so you must keep the client object live like an EV watcher and callbacks are guaranteed to fire or return errors on shutdown. Note the module treats all data as raw bytes so you must encode UTF-8 yourself, DNS name resolution is blocking unless you pre-resolve hostnames, GSSAPI and OAUTHBEARER are not implemented, and TLS on Linux can deliver SIGPIPE unless your application ignores it. If you need a fast, full-featured Kafka client embedded in an EV or AnyEvent application and can live with those caveats, EV::Kafka is a strong choice.

DBIx::Class::Schema::GraphQL introspects a DBIx::Class schema and generates a ready-to-run GraphQL::Schema so you can expose your database as a GraphQL API with minimal effort. It maps SQL column types to basic GraphQL scalars, exposes relationships as object or list fields, and creates root Query entry points including singular lookups and plural all<Source>s queries with filtering, ordering, and both offset and cursor pagination. It also generates create, update, patch, and delete mutations for each source and supports composite primary keys. Note the deliberate limitations: relationship fields are unfiltered, mutations accept only flat scalar inputs, custom SQL types map to String, and cursor pagination relies on primary key order. In the recent v0.0.3 release a security fix was added to prevent SQL injection by validating orderBy.field against the source's declared columns. The to_graphql method returns the GraphQL::Schema plus a context you can pass to GraphQL::Execution to run queries and mutations.

Dancer2::Plugin::Feed is a lightweight Dancer2 plugin that lets you generate RSS or Atom feeds from your web app without dealing with raw XML. It wraps XML::Feed and XML::Feed::Entry and exposes create_feed plus convenience shortcuts create_atom_feed and create_rss_feed. You pass feed metadata either in your Dancer2 config or as parameters and provide entries as an arrayref of hashrefs with keys like title, link, summary, content, author, issued and modified. The plugin sets the appropriate Content-Type header for the chosen format and surfaces format-related errors via exception roles so you can handle them in route code. If you want quick, configurable feed generation integrated with Dancer2, this module does the job while delegating the XML heavy lifting to XML::Feed.

AsposeCellsCloud::Role is a lightweight helper within the Aspose Cells Cloud Perl SDK that centralizes configuration and API client creation so the rest of the SDK can obtain ready-to-use service objects. It exposes access to a shared Configuration object for credentials, endpoints and defaults, and delegates client construction to an ApiFactory so API modules do not need to repeat setup code. If you are integrating Aspose Cells Cloud into a Perl application this role simplifies managing connection details and reusing a consistent, preconfigured API surface across your code.

Catalyst::View::Wkhtmltopdf is a Catalyst view that turns HTML or Template Toolkit output into PDF by invoking the wkhtmltopdf command line tool. You configure the view in your app, stash either raw HTML or a template name plus options like page size, margins, filename and disposition, then forward to the view or call render to produce a PDF response or receive a filehandle. The module exposes many wkhtmltopdf options and allows per-request overrides and custom tmpdir and allowed asset paths. The recent 0.6.0 release fixed a command injection vulnerability (CVE-2026-16766), improved argument handling, added more option support and now returns a filehandle instead of raw contents. Note that wkhtmltopdf itself is no longer maintained and relies on old QtWebKit libraries so do not use it with untrusted HTML and consider migrating to a maintained PDF-generation solution.

EV::Gearman is a high-performance Perl client and worker for the Gearman job server built on the libev event loop and implemented in XS so there is no libgearman dependency. A single EV::Gearman object can act as both client and worker, supports foreground and background submissions, synchronous or asynchronous worker handlers, pipelining for high throughput, automatic reconnect and per-request timeouts, and the Gearman admin text commands over the same connection. It exposes simple callbacks for job progress, completion and errors and lets async workers defer completion until later so you can integrate timers or other IO. The module operates on raw byte strings so you must encode/decode UTF-8 yourself and it enforces practical limits such as a 256 MiB packet cap and a 16 MiB admin reply cap. Note that DNS name resolution is currently synchronous and can block the event loop, and some server queue types may not execute scheduled epoch jobs with certain gearmand versions, so validate against your deployment. If you need an efficient, event-driven Gearman client/worker in Perl with low-level control and maximum throughput, EV::Gearman is a strong choice.

Business::ISBN::Data is a companion data package for Business::ISBN that provides the official ISBN range and publisher code information derived from the ISBN Agency's RangeMessage.xml, so Business::ISBN can validate, parse, and format ISBNs correctly. The module is normally loaded automatically by Business::ISBN and ships with a copy of RangeMessage.xml while also falling back to built‑in data or a RangeMessage.xml found in the current directory, and you can point it at an alternate file by setting the ISBN_RANGE_MESSAGE environment variable before loading Business::ISBN. Note that the data structure changed to address an ISBN‑13 prefix bug so you should use Business::ISBN 3.005 or later. The data are updated frequently and available on GitHub, and a recent fix stopped unintended autovivification of ISBN_RANGE_MESSAGE to avoid accidental creation of that variable.

Socket::MsgHdr is a lightweight Perl module that exposes the low level sendmsg and recvmsg socket calls and gives you a convenient object to describe message buffers, peer addresses, and ancillary control data such as file descriptor passing and IPv6 packet options. You create a Socket::MsgHdr object to allocate receive buffers or to pack outgoing data, use the cmsghdr method to build or parse control messages like SCM_RIGHTS, and then call sendmsg or recvmsg just like the C APIs while benefiting from a Perl-friendly interface that also exports into IO::Socket. It is aimed at developers who need advanced socket features rather than simple TCP/UDP I/O, and it notes some portability gaps because the XS layer currently uses RFC 2292 CMSG macros and does not support legacy msg_accrights layouts on very old systems. A recent update makes recvmsg populate the object’s msg_flags field so you can inspect message-level flags after a receive.

Data::NDArray::Shared provides a compact, typed N-dimensional numeric array that lives in shared memory so multiple Linux processes can read and write the same data concurrently. It supports fixed numeric dtypes (floating and signed or unsigned integers), 1 to 8 dimensions with row-major layout, and can be backed by a file, an anonymous mapping inherited across fork, or a transferable memfd. You get element and flat-index access, bulk fills and zeroing, reshape without copying, reductions like sum and mean, in-place scalar and element-wise arithmetic, and convenient conversion to and from PDL when available, including an optional zero-copy PDL alias for in-place PDL operations. Mutations are serialized with a futex-based write-preferring rwlock that includes dead-process recovery so crashes leave the array consistent, though integer arithmetic wraps to element width and very large integer sums may lose precision when returned as double. The module requires 64-bit Perl and Linux only. The 0.03 release fixes a use-after-free bug in add/subtract/multiply, tightens security and robustness, and bumps the on-disk format so files from 0.02 are rejected and must be recreated.

Data::Log::Shared is an append-only, lock-free shared-memory log designed for Linux systems running 64-bit Perl. It lets multiple concurrent writers append variable-length entries and lets readers replay from any offset, which makes it a good fit for audit trails, event sourcing and debug logging. Persistence is optional via a backing file, memfd, or an existing file descriptor, and readers can block waiting for new entries or skip slots abandoned by crashed writers. Truncate marks old entries as logically invalid but does not free physical space, while reset reclaims space but must only be used when no other process is using the log. The API provides append, read_entry, each_entry, tail and count inspectors, wait_for tailing, sync and unlink, and eventfd hooks for notifications. Backing files are created with conservative permissions by default and the module emphasizes high throughput in concurrent append and read workloads.

Data::KDTree::Shared provides a shared-memory k-d tree for fast spatial indexing and nearest-neighbour queries across processes, letting you store up to 16-dimensional points (each with a 64-bit id) and then perform single nearest, k-nearest, axis-aligned box, and radius queries far faster than scanning every point. Points are appended cheaply and the tree is automatically bulk-balanced on first query after inserts so query depth stays logarithmic regardless of insertion order. The index can be shared via a backing file, an inherited anonymous mapping after fork, or a memfd passed between processes, and queries run concurrently while mutations are serialized with a futex-based lock that includes dead-process recovery. The module requires 64-bit Perl on Linux and uses a fixed capacity chosen at creation, so you should size the index up front; there are also practical limits noted around reader-slot exhaustion and a very unlikely PID-reuse caveat for crash recovery.

Data::Intern::Shared is a Linux-only, 64-bit Perl module that stores each distinct byte string once in shared memory and assigns it a compact uint32 id that is stable and usable across processes. It is designed so shared data structures can keep fixed-size integer keys instead of duplicating strings, saving memory and making interprocess coordination simpler. You can create anonymous mappings, file-backed mappings, or transferable memfd mappings to share the same table across forked or unrelated processes. Lookups and intern operations are constant time and the implementation supports concurrent access with writer-preferring locking and crash recovery. Be aware that interning is permanent so there is no per-string removal, keys are treated as raw bytes so wide strings must be encoded first, and the capacities for number of strings and total arena bytes are fixed at construction. The recent 0.03 release changed the on-disk format so existing 0.02 files are refused and must be recreated, and earlier releases hardened security by creating backing files with a secure default mode.

Data::HyperLogLog::Shared is a Linux-only, 64-bit Perl module that implements the HyperLogLog probabilistic distinct-count sketch in shared memory so many processes can estimate the number of unique items seen without storing those items. It keeps a compact array of one-byte registers in an mmap region (default precision 14 uses about 32 KB and yields roughly 0.8% relative error), and exposes simple methods to add single items or batches, read the rounded estimate, merge another sketch of the same precision, clear the sketch, and inspect stats. Processes can share the same estimator via a backing file, an anonymous mapping across fork, or a memfd passed between processes, and mutations are protected by a write-preferring futex-based rwlock with dead-process recovery. The module creates secure backing files by default and supports syncing and unlinking the backing store. Limitations called out by the author are Linux and 64-bit only, no detection of PID reuse in the rare crash-recovery path, and a highly unlikely corner case if more than 1024 concurrent reader processes crash while holding the read lock.

Data::Histogram::Shared provides a Linux-only, 64-bit Perl implementation of an HdrHistogram stored in shared memory so multiple processes can record integer measurements into a compact fixed-size histogram and query percentiles, min, max and mean with a configured number of significant figures. You construct it with the lowest and highest trackable integer and desired precision, record single values or batches, and either attach a backing file, inherit an anonymous mapping across fork, or pass a memfd between processes to share the same counts array; a futex-based read/write lock with dead-process recovery protects concurrent mutation. The histogram is extremely memory efficient so you can record very large streams without growing memory, but it stores integers only so you must scale floating values yourself and it enforces range checks on inputs. It also supports merging histograms with identical geometry, syncing and unlinking backing files, and exposes stats and geometry information for introspection. Recent releases hardened file-creation permissions, fixed a use-after-free crash in merge() and record_many(), and introduced an on-disk format change that makes older files incompatible.

Termbox::PP is a compact, pure-Perl implementation of the Termbox terminal UI library that makes it easy to build text-mode interfaces without XS or external C libraries. It gives you a simple, cell-based back buffer for drawing text and attributes, functions to initialize and restore the terminal, helpers to print formatted UTF-8 text, and event objects for keyboard, mouse and resize handling so you can write a single-threaded render loop that responds to user input. The module aims to mirror the termbox2 API while staying small and portable, works out of the box on Unix with core Perl and can be used on Windows with the usual console support libraries, and it exposes utility routines for Unicode handling, color modes and low-level raw output when needed. The project is still evolving so expect occasional API tweaks, and recent updates have restored Windows Virtual Terminal support, improved Unicode width handling and performance, and fixed a few export and initialization edge cases.

TOML::XS is a fast, XS-backed TOML parser for Perl that embeds the tomlc17 C library so you do not need to install any external C dependency. It takes a raw byte string containing a TOML document and returns a Document object that can be converted into Perl structures or queried for individual values with get, with strings returned as decoded character strings, booleans represented by library constants, and timestamps exposed as Timestamp objects. The module is parser-only and does not provide serialization back to TOML. Recent updates switched the embedded engine to tomlc17 to address CVE-2026-16634, fixed several memory leaks, renamed the primary accessors to get and added microsecond-level timestamp accessors, all while preserving dramatically higher throughput compared with pure-Perl TOML libraries.

CGI::Info is a Perl helper for CGI scripts that collects and exposes runtime details so you do not need to hard-code script paths, host names, document root, temporary directories, or protocol information. It parses input parameters from real CGI requests or from the command line or stdin for local testing, supports file uploads with configurable size limits, and lets you declare an allow-list of permitted parameters using regexes, validation rules, or callbacks for contextual checks. The module includes convenience methods for cookies, a simple web-application-firewall style filtering to reduce common injection and traversal attacks, and client classification helpers such as is_mobile, is_tablet, is_robot, is_search_engine, is_ai and browser_type so you can tailor responses to phones, bots or known AI crawlers. CGI::Info is configurable at runtime from files or environment variables, accepts custom loggers and optional caching for IP lookups, and is intended as an extra layer of safety and convenience rather than a full security solution. Note that tablet detection is currently limited and params() returns a hash reference that callers should copy before mutating.

nup is a command line utility that displays files or the output of commands in an n-up, multi-column paged layout so you can read multiple pages or files side by side. It auto-detects whether an argument is a file or an executable and you can force command mode with -e. You control the grid, number of columns and rows, page height and pane width and pick border, line and color styles or one of several board color schemes. nup can run commands, define aliases, show filename headers, switch between paged and non-paged modes, enable parallel columns for side‑by‑side viewing, and use App::optex::textconv to convert common binary formats like PDF and Office files into text before display. It is handy as a MANPAGER or for comparing multiple outputs in one terminal. Note that stdout and stderr are merged into the paged output and the executed command’s exit status is not preserved.

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

Sys::OsRelease::Lite is a lightweight Perl helper that reads the standard /etc/os-release file and exposes the operating system and distribution metadata to your scripts in a simple, consistent way. It provides a singleton interface with ready-made accessors for common fields like id, id_like, version_id and pretty_name, plus generic methods to list, check and fetch any discovered attributes, and a platform helper that maps common ID_LIKE values to familiar platform names. The module keeps dependencies minimal so it is suitable for use in system scripts, installers and containers and it will fall back to Perl's native osname if no os-release file is found. Recent changes added a Sys::OsRelease::Lite packaging variant to maintain compatibility with older Perls before 5.22 and adjusted the Lite delivery for CPAN, making the same functionality available on legacy systems.

Sys::OsRelease is a lightweight Perl helper for reading the standard /etc/os-release file used by Linux and BSD to identify the operating system and distribution. It provides a singleton-based interface with convenient read-only accessors like id(), id_like(), name() and many more, plus generic methods such as get(), has_attr(), found_attrs() and platform() to return a normalized platform name. The module keeps minimal dependencies and supports both class-style and object-style usage so scripts can easily detect OS type for configuration, packaging or installation logic. It requires Perl 5.22 or newer and a repackaged Sys::OsRelease::Lite exists for older Perl versions.

Data::HierTimingWheel::Shared implements a shared-memory, multi-level timing wheel for Perl that lets multiple processes schedule and cancel timers in constant time no matter how far in the future they fire. It follows the Varghese-Lauck design used by the Linux kernel and systems like Kafka so far-future timers are parked in coarse levels and only redistributed as their firing time approaches, making scheduling and cancellation O(1) while using a fixed, predictable amount of memory. Timers carry an arbitrary 64-bit integer payload and are returned in fire order when a process advances the shared tick counter, and the wheel can be backed by a file, an anonymous mapping inherited across fork, or a memfd for cross-process sharing. The module is Linux-only and requires 64-bit Perl, enforces a fixed capacity and maximum delay based on the wheel geometry, and uses a futex-based writer-preferring lock with dead-process recovery; the author notes two narrow caveats, PID reuse is not detected and more than 1024 concurrent reader processes can create a rare edge condition that may block writers.

Data::Heap::Shared provides a lightweight, high-performance binary min-heap that lives in shared memory on Linux so multiple processes can push and pop integer (priority, value) pairs as a cross-process priority queue. You can create a fixed-capacity heap backed by a file, an anonymous MAP_SHARED mapping inherited by forked children, or a memfd-backed mapping whose file descriptor can be handed to another process for attachment. The API is simple: push, pop, peek, blocking pop with futex-based waits, and optional eventfd notifications for integration with event loops, plus methods to inspect stats, sync to disk, and remove the backing file. It uses mutexes with PID-based stale-lock recovery to handle crashed holders, but the author warns that crash recovery can leave the heap partially sifted so critical users should clear and rebuild after a recovery. This module is Linux-only and requires 64-bit Perl, making it a good choice when you need a compact, concurrent priority queue shared between processes.

Data::HashMap::Shared provides extremely fast, type-specialized hash maps that live in file-backed or memfd-backed shared memory so multiple Perl processes can read and write the same table with minimal overhead. It offers lock-free read paths, futex-based writer locks, atomic integer counters, compare-and-swap, optional LRU eviction and per-key TTLs, and an arena for storing strings, so it doubles as a high-performance cross-process cache and counter store. Multiple variants cover integer-to-integer and string-to-string use cases and you can shard a map across files for parallel writes and higher total capacity. The module is Linux-only and requires 64-bit Perl, integer variants silently wrap to their fixed bit widths so pick an appropriate variant, and PID-based crash recovery assumes a shared PID namespace (so cross-container sharing is not supported). Backing files are created owner-only by default for security and a recent release changed the on-disk format, so existing files must be migrated with the bundled hashmap-shared-upgrade tool or the upgrade_file API when upgrading to the latest version.

Data::Graph::Shared provides a fast, Linux-only shared-memory directed weighted graph you can attach to from multiple processes to read and mutate a single in-memory graph. It supports file-backed, memfd and anonymous mappings and exposes simple operations to add and remove nodes and edges, read node data and neighbors, and query counts and degrees, with optional eventfd integration to signal updates to an event loop. Mutations are serialized by a process-shared futex mutex and the module includes crash-recovery logic that can reclaim the lock if a writer dies, but a process that crashes mid-write may leave partially applied changes so callers should treat writers as trusted. The design favors O(1) node removal of outgoing edges only to stay fast; use remove_node_full when you need incoming edges spliced out as well. It requires 64-bit Perl and is optimized for throughput, with benchmarks showing millions of simple ops per second, and recent releases tightened security by making backing files 0600 by default and fixed a use-after-free bug in add_edge along with other robustness improvements.