CPANscan

Consumer::NonBlock provides a lightweight way to pass text from a fast producer process to a slower consumer without making the producer block on a full pipe. You create a paired reader and writer, the writer sends lines or arbitrary text into rotating temporary files, and the reader consumes and deletes those files as it goes so processed data does not accumulate on disk. The module can store data in /var/shm for better performance, works across forks using an environment variable and a weaken mechanism to control which process deletes data or closes the stream, and is intended for cases where you cannot afford the producer to block rather than as a general replacement for pipes. This is an early release but it already fixes a buffering edge case that could split writes across file boundaries and corrupt lines.

Sieve::Generator is a compact Perl library for programmatically building RFC 5228 Sieve email filter scripts by composing a tree of objects and rendering them as correctly indented Sieve code. It is driven by the Sieve::Generator::Sugar layer, which exports short constructor functions such as sieve, ifelse, block, command and qstr so you can build, reuse and stitch together subtrees of filtering logic without dealing with class names. Each node implements as_sieve to produce final output, making this useful for mail server administrators and developers who want to generate or manipulate Sieve rules from code instead of hand editing. The current release tightens and simplifies the API by removing some lesser-used sugar, improves the command sugar for smarter argument typing and nicer formatting with tagged arguments, and adds convenience helpers var_eq and var_ne. Note that the author does not promise a fixed minimum Perl version, so verify compatibility with your environment.

SQL::Wizard is a Perl library for building SQL by composing immutable expression trees instead of concatenating strings. You create columns, functions, arithmetic expressions, joins, CTEs, window functions, CASEs and full SELECT/INSERT/UPDATE/DELETE statements as objects and nothing is rendered until you call ->to_sql, which returns a SQL string with "?" placeholders plus a flat list of bind values ready for DBI. Values are bound by default, identifiers are quoted and validated, and there are multiple injection guards while still providing a raw() escape hatch for cases the API does not cover. The API supports nested subqueries, compound queries, PostgreSQL and MySQL upsert patterns, RETURNING, and immutable modifiers so you can derive many variants from a base query. It has no non-core dependencies and currently emits standard ANSI SQL with a reserved dialect option for future database-specific rendering.

Math::GMPz is a Perl interface to the GMP C library that gives you fast, arbitrary‑precision integer arithmetic by wrapping the library's mpz (integer) functions. It lets you create and manipulate very large integers, perform high-performance arithmetic and bitwise operations, compute gcds, modular inverses and exponentiation, test for primality, produce random big integers, and import or export raw binary representations, and it overloads Perl operators so big integers behave much like native numbers. The module requires a compiled GMP library and provides both blessed objects that are auto‑cleared and unblessed variants that you must free manually. The author notes some practical caveats such as UTF8 handling in import/export, limits on certain formatted I/O calls, and that passing the wrong argument types at the C interface level can cause segfaults, but otherwise Math::GMPz is a direct, high‑performance bridge from Perl to GMP for anyone needing reliable big integer support.

Math::GMPq is a Perl interface to the GMP library for precise rational arithmetic, letting you create and manipulate arbitrarily large fractions with full support for parsing and formatting in many bases, canonicalizing (reducing) fractions, accessing numerator and denominator as big integers, and performing fast arithmetic and comparisons. The module wraps GMP's mpq routines and provides Perl-friendly constructors, conversions, operator overloading so native Perl operators work with big rationals, and RNG state helpers when you need random rationals. Blessed objects are cleaned up automatically but unblessed objects can be used if you prefer manual memory management. You do need the GMP C library installed and you should be careful to pass the correct argument types because incorrect types can crash the program. Use Math::GMPq when you need high-performance, exact rational math or tight interoperability with Math::GMP and Math::MPFR.

Math::GMPf is a Perl interface to the GMP library's mpf "bigfloat" routines that gives Perl programs access to arbitrary‑precision floating point arithmetic by wrapping the native GMP C API. It exposes initialization, conversion, I/O and formatted output, a full set of arithmetic and comparison operations, random number facilities, and operator overloading so you can use high‑precision numbers in Perl expressions much like built‑in scalars. Objects are blessed and cleaned up automatically though unblessed "nobless" variants are available if you prefer manual memory control. You must have the GMP C library installed to use it and recent releases improved comparison behavior so the overloaded <=> returns canonical values and added better quadmath support on Cygwin.

App::Test::Generator creates ready-to-run Test::Most fuzz and corpus-driven test harnesses from formal input/output schemas so you can automatically probe functions and methods for edge cases and regressions. You point it at a schema file, usually YAML, that describes the module, function, inputs, outputs, transforms and optional static corpora, and it emits a .t script that combines randomized fuzzing, deterministic boundary tests, type- and semantic-aware generators (email, uuid, timestamps and more), and optional property-based checks via Test::LectroTest. It supports both functional and OO targets, reproducible runs via a seed, configurable iteration counts, per-field and per-type edge-case injection, and can extract schemas from Perl source as a proof of concept for automated test generation and CI workflows such as GitHub Actions. Non-YAML input formats are less exercised and some configuration choices like seed and iterations live at top level rather than under config, and the distribution carries an unusual licensing restriction beyond a personal GPL2 allowance so review the licence if you plan wide or commercial use.

Mo::utils::Array provides a compact set of validation helpers for Mo-style Perl objects to ensure that attributes meant to be arrays are correct and consistent. The module supplies functions to check that a value is an array reference, to require at least one element, to enforce a maximum number of items, to verify that each element is an instance of a specified class, and to restrict elements to a defined list of strings. Failures are reported using Error::Pure and the routines themselves return undef, making them easy to plug into simple object validation workflows. Recent updates added item-count checks and string-list checks and moved a common object-checking helper into Mo::utils::common.

Regexp::Common::URI::RFC3986 supplies a comprehensive set of ready-to-use regular expression fragments that implement the URI grammar from RFC 3986, letting you validate or parse schemes, authority, paths, queries, fragments and host forms by interpolating plain string regexes into your own patterns. The module exports named fragments via selectable tags (for base character classes, path parts, host/authority productions, top-level URI productions, IDN helpers, or all of them) and deliberately returns non-capturing regex fragments as plain strings so they are easy to embed without pulling in Regexp::Common. It adds faithful support for IPv6 literals and the RFC 3986 IPvFuture form, includes non-normative helpers for pre-validating Unicode hostnames before ACE/punycode conversion, and preserves many RFC 2396 names for backward compatibility. There are no runtime dependencies beyond Perl's Exporter and the distribution is tested across modern Perl releases. This initial standalone CPAN release is a full transcription of RFC 3986 and fixes earlier IPv6 coverage so all appendix A alternatives are handled correctly.

Net::Nostr is a Perl library for working with the Nostr decentralized messaging protocol that gives you both a client and a relay implementation so you can connect to relays or run your own. It exposes high level factories to create Net::Nostr::Client objects for WebSocket connections, subscriptions and publishing and Net::Nostr::Relay objects for running relay servers, and ships companion components for event creation, signing and verification, keypair management, filtering, protocol messages, follow lists, deletion requests, threading, bech32 entities and encrypted payloads. It supports the key NIPs used by client and relay implementations including NIP-01, NIP-02, NIP-09, NIP-10, NIP-19, NIP-42 and NIP-44 so you can handle authentication, follow lists, deletions, threads, bech32 identifiers and encrypted payloads out of the box. If you want to build Nostr clients, integrate with relays from Perl, or run your own relay this module provides the building blocks to create, sign and transmit events and to manage keys and filters. Recent updates add convenience methods to persist keys from Net::Nostr::Key and improve the documentation.

App::FirefoxUtils is a small collection of command-line tools and Perl-callable functions for controlling and inspecting Firefox on Unix-like systems, offering ways to detect Firefox processes, list profiles, open groups of tabs, start, restart or terminate the browser, and pause or resume its processes to save CPU and battery life; its pause-and-unpause mode can alternate stop/continue periods so background web apps still get occasional updates. The routines are exportable for use from Perl and also installed as standalone CLI utilities, they return an enveloped array with HTTP-style status codes for easy scripting, and they accept flexible filters for matching processes. The latest release adds a --kde-activity option to the open-firefox-tabs command so you can switch KDE activities when opening tab sets.

IPC::Manager:DBI provides a set of database-backed client implementations for IPC::Manager so programs can exchange messages through a shared SQL store instead of a bespoke broker or socket layer. Each client uses two tables, one for tracking clients and one for messages, and messages are removed once read so the database acts as a transient message queue. You connect by supplying a DSN as the route plus typical DB credentials, and implementations are provided for MariaDB, MySQL, PostgreSQL and SQLite. The project source is on GitHub and the recent 0.000010 release split this functionality out from a larger DBI-Manager package.

IPC::Manager::Client::UnixSocket provides a Unix‑domain datagram socket transport for the IPC::Manager framework, giving each client its own SOCK_DGRAM socket so multiple writers can send messages to a single reader. It is useful when you need simple, local interprocess messaging on the same host and want to use the familiar IPC::Manager API to spawn managers, connect clients, send messages and fetch pending messages. Note that the suspend operation is not supported by this protocol. Recently the component was split out of the main distribution to live as its own module.

Business::ISBN::Data is a companion data pack for Business::ISBN that supplies the official ISBN range information from the ISBN Agency RangeMessage.xml file so the main module can validate, parse, and format ISBNs correctly by group and publisher ranges. You normally do not load it directly because Business::ISBN loads it for you, and you can point it at a newer or alternate RangeMessage.xml at runtime by setting the ISBN_RANGE_MESSAGE environment variable. If no external file is found the module falls back to built-in data or looks in the current directory, though those fallback sets may be older. The distributed package includes the RangeMessage.xml and provides instructions for regenerating the default data from the official file, and you must use Business::ISBN 3.005 or later because of an ISBN-13 data structure change. The source is on GitHub so you can inspect, update, or contribute improvements.

Dios gives Perl 5 a compact, Perl 6-inspired way to declare inside-out classes and rich subroutine signatures using simple keywords like class, has, shared, method, func, multi and submethod. It auto-generates constructors, destructors and accessors, enforces types and constraints via Dios::Types, and provides flexible parameter handling including positional, named, slurpy, aliased and readonly parameters, defaulting, return-type checks and basic tail-call elimination. The syntax makes it easy to write encapsulated, type-checked objects and multimethods without hand-rolling fieldhashes or parameter parsing, so it is useful when you want safer, more expressive OO and API declarations. Be aware of two limitations mentioned by the author: shared array or hash attributes do not work with lvalue-style accessors, and Dios relies on Keyword::Declare which creates compatibility constraints for some Perl versions and specific Keyword::Simple releases.

WWW::Tracking is a small, pluggable Perl toolkit for doing server-side website visitor tracking and for translating tracking data between formats and services. It gathers visitor details from HTTP headers, logs or tracking URLs into a unified data object and then lets you serialize or forward that data to different backends such as Google Analytics, Piwik, local logs or custom formats via plugins, which makes it useful for tracking clients without JavaScript, replaying recorded hits, running multiple trackers in parallel or migrating between services. The module is intentionally modular so parsers and delivery methods live in WWW::Tracking::Data::Plugin::* and you can call from(...) to populate data and make_tracking_request to send it, though the author notes it is still a work in progress and only the header parsing and server-side Google Analytics (plus some other plugins) are implemented out of the box. Recent updates around version 0.05 cleaned up issues reported by CPANTS and added explicit dependencies such as DateTime and URI.

IPC::Run is a mature Perl toolkit for launching and controlling external programs and pipelines while letting your script feed stdin and capture stdout and stderr, either all at once or interactively. It offers a simple run function that behaves like a safer, more flexible system replacement and an event style API with start, pump and finish for Expect like scripting and incremental I O. You can redirect to scalars, callbacks, filehandles or named files, stitch commands together with pipes or background them with ampersands, attach filters to massage or chunk data, and apply timeouts and timers to prevent hangs. Harness objects give you programmatic control to send signals, kill processes with a grace period, inspect PIDs and exit codes, and reuse or prebuild command sets. Pseudo terminal support is provided when you need a real tty, and Win32 support exists but is described as experimental with a number of platform limitations documented. If you need robust, scriptable subprocess management in Perl, IPC::Run is highly relevant.

OpenTelemetry::Instrumentation::namespace is an experimental Perl helper that can automatically add OpenTelemetry tracing to selected packages and subroutines without editing their source code. You give it ordered rules made of package name strings or regexes and optional nested rules for subroutine names, and it locates matching loaded modules and wraps their routines to start spans, while also installing a require hook so the same rules apply to modules loaded later. Configuration can be passed inline or via a YAML file and options let you ignore constants, private or import methods and prefer existing instrumentation libraries when present. This tool is intended to make it easy to selectively instrument large or third‑party codebases rather than replace bespoke instrumentation libraries. Note that it cannot discover subpackages that do not have entries in %INC so routines declared only inside another module file may be missed. Recent changes include a bugfix that ensures the caller-based install routine returns a true value.

IO::Tty is a low-level Perl module that allocates pseudo-terminals (ptys) and provides terminal-related constants for import. It is mainly a backend for IO::Pty so most users should use IO::Pty to create and manage ptys and only rely on IO::Tty directly when they need the raw constants or very low-level control. The module targets POSIX-style systems and has been tested across many Unix variants while Windows support is limited to the Cygwin environment. Because pty behavior is platform dependent the author documents a number of system quirks such as some platforms not reporting slave EOF back to the master and a historical hang when printing very long lines to a non-raw pty under Cygwin. The recent 1.25 release fixes a notable resource-handling bug so destroying a pty object no longer force-closes a slave handle held elsewhere, improving compatibility with tools like IPC::Run.

OpenAPI::Modern is a Perl toolkit for loading an OpenAPI v3.0, v3.1 or v3.2 document and validating HTTP requests and responses against that specification. It uses JSON::Schema::Modern for full JSON Schema evaluation and works directly with Mojolicious request and response objects or converts other common request/response types for best-effort validation. You construct it with your OpenAPI document or schema and an optional evaluator, then call validate_request or validate_response to get a detailed JSON::Schema::Modern::Result that lists validation errors and exact schema locations. The distribution bundles up-to-date metaschemas, supports draft2020-12 features and dialects, and includes guidance for caching large documents to speed startup. A few OpenAPI features are not yet implemented or are limited, for example cookie parameters, multipart and application/x-www-form-urlencoded bodies, some query styles, and automatic enforcement of security schemes, and parsing works most reliably when messages are provided as Mojolicious objects. If you need programmatic conformance checks between your HTTP traffic and an OpenAPI description in a Perl app or test suite, this module is a practical and standards-aware choice.

JSON::Schema::Modern is a Perl evaluator and validator for JSON Schema that implements the modern specification family up to draft2020-12, letting you check JSON data or Perl data structures against rich schema rules. You construct an evaluator, choose a specification version and output style, and call evaluate or evaluate_json_string to get a Result object that includes errors, annotations and optional default values when enabled. The module supports format checking, custom format, media-type and encoding handlers, strict keyword checking, short-circuit validation for speed, traversal and schema registration so you can preload or reuse schema documents, and helpers for OpenAPI-style workflows. It does not automatically fetch schemas from disk or the network so external documents must be added to the evaluator first and some output formats remain unimplemented. Recent updates tightened several format validators (hostname and duration) and added a with_defaults option to report missing default values for easy population of instance data.

Hypersonic is a Perl micro HTTP server built for raw speed that JIT-compiles C code so the event loop and hot paths run in native code rather than Perl. You register routes and call compile(), at which point static responses and static files are baked into C constants and the minimal native glue for dynamic handlers is generated, yielding very low overhead at request time. It includes first-class support for WebSockets and optional room-based broadcasting, streaming and Server-Sent Events, gzip compression, optional TLS, session cookies, an async thread pool for background work, and utilities for testing and dispatching requests. Hypersonic is aimed at use cases that need extreme throughput and minimal runtime overhead and it depends on XS::JIT and standard native libraries for optional features, so it is most relevant if you are comfortable with a compile step and native dependencies to get maximum performance.

XS::JIT is a small, focused Just-In-Time compiler that lets you compile and load C/XS code from Perl at runtime so you can generate native functions on the fly and install them into Perl namespaces. It is aimed at cases where you produce C dynamically and want fast, no-frills compilation: it skips heavy parsing and xsubpp, invokes the compiler directly without generating a Makefile, caches builds for reuse, and exposes a simple compile interface plus a C API so other XS modules can call into it. You can write plain wrapper-style C functions that return SV* or, for best performance, write XS-native functions and tell XS::JIT to create direct aliases to avoid wrapper overhead, and there are compatibility macros for code that targets Inline::C. If you need more features then Inline::C remains the fuller solution, but XS::JIT trades some of that breadth for much faster first-compile and runtime performance. Recent releases include important platform fixes, notably macOS hardened-runtime and SDK include fixes and improved dlopen path handling, which make runtime loading more robust on modern systems.

Sys::Async::Virt is an asynchronous Perl client for the libvirt remote protocol that lets you manage virtual machines, networks, storage pools and host information from Perl code over SSH, TCP or external process transports. Its methods mirror the libvirt API in an object oriented way and return Futures that you can await with Future::AsyncAwait so operations like creating domains, querying host stats or subscribing to domain and network events integrate cleanly into evented programs. The module handles protocol details for you, offers event callback/stream support for things like volume upload/download and converts some C-style types into Perl-friendly forms such as cpumap arrays and typed-parameter hashes. It supports SASL and other authentication methods, includes many libvirt entry points and a large set of constants, but remains marked experimental and a few migration- and file-descriptor-related entry points are not yet implemented; some older libvirt servers lacking specific protocol features may therefore not be supported. This release was updated to track libvirt v12.2.0 and adds a few new constants to match that protocol version.

Protocol::Sys::Virt implements the LibVirt RPC protocol in Perl and provides the building blocks for LibVirt-aware clients and, if you really need one, servers. It supplies generated message (de)serializers, transport and stream handling, URI parsing, typed-parameter helpers and keepalive support so you can integrate LibVirt with evented or future-based async code instead of using the blocking Sys::Virt API. The module follows LibVirt release tags so it stays aligned with the upstream protocol, and recent work added stream handling, typed-parameter utilities and improved async callback behavior. Note that a recent change standardized the mapping of byte/char arrays to strings (with a follow-up fix for a mapping regression), so you may need to adjust code that previously expected arrays of integer bytes.

Sys::Virt is a Perl XS binding for the libvirt virtualization API that lets Perl programs connect to hypervisors and manage virtual resources with a single, consistent interface. You can open connections to local or remote backends using libvirt URIs and then list, define, create, start, stop and inspect domains, networks, storage pools, interfaces and node devices, gather host and guest statistics, perform migrations and save/restore operations, and register event callbacks for changes. The API handles authentication callbacks and raises Sys::Virt::Error exceptions on failure so it fits into standard Perl error handling. Event callbacks and close callbacks are supported but must be explicitly deregistered to allow the connection object to be garbage collected. The module is actively maintained and the recent 12.2.0 release added constants to control zeroing behavior during block-copy and disk-migration operations and a constant to expand CPU feature reporting when querying domain capabilities. Note that the XS layer interacts closely with libvirt and the author advises auditing callback management to avoid leaks.

Zabbix7::API is a lightweight Moo-based Perl client for talking to a Zabbix 7.x server over its JSON-RPC API. It provides easy methods for login, logout, raw queries and for fetching Zabbix objects as Perl objects via fetch and fetch_single while delegating class-specific behavior to Zabbix7::API::* wrappers. HTTP requests are made with LWP::UserAgent and logging goes through Log::Any, and SSL is supported when LWP::Protocol::https is installed. The module favors explicit create, update and exists operations and can optionally re-pull server-generated values after writes via pull_after_push_mode to simplify provisioning workflows. Not every Zabbix class is wrapped and the author notes the primary focus has been on reading hosts rather than creating objects, but recent releases added support for Event and Problems.

Object::Proto is an alternative object system for Perl that gives you prototype chains and very fast, array-backed objects while keeping normal blessed semantics so isa, can and package methods work as expected. You declare a class and its properties at compile time and the module maps names to array slots and installs compiled accessors, supporting positional or named constructors, type constraints and modifiers like required, readonly, default, lazy/builder, clearer and trigger. You can register custom types in Perl or at the XS level for near-native speed, import function-style accessors compiled to custom ops for the highest performance, use roles and method modifiers, control mutability with lock/unlock/freeze, clone objects shallowly, and define DEMOLISH cleanup handlers that are called on destruction. If you need compact, high-performance objects with built-in typing and extensible type checks, Object::Proto is a solid fit. This is the initial release split out from the Ancient distribution and it ships with prototype chains, a rich slot specification system and an XS API for type registration.

Log::Fmt::XS is a lightweight performance-focused companion to Log::Fmt that swaps in XS (C) components to speed up emitting logfmt-formatted logs; it acts as a subclass of Log::Fmt so you can expect the same API and behavior while gaining lower overhead and higher throughput for structured logging. If you already use Log::Fmt and are looking to reduce logging latency or CPU cost in high-volume applications, this module is relevant. The distribution carries no fixed promise about future Perl version requirements and this 0.001 release is the initial published version by Rob Mueller.

Log::Dispatchouli is a lightweight convenience wrapper around Log::Dispatch that makes adding logging to a Perl program easy and configurable without deep knowledge of syslog facilities or log categories. It can send messages to syslog, stdout, stderr, a rotating file, or an in-memory array for testing, and it uses String::Flogger so you can log plain strings, sprintf-style arrayrefs, data structures, or lazily evaluated coderefs. The API centers on simple methods like log, log_debug and log_fatal plus log_event for structured, logfmt-style key=value output, and it supports global and per-message prefixes, proxy loggers for localized context, and test-friendly loggers that capture events. You can toggle debug and muted modes at runtime, control whether logging failures are fatal, and pull the underlying Log::Dispatch object if needed. A few features are noted as experimental or deprecated, and the structured-event expansion is convenient but not meant to be a full serialization system. If you want straightforward, flexible logging with minimal ceremony and good support for structured messages and testing, this module is a practical choice.