CPANscan

Protocol::Sys::Virt implements the libvirt RPC protocol in Perl, providing the XDR (de)serializers, transport and stream handling, URI and unix-socket helpers, and ancillary routines you need to build libvirt-aware clients and low-level tools. Its main purpose is to enable truly asynchronous, non-blocking interaction with libvirt from Perl without relying on Perl threads, so it fits event-loop and Future/async-await style code where Sys::Virt’s synchronous API would block. This distribution is a protocol-level toolkit rather than a high-level convenience wrapper, so it is most relevant if you want to implement custom transports, integrate libvirt into async applications, or build diagnostic and protocol tooling; building a full libvirt server is supported but generally unnecessary. The module follows libvirt’s protocol releases and is currently updated to libvirt tag v12.7.0, so it includes the protocol additions and event constants up to that release. Documentation is still a work in progress, but the changelog shows ongoing fixes and feature additions such as stream support, URI parsing, typed-parameter helpers, and keepalive improvements.

Config::INI::RefVars is an enhanced INI parser for Perl that turns configuration files into plain Perl data while adding powerful features like variable references, built-in and user-defined function calls, include directives, line continuations and several assignment operators for flexible value composition. It produces a hash-of-hashes via the variables method, supports cross-section references, access to environment and Config entries, and a special tocopy section or optional global mode for shared defaults, and you can register custom built-in functions when constructing the parser. All references and function calls are resolved during parsing so the result contains only simple scalars, and parsing errors such as recursive references or syntax problems throw exceptions and may leave the object unusable. The module requires Perl v5.10.1 or newer. Recent releases added a registerable builtins mechanism and extra built-in helpers such as catpath and the newest maintenance release corrected license metadata.

App::Envdoctor is a small command-line tool that checks consistency between environment variables your Perl code actually uses and the variables declared in your .env files. It scans source for $ENV{VAR} references and reports variables that are used but not defined as errors and variables that are defined but never referenced as warnings, which helps you catch missing configuration and clean up stale entries. The tool runs locally only, never uploads data and never prints variable values, so it is safe to run in projects with sensitive settings. Use it when you want a quick, automated way to validate and tidy environment configuration for Perl projects.

Robots::Validate is a utility for web applications that checks whether an HTTP user-agent string that claims to be a known web robot actually comes from the robot's documented IP space. It uses a rules file of agent names, domain suffixes and network blocks to either match an IP directly or perform reverse DNS plus forward-confirmation to verify a hostname belongs to the robot, and it returns a clear success, failure or unknown result so you can treat bots differently in logging, rate limiting or content negotiation. The module now matches multiple agent substrings efficiently with the Aho-Corasick algorithm, supports a configurable TOML rules file, optional caching of results and adjustable validation modes to control how overlapping agent names are handled. The recent 0.4.0 release is a complete rewrite that raises the minimum Perl version, adds caching and match-mode control and introduces limits on forward DNS lookups to mitigate abuse. Be aware that the rule set is not exhaustive, cloud or decentralized crawlers may not be verifiable and DNS-based checks can be unreliable, so you should follow the module's guidance when configuring cache expiry and domain suffix rules.

Text::Table::Read::RelationOn::Tiny parses simple text "cross" tables that represent a binary relation on a set and turns them into a programmatic incidence matrix plus a list of element names and their numeric ids. It reads ASCII tables where cells are either a marker (default "X") or empty, accepts input from files, strings, array refs or filehandles, and returns a hash-of-hashes incidence matrix, an element array and an id map in one call. The module supports preset base sets and equivalent-element groups, optional subset tables, a pedantic mode to enforce table formatting, options to use external data without copying, and helpers to return named matrices or a blessed matrix object with a related() method. If you work in Perl and need to convert human-readable relation tables into adjacency/incidence structures for graph, relation or matrix processing, this is a compact, well documented tool that requires Perl v5.10.1 or later; the most recent updates mostly tidy documentation and security metadata.

Photonic is a Perl toolkit for modeling and computing the optical response of metamaterials and photonic structures. It gives you modular building blocks to describe geometry from characteristic functions, microscopic dielectric maps, or 2D images and to compute dielectric tensors, longitudinal responses, Green tensors, microscopic fields, Haydock coefficients, and second harmonic susceptibilities. The distribution supports binary and multi‑phase systems and offers both non‑retarded (longitudinal) and wave‑equation based formalisms, including a spinor representation for complex materials, plus utility and role modules to factor common behavior. It is aimed at researchers and engineers who need scriptable, reusable tools to extract macroscopic and microscopic optical properties and is released under GPL/Artistic licensing.

MIDI::RtMidi::Util is a compact helper module for working with real-time MIDI from Perl, providing simple utilities around MIDI::RtMidi::FFI::Device. It lets you open an output by part of its name with out_port, stop and close a RtMidiOut with halt, and query available inputs and outputs with input_ports and output_ports. Recent changes removed an automatic program exit from halt and added the input_ports and output_ports functions to make port discovery and graceful shutdowns easier.

Crypt::Age is a pure-Perl implementation of the age file-encryption format that lets Perl programs generate X25519 keypairs, encrypt and decrypt data or files, and interoperate with the standard age and rage command-line tools. It uses modern primitives provided by CryptX (X25519 for key agreement, ChaCha20-Poly1305 for authenticated encryption and HKDF-SHA256 for key derivation) and offers both simple in-memory APIs for small payloads and streaming filehandle APIs that read and write in 64 KiB chunks so memory use stays bounded. The module supports Bech32-encoded age public and secret keys and implements the X25519 recipient type end-to-end, but it does not implement scrypt (passphrase) recipients, SSH recipients, post-quantum/tagged recipient types or ASCII armor. Recent releases tighten spec compliance and safety: header parsing is stricter (now rejects headers with no recipient stanza), parsing and encoding are more exact, and error messages and checks were hardened to avoid accidental leakage of key material and to improve interoperability with age/rage.

Rex::LibSSH is a Rex connection backend that uses Net::LibSSH to run commands and perform file and filesystem operations over plain SSH exec channels instead of SFTP, making it useful for minimal containers, embedded systems, or any host where an SFTP subsystem is not available. You enable it by setting the connection type in your Rexfile and it supports public key authentication with optional strict host key checking for interactive security. Unlike Rex's built-in SSH drivers this module implements stat, ls, upload, download and similar operations by shelling out over SSH, so it works where SFTP would be missing, but it does not route filesystem calls through Rex::Interface::Fs::Sudo and upload/download/read-mode calls keep the entire file in memory on both ends. Recent 0.003 fixes make exec() accept the three-argument signature used by Rex::Commands::Run so environment hashes and shell options are passed through, add input validation to block NUL bytes and unsafe glob metacharacters, and include tests proving operation against sshd builds without an SFTP subsystem.

Net::LibSSH is a Perl XS binding for the libssh C library that gives Perl programs direct SSH capabilities such as opening session channels and running remote commands. You create a session, set host, user, port and other options, connect and authenticate by password, public key or agent, then open Net::LibSSH::Channel objects to exec commands and read their output; an optional SFTP interface is available but returns undef if the remote server does not support SFTP. Because it exposes exec channels rather than a file-transfer API, file operations can be implemented on top of channels so SFTP is not mandatory for automation. Note that the module is not thread safe and does not support fork, and once a session has been connected and then disconnected it cannot be reconnected, so use one connection per process and check error messages via the error method.

Alien::libssh is a small helper module that supplies the libssh C library for other Perl modules so they can compile and link against SSH functionality. It prefers a system-installed libssh discovered via pkg-config and falls back to building a bundled copy from source with CMake so no network access is required at install time. The module exposes standard Alien::Base methods such as cflags and libs so build tools and XS modules can pick up the correct compiler and linker flags. The recent 0.002 update fixes the bundled (share) build so the packaged tarball is actually used, builds libssh statically and appends -lcrypto and -lz so XS consumers do not require a runtime libssh.so, and makes sure pkg-config is used to gather flags on both install paths while forcing the share build during author release tests to exercise the offline fallback.

AmberDB is a high-performance flat-file NoSQL engine for Perl that sits on top of Berkeley DB (DB_File) and gives you schema-driven records, precomputed inverted indexes, columnar facet indexes, and full ACID transactions with undo journaling and strict two-phase locking for safe multi-table updates. You can use it like a document store with nested repeating blocks or in a lightweight simple mode as an ultra-fast schemaless key-value store that supports RAM-disk caching, full-text search with multilingual normalization, slug maps, and a rich set of helpers for inserts, updates, deletes, reads, filtering and pagination. Schemas live on disk or can be changed at runtime, indexes are built automatically from schema definitions, and the API exposes both high-level operations (field_fetch, search_table, read_all) and low-level DB_File access for bulk or recovery tasks. Recent releases hardened ID validation and simple-mode key sanitization, standardized slug handling and .slg files, and strengthened concurrency and cross-platform flocking; note that a previous release introduced an important migration: your schema directory must be named schema/ rather than scheme/.

Perl::Critic::Policy::ProhibitPipeOpen is a linting rule for Perl that spots and forbids using open with pipe modes to start external processes, closing a loophole left by other policies that already flag system, exec, qx and backticks. It makes sure pipe opens like open(my $fh, '-|', ...) or the old "ls |" spelling are treated the same as other shell-outs so every use of spawning a command must be made explicit with a "## no critic" and an accompanying justification. Ordinary file opens remain allowed and normal. The policy runs at the highest severity and is grouped under security and performance, and note that it only recognizes a pipe mode when that mode is a literal in the source code.

Crypt::OpenSSL3 is a modern Perl wrapper for the OpenSSL cryptography library that gives Perl programs access to SSL/TLS connections, asymmetric keys, symmetric ciphers, message digests, MACs, KDFs and X.509 certificate handling via focused submodules such as Crypt::OpenSSL3::SSL, ::PKey, ::Cipher, ::MD, ::MAC, ::KDF and ::X509. The top-level module itself provides error handling and build-time introspection so you can query OpenSSL version and configuration from Perl. The distribution is actively maintained and keeps pace with OpenSSL changes, adding features like HPKE, PKCS7, ASN1 helpers, encoding/decoding, X509 store/context improvements and password-callback support for private keys, and it is available under the Apache 2.0 license.

Punk::Authorisation provides row-level authorization for Punk web applications by letting you define simple, application-owned rules that answer whether the current user may act on a specific database row. It supplies a plugin that installs a rule DSL and controller helpers so you can write checks like $c->may('doc.edit', $doc) and get clear outcomes, with refusals translated into the correct HTTP responses to avoid leaking the existence of other users' rows. The distribution also offers an optional grants table (Punk::Model::Grant) when you need delegated permissions and integrates with Punk's auth configuration for role ladders. This initial release extracts the logic from Punk::DIY and includes a demo application that exercises every rule against every row.

Tomba::Finder is the official Perl client for the Tomba.io Email Finder API that makes it easy to discover and verify contact data from Perl code. It exposes one-line methods for common tasks like searching a domain for known emails, generating the most likely address from a name and domain, verifying deliverability, enriching a profile from an email, finding author or LinkedIn emails, locating phone numbers, searching companies, managing leads and API keys, and running bulk operations. The module acts as a simple facade mapping API endpoints to Perl methods while also offering standalone submodules if you need more granular control. If you are building contact discovery, lead enrichment, or data verification into Perl scripts or apps, this module provides a ready-made, documented interface to the Tomba service and includes examples and links to full API docs.

Punk::APIKey is a plugin for Punk applications that provides a complete API key system for issuing and validating bearer tokens. Keys are generated once, stored as a digest, and presented to clients as an "Authorization: Bearer" token, while the framework enforces scoped access, per-key rate limits, revocation, and checks against the key owner’s current standing. The distribution includes a default database model and Sqitch schema for SQLite/Postgres/MySQL, a command-line tool for issuing, listing and revoking keys, and a ready-to-run example application that demonstrates minting, using, demoting, suspending and revoking keys. If you need token-based API access with scope control and operational features like rate limiting and owner-aware enforcement, this module provides an out-of-the-box solution for Punk apps. This is the initial 0.01 release.

Weather::NHC::TropicalCyclone is a lightweight Perl client that reads the National Hurricane Center's CurrentStorms.json and presents each active storm as a Storm object so your code can list, inspect, and fetch details for current or archived tropical cyclones. It can fetch live data from NHC or load saved JSON from a file or memory, offers simple validation with warnings for any unknown fields that are preserved, and provides helpers to fetch basin RSS feeds. The constructor accepts a HTTP::Tiny-compatible object for testing or custom transports and fetch accepts options like timeout, save_to, and url for mirrors or replay. The parser is intentionally tolerant of additive changes to the feed and is kept up to date with NHC formats through the 2026 season, making this module a good fit for developers building monitoring, replay, or archival tools that need programmatic access to NHC storm status.

PDL::IO::Matlab lets Perl Data Language (PDL) arrays be saved to and loaded from Matlab .mat files by wrapping the matio C library, with both a simple functional API and an object-oriented interface. It supports Matlab formats 4, 5 and 7.3 and can read and write real multi-dimensional arrays, with optional zlib compression when available. The module only handles PDL-compatible numeric arrays so other Matlab datatypes will raise errors, and users should be aware that 1-D PDLs must be represented as 1xN or Nx1 in Matlab because Matlab has no native 1-D vectors. Also, PDL uses row-major ordering while Matlab uses column-major ordering so indices will appear transposed unless you explicitly handle that. Octave compatibility has quirks such as overwriting of duplicate variable names in MAT5 files and errors if MAT73 support is not present in the linked libmatio. Recent updates refresh libmatio to 1.5.30 and add a check that prevents creating MAT73 files when the installed libmatio lacks HDF5 support, with some test modernisation; compression support and other build improvements were added in earlier releases. Overall this is a practical tool for exchanging numeric arrays between PDL and Matlab/Octave when you stick to real numeric arrays and mind the format and dimensionality caveats.

Aion is a modern object system for Perl 5 that gives you a Moose-like way to declare classes and roles with typed, validated attributes and flexible aspects. You define features with has(...) and use aspects such as is, isa, default, lazy, coerce, trigger and others to generate accessors, predicates and clearers while enforcing constructor parameter rules and runtime type checks. Roles can declare requirements, inherit and refine interfaces, and even add new aspects to features, and method signatures can be validated with the :Isa attribute. Aion also integrates a dependency injection pattern via its pleroma container and the eon aspect, making it a compact, extensible alternative to Moose/Moo/Mouse for Perl developers who want strong attribute validation, role composition and DI support without the heavier Moose machinery.

Sisimai is a Perl library that parses bounced email messages and turns them into easy to use structured data, returning Perl objects or JSON so you can programmatically see the recipient, sender, SMTP codes, delivery status and a categorized bounce reason. You call Sisimai->rise with a mailbox path, Maildir, file, STDIN or even a string to get an array of Sisimai::Fact objects and you can call Sisimai->dump to get JSON output, with options to include delivered or vacation results and an origin field that records the source. The module ships parsers for many MTAs and a comprehensive set of reason detectors, and it offers helper methods like engine, reason, match and version plus a callback feature to extract or store custom data during processing. It is actively maintained and requires modern Perl, and recent releases added support for newer Perls and fixed a ReDoS vulnerability in HTML parsing while continuing to refine MTA patterns and status code handling.

File::Access::Driver is a lightweight Perl class that wraps common file operations into a single, easy API so you can create, truncate, delete, check existence and write file content without hand‑rolling filehandle management. You set files by directory, filename or full path and can enable an in-memory buffer or persistent open filehandles for better performance. The module is a "batteries included" convenience layer that reduces boilerplate and centralizes resource cleanup, and it reports problems via getErrorCode and getErrorString rather than throwing exceptions so you can inspect status after each call.

Object::Meta is a small Perl class for holding a piece of raw data together with separate meta information while keeping the two clearly distinct. You create an Object::Meta and then set or retrieve data fields and metadata fields independently. You can also declare an index field and set its value so instances can be automatically indexed and used in an Object::Meta::List. The object can be cleared of its contents without losing the index configuration. It is lightweight and avoids the need to write detailed definition modules, so it is useful when you need a simple, indexable container that carries both payload and metadata.

OpenSearch::Client is an unofficial Perl client for OpenSearch that lets Perl applications connect to and interact with OpenSearch clusters for indexing, searching and basic cluster operations. It is derived from the Search::Elasticsearch client so many callers will find the API familiar while it follows the OpenSearch project's diverging API. Documentation is available via OpenSearch::Client::Manual and a companion utility, OpenSearch::Client::Hash, can produce BCrypt, Argon2 and PBKDF2 password hashes for user creation. The module is maintained by Mark Dootson and distributed under the Apache 2.0 license, making it a practical option for Perl projects that need OpenSearch integration.

Algorithm::UrataniTakeda implements the Uratani-Takeda multiple-string search algorithm to let you find many patterns in a text quickly by combining ideas from Aho-Corasick and Boyer-Moore, with behavior similar to Commentz-Walter. You construct it with a list of patterns and then either call search with a callback that is invoked for each match, use matches to collect all matches, or use first to get the first match. The callback may return false to stop further searching. This is an experimental implementation that requires Perl 5.26 or later, the initial release is on GitHub, and issues or test cases should be reported there.

File::Raw::Archive is a lightweight, streaming archive reader and writer for Perl that focuses on practical, script-friendly access to tar-style archives while letting you add other formats via plugins. It ships with robust tar support that understands ustar, GNU longname tricks, and PAX extended headers and can auto-detect or write gzip-compressed streams. You can iterate entries or build archives with a simple API that includes open, each, list, extract, extract_all and create, and convenience exported functions for one-liners. Extraction supports platform extended attributes by default and protects against path-traversal unless you explicitly opt out, and it can dispatch content to forked workers for parallel extraction on systems with fork. If you need to support zip, cpio, ar or other formats you can install sister modules that register format plugins, making this a flexible choice for tools that inspect, extract, or create archive containers from Perl.

File::Raw is a high-performance Perl file toolkit that exposes simple, easy-to-use functions for common tasks like reading and writing whole files, appending, streaming lines, memory-mapped reads, atomic writes, copying, moving and inspecting file metadata while avoiding PerlIO overhead. Its API gives you slurp/spew helpers, an efficient each_line callback for streaming, a lazy lines iterator, mmap access for zero-copy reads, and a stat call that caches results to reduce syscalls. Built-in helpers cover head, tail, grep/map/count over lines and a small predicate system so you can filter text easily. A plugin system lets you register format and codec handlers such as CSV or gzip and chain them for composed read and write workflows, and there is a C-level XS API so high-performance plugins can be written in native code. The module focuses on speed using direct read/write syscalls and platform optimizations like sendfile and copyfile, and it provides safety features such as atomic_spew for crash-safe writes. Note that iterator use with a plugin is eager and will slurp the file into memory, each_line is recommended for true streaming, and the internal stat cache must be cleared if external processes change files.

Fetch is a modern Perl HTTP client that puts its performance-critical socket, TLS and HTTP/2 code in C while exposing an easy async API in Perl. Each request returns a Fetch::Future so you can await a single call synchronously or run thousands of requests concurrently on Fetch's built-in event loop or on IO::Async, AnyEvent or Hyperman. It supports HTTP/1.1 and HTTP/2 over TLS with protocol negotiation, keep-alive connection pooling, redirects, per-request timeouts, streaming body callbacks, a cookie jar, JSON helpers and native WebSockets. You can observe every outbound hop with request hooks, clone agents to share pools but isolate cookies or headers, and even drive Fetch from C via a small ABI when embedding in XS code.