CPANscan

CPAN::Perl::Releases::MetaCPAN lets you map Perl releases on CPAN to their tarball locations by querying the MetaCPAN API, so you can programmatically find download URLs and basic metadata like author, version, date, maturity and checksums. It offers an object interface to fetch structured release lists and a simple exported function perl_tarballs for getting tarball paths for a given version, making it useful for scripts or tools that need to locate or download official Perl release archives. The module mirrors CPAN::Perl::Releases but uses fastapi.metacpan.org for its data and includes links to artifact attestations for provenance.

TOML::Tiny is a minimal, pure-Perl TOML v1.0 parser and serializer that lets you read TOML files into native Perl data structures and write Perl hashes back out as TOML. It offers both simple functional calls and an object API and handles tables, arrays, strings, datetimes and booleans while providing hooks to customize how integers, floats, booleans and datetimes are inflated, falling back to Math::BigInt or Math::BigFloat when values exceed native precision. The module defaults to somewhat stricter parsing than older TOML libraries, supports quoted and multiline strings, binary/oct/hex integers and special float values like inf and nan, and aims to be compatible with TOML and TOML::Parser while adding a few useful options. Its pure-Perl, lightweight design makes it a good choice for scripts and environments where dependencies should be minimized. Recent releases removed a hard dependency on TOML::Parser and fixed tests when Types::Serialiser is not present.

Catalyst::Plugin::OpenIDConnect is a plugin for the Catalyst web framework that makes it easy to turn your application into an OpenID Connect provider, providing the authorization server side of OIDC and OAuth 2.0. It handles the common plumbing you need, including JWT creation and verification, state and code storage, and a reusable controller that mounts the standard endpoints and discovery document so you get authorize, token, userinfo, jwks and logout endpoints out of the box. You configure issuer details, signing keys and client registrations in your app config and then add a controller that extends the plugin controller so you keep full control of routing and integration with other Catalyst plugins. The plugin does not implement the OIDC client role, and it supports conditional initialization so apps sharing code can opt in to being a provider.

Astro::UTDF is a Perl module for reading and manipulating Universal Tracking Data Format files and turning each 75‑byte binary record into an object with convenient accessors for timestamps, azimuth, elevation, range delay, Doppler counts, transmit frequency, antenna metadata and many other UTDF fields. You can bulk read a file with slurp and get a sequence of Astro::UTDF objects linked to their prior record so the module can compute Doppler shift, range rate and human‑friendly measurement times, and you can also construct or modify records via mutators or by supplying hex/raw record data. The module exposes controls for validity checking, lets you override computation factors such as M and K and set transponder latency, and includes a decode helper that formats several fields for display. Note that the author marks the code as alpha and it was developed without access to the full UTDF specification, so users should validate results against their own data. Recent maintenance updated metadata and added a pointer to a Python implementation of UTDF for reference.

Alien::YARA is an installer wrapper that makes the YARA C library easy to use from Perl by locating a system libyara or downloading and building a local copy when needed, so FFI or XS modules can reliably link to it across Linux, macOS, and Windows. It exposes simple helpers such as dynamic_libs to give the shared library path, and cflags and libs for compiling or linking, and it can install YARA into a local dist_dir for isolated use by modules like YaraFFI. The module removes the friction of packaging a native dependency for Perl code that needs YARA binaries and works with Alien::Base and Alien::Build under the hood. In the latest release the download was switched to the official YARA release tarball which includes pre-generated configure scripts, eliminating downstream requirements for autotools during the build.

textconv is an App::optex extension that extracts plain text from a variety of non-text files so they can be treated like text by tools such as optex or git. It leaves the original files untouched and converts Office Open XML documents, legacy Word and Excel files, PDFs, JPEG metadata, web pages, and even encrypted .gpg files into text for diffing, searching, or viewing. The distribution includes a fast, simple XML regex converter for .docx/.pptx/.xlsx and optional backends that call pandoc or Apache Tika for more robust conversions. You can invoke it directly with optex -Mtextconv or use it via git textconv to make binary documents human readable in diffs. The latest release switched to Command::Run::Tmpfile for temporary file handling, so it now requires Command::Run 1.01 or newer.

optex is a small collection of command modules for the optex command-line tool that lets you add or organize subcommands as separate Perl modules. You run commands via the optex driver with a syntax like "optex command [-Mmodule] ..." or by making a symbolic link named for the desired command so optex will dispatch to the matching module. The repository contains the module implementations and the optex script includes its own manual, making it easy to extend the command set or reuse existing command modules. It is aimed at developers who want a modular, scriptable way to build or customize command-line tools and pairs naturally with the Getopt::EX option-handling approach.

Command::Run is a lightweight, dependency-free Perl utility for running external commands or calling Perl code references and capturing their input and output in a simple, chainable API. It makes it easy to feed data to a command, capture stdout and stderr separately or merged, and retrieve the exit status and pid, and it can expose the captured output as a file-descriptor path (for example /dev/fd/N) so other programs can read it. For Perl code references it supports a nofork mode to avoid fork overhead and an optional raw mode to avoid PerlIO encoding conversions, which can greatly speed up repeated calls and avoid double-encoding of pre-encoded or binary data. The module is intentionally small and focused compared with heavier IPC libraries, so it is a good fit when you need straightforward command execution or fast, low-overhead execution of Perl callbacks; note that the recent 1.01 release added a raw temporary-file mode so byte streams are stored and read back unchanged.

Test::YAFT is a lightweight Perl testing framework that combines BDD-style, human-readable syntax with the Arrange-Act-Assert pattern so tests read like specifications. It gives you functions such as it, assume, there, arrange, act, got and expect to set up context, run code and express rich assertions while leveraging Test::Deep for nested structure matching and Test::Differences for clear failure output. A hierarchical context system manages shared and local test state so setups can be inherited and safely overridden and overloaded operators let you combine or negate expectations for clearer, tabular-style checks. If you want expressive, self-documenting tests or are migrating from Test::More, Test::Spec or Test::Deep this module is a good fit and the recent 1.0.3 release added the new assume primitive and finer-grained export tags to simplify imports.

EV::Etcd is a high-performance asynchronous etcd v3 client that binds the native gRPC C API into Perl's EV/libev event loop so you can do nonblocking key/value operations, watches, leases, locks, transactions, authentication, cluster maintenance and leader election from a callback-driven interface. It offers configurable endpoints, timeouts, retry and health monitoring options and will automatically reconnect streaming operations like watches and lease keepalives to survive transient network failures. Keys and values are treated as raw bytes so you must encode and decode character data yourself. One important caveat is that the client is not fork safe because the background gRPC thread does not survive fork, so create a new client in child processes. EV::Etcd is a good fit for Perl services that need low-latency, event-loop integrated interaction with an etcd cluster.

SPVM is a statically typed programming language that uses a Perl-like syntax and is aimed at people who want the familiarity of Perl with stronger types and compiled performance. You can run small scripts or full programs, compile ahead of time or JIT, build standalone executables with spvmcc, and call SPVM methods directly from Perl so it can sit alongside existing Perl code. The system includes a rich standard library, threading and lightweight coroutine support, a builder system for native C and C++ bindings, and tools for distributing native modules, so it is useful when you need higher throughput or tighter C/C++ integration than plain Perl. Note it is not yet at a 1.0 stable guarantee so backward compatibility is not promised, and recent releases have focused on improving the build and packaging flow by refactoring Makefile.PL generation to produce more reliable, dependency-aware module builds.

Module::Generic is a feature-rich base class and toolbox for Perl module authors that speeds up building object APIs by providing ready-made typed accessors, dynamic method/autoload support, on-the-fly class generation, and consistent error and logging facilities. It bundles helpers for common data types like numbers, timestamps, UUIDs, IPs, files and URIs, transparent (de)serialisation hooks for Storable/Sereal/CBOR/JSON, terminal colour formatting, and utilities to convert objects to plain hashes for JSON output. The module is designed for real-world use with careful thread and END-phase handling, optional XS accelerations for hot helpers to improve performance, and a create_class helper to generate classes and methods declaratively. If you are writing Perl libraries or applications that need consistent accessor patterns, robust error propagation, dynamic data objects, or convenient file and serialization utilities, Module::Generic is likely relevant. Recent releases hardened END-phase behavior and thread-shared globals and in v1.5.4 reimplemented class-load detection in XS for stricter, faster checks and made timestamp parsing more robust for Japanese date libraries.

HTTP::Handy is a compact, single-file HTTP/1.0 server for Perl 5.5.3 and later that implements a practical subset of the PSGI interface so you can run simple web apps without installing any CPAN dependencies. It provides a run() entry point to start a server, an in-memory psgi.input object for reading POST bodies, convenient helpers like serve_static, url_decode, parse_query, mime_type and response builders for HTML, JSON, text and redirects, and built-in LTSV access logging with automatic 10 minute rotation and a simple directory layout for logs and htdocs. The module is designed for local tools, demos and rapid development where portability and zero dependencies matter, and it supports HTMX-friendly fragments alongside static file serving. Be aware it is intentionally minimal and not for production use because it only speaks HTTP/1.0, handles GET and POST only, runs single-threaded, buffers request and response bodies in memory, and does not support HTTPS or advanced PSGI features. The recent 1.06 update fixes a warning in HTTP::Handy::Input::read so common read idioms no longer emit uninitialized value warnings while preserving the same behavior.

DateTime::Lite is a drop-in, lighter-weight replacement for DateTime that gives you the same API with fewer dependencies, lower runtime overhead, and faster common operations. It keeps accurate IANA timezone handling by reading TZif binaries and evaluating POSIX footer rules, offers full Unicode CLDR and BCP47 locale support including timezone inference from locale tags, and uses an XS layer for fast calendar math and nanosecond-aware timestamps. Formatting supports both strftime and CLDR patterns, durations and arithmetic mirror DateTime semantics, and error handling favors returning undef with an exception object rather than dying. The module trades a compact SQLite-backed timezone store and optional process-level memory cache for the preloading model used by DateTime::TimeZone, so it is especially attractive for short-lived scripts and CLI tools or for projects that want a lower dependency footprint, while long-lived services should enable the provided timezone memory cache for best throughput.

Schema::Validator is a compact Perl utility for working with Schema.org structured data that gives you two practical tools: is_valid_datetime to check whether a string matches the ISO 8601 date and datetime formats accepted by Schema.org, including space or T separators and timezone offsets, returning a simple boolean without throwing, and load_dynamic_vocabulary to download and cache the official Schema.org JSON-LD vocabulary, parse it into convenient lookup tables for classes and properties, and return a hashref of class definitions while also populating package globals for direct queries. The vocabulary fetch is cached locally for a configurable period and will fall back to a stale cache on network failure while emitting carp warnings instead of dying. Configuration options cover cache file, cache duration, vocabulary URL and network timeout so you can adjust behavior at runtime. This module is a good fit if you need lightweight Schema.org date validation or programmatic access to the live Schema.org vocabulary; be aware that cache invalidation is time based only and there is no checksum or version check.

EV::MariaDB is an asynchronous MariaDB/MySQL client for Perl that plugs into the EV event loop and uses the MariaDB Connector/C nonblocking API to perform database work without blocking your program. It gives you async connect, queries, prepared statements, pipelined query dispatch for higher throughput, streaming row-by-row results for very large result sets, transaction control, utilities like ping/reset/change_user, and support for streaming BLOB/TEXT parameters. Callbacks use a simple (result, error) convention and query calls are queued and dispatched in FIFO order so you can safely issue many queries up front. The module also handles UTF-8/utf8mb4 if you configure the connection and provides synchronous accessors for connection state and info. Note that some operations are exclusive and require the connection to be idle, and multi-statement queries only deliver the first result set to the query callback while secondary results are consumed and reported via the error handler. This module is a good fit for event-driven Perl applications that need nonblocking, high-throughput access to MariaDB/MySQL.

sshca is a lightweight command-line SSH Certificate Authority that makes it easy to centrally sign and manage SSH public keys by issuing short-lived user and host certificates. The included sshca script supports creating a CA directory, issuing certificates from public key files or stdin, renewing certificates, listing certificates and expiries, revoking certificates and cleaning up expired entries, while configuration comes from a YAML file or environment variables with sensible defaults such as ed25519 keys and common validity periods. Certificate metadata is currently stored on the filesystem with plans to add configurable storage backends, which makes sshca a practical choice for teams who want to replace scattered authorized_keys management with centrally issued, trackable certificates. Recent 0.0.7 fixes improve basedir resolution, configuration precedence and debug output and stop processing when invalid options are provided.

Dev::Util is a lightweight collection of Perl development utilities organized into submodules. It supplies common needs such as a consistent feature setup and standard constants, operating system detection and external command helpers, file and directory utilities and temporary file helpers, interactive prompts and menus, timestamped backups for files and directories, and a simple semaphore lock facility. Use Dev::Util::Syntax to centralize your feature and pragma imports and pick individual submodules like Dev::Util::File, Dev::Util::OS, Dev::Util::Query, Dev::Util::Backup or Dev::Util::Sem as needed. It includes example programs and follows a standard install flow via perl Makefile.PL, make, make test, make install with bugs reported through CPAN's RT.

Archive::Tar is a pure-Perl, object oriented toolkit for creating, reading, modifying and extracting tar archives, with optional gzip, bzip2 and xz support when the corresponding compression modules are installed. You can build tar objects in memory, add files or raw data, rename, change permissions and ownership, list or extract entries, and write either plain or compressed tarballs, and it also offers an iterator and a class-level extract_archive for streaming or on-disk extraction when you do not want to load everything into memory. Because it is written in Perl it is very portable and easy to script, but it is slower and more memory hungry than system tar, so for very large archives you should use the iterator or extract_archive methods or rely on the platform tar. Archive::Tar also includes security-minded defaults and tunable globals to control chown, chmod, symlink resolution and whether extraction may escape the current directory, and recent releases added a MAX_FILE_SIZE cap (default 1GB), stricter validation of symlink and hardlink targets in secure mode, and changed hardlink extraction to be disabled by default with an EXTRACT_HARDLINK flag, while a later patch allows certain parent-path link cases in secure extraction. If you need a portable Perl API to inspect or manipulate tar files from scripts or programs and are comfortable with its memory and performance characteristics, Archive::Tar is a solid choice.

EV::Redis is a high-performance asynchronous Redis client for Perl that uses the hiredis C library and libev for low-latency event-driven I/O, and is a drop-in, backward-compatible replacement for EV::Hiredis. It is designed for performance-sensitive applications and adds practical features such as automatic reconnection, flow control (max pending / waiting queue), TLS support, RESP3 server push handling, configurable timeouts, TCP keepalive and socket options, and a fire-and-forget mode for very high write throughput. Integration with AnyEvent is seamless when EV is used as the backend. The module treats all data as raw bytes and does not do automatic UTF-8 encoding or decoding, so callers should encode/decode text themselves. If you need a fast, event-loop-friendly Redis client with advanced connection controls and modern Redis protocol support, EV::Redis is a strong choice. Recent updates include safety fixes such as eliminating a use-after-free when a callback clears its own handler and added tests around AUTH behavior.

App::CriticDB is a utility and Perl module for scanning large codebases with Perl::Critic, persisting the found violations and producing fast, perlcritic-style reports without re-running expensive full scans. It stores violation data in local files using Storable, records each file's mtime so only changed files are re-scanned, and removes entries for files that no longer exist. You can use it programmatically or via the perlcriticdb command line to collect and output reports to STDOUT, with support for perlcritic-style verbosity and a quiet collection mode. Current limitations include file-only storage backends and mtime-based change detection, and the datastore only records violations rather than files with no issues, but the project is actively improving reporting and storage. Recent releases made storage safer and more robust by switching to tempfile-plus-rename for Storable writes and adjusting tempfile permissions so tests work under root, and they improved violation formatting and verbose reporting.

Sys::Export helps you extract a tailored subset of an operating system tree for use in chroots, initrds, or small disk images by automatically including needed libraries and interpreters, rewriting paths and user/group IDs, and letting you inject or generate files as part of the export. It is a thin top-level wrapper that creates and exposes an OS-specific exporter (Sys::Export::Linux is the fully supported backend) so you can call simple functions like add, find, skip, rewrite_path, and finish without managing objects directly. The module understands common shorthand for filesystem entries, can produce CPIO output and now also supports creating VFAT, ISO9660, hybrid ISO and GPT images, and offers helpers such as map_or_load_file and lazy file data objects for efficient file handling. Recent additions include a which helper to locate executables in the source tree and Linux-only dependency detection for Perl scripts via strace, plus improved logging and many utility enhancements, making this useful if you need to build minimal boot or runtime environments from an existing filesystem.

Net::CIDR::Set is a Perl module for representing and manipulating collections of IP addresses and ranges, letting you work with CIDR blocks, arbitrary start-end ranges, or single addresses as a single logical set. It supports IPv4 and IPv6 (but not mixed in the same set) and provides the usual set operations such as union, intersection, exclusive-or, difference and complement, along with membership tests, merge/remove, in-place invert and deep copy. The module also gives convenient iterators and export methods to walk or dump addresses, compact CIDR representations, or ranges in different formatting styles, though methods that return every address can easily produce huge arrays for large or IPv6 sets. Net::CIDR::Set is a practical tool for firewall rules, ACLs, network inventories and any code that needs to compute overlaps or compact address representations and requires Perl 5.14 or later.

EV::Pg is an event-driven PostgreSQL client for Perl that plugs libpq's asynchronous protocol into the EV event loop so your database I/O never blocks the reactor. It provides non-blocking parameterized queries, prepared statements, pipeline mode for batching, COPY IN/OUT streaming, LISTEN/NOTIFY, single-row and chunked result streaming, async cancel where supported, and various helpers for escaping, password hashing and connection metadata. Results and errors are delivered to per-query callbacks in a consistent (result, error) form, making it easy to integrate into existing EV-based applications and to push high query throughput. The module requires libpq and EV, needs libpq 14 or newer and exposes additional features when libpq 17 or later is available, and a small number of operations are necessarily blocking at the libpq level so you should consult the docs when using those calls.

Attean is a Perl framework for working with Semantic Web data that makes it easy to parse, store, query, and serialize RDF and SPARQL content. It provides a consistent API to load triples and quads from many formats, push them into pluggable stores (including an in-memory store for temporary models), run SPARQL queries and iterate over results, and produce output in a variety of media types. The module discovers parser, serializer, and store implementations via a plugin convention, and includes helpers for HTTP content negotiation, and for registering custom SPARQL functions, functional forms, aggregates, and datatype roles. Use Attean when you need to build RDF data pipelines, convert between RDF formats, or embed SPARQL evaluation in Perl applications.

EV::cares is a high-performance asynchronous DNS resolver for Perl that embeds the c-ares C library directly into the EV event loop so socket I/O and timers run in XS with no Perl-level event overhead. It gives you a simple object API to run many concurrent lookups and bulk queries, resolve A/AAAA and reverse names, perform search/domain-appended queries, issue raw DNS queries, and parse a wide range of record types including MX, SRV, TXT, HTTPS/SVCB, TLSA and DNSSEC-related records while also returning per-record TTLs for cache-aware applications. You can control servers, timeouts, retries, ports, EDNS size, hosts-file lookups, address sorting and local binding, and enable a TTL-bounded result cache. Callbacks are driven safely on the EV loop and exceptions are caught so they do not unwind your program. The module requires c-ares >= 1.24 and gains richer parsing for HTTPS/SVCB and TLSA with c-ares >= 1.28. Be aware that parsed DNSSEC records are not cryptographically validated by this module and that DoT/DoH server URI forms may be unsupported on older c-ares releases.

Data::Throttler is a lightweight Perl module for enforcing rate limits by counting events in time buckets and answering with a simple yes or no when you try to record an event. You call try_push to see whether an action should proceed and you can throttle globally or per key so, for example, a single IP can be limited to 100 sends per hour. It can keep its counters in memory or use a persistent backend like YAML/DBM::Deep so limits survive across processes and restarts, and it includes locking and a reset_key method for coordinated multi-process use. The module splits the configured interval into buckets and sums recent buckets to decide allowance, you can tune the number of buckets, test with a custom time, and dump bucket contents for debugging although that pretty print requires Text::ASCIITable. Note that bucket spacing defaults to the interval divided by ten and sub-second resolution is not supported, making this a good fit for typical per-minute or per-hour throttles such as email or API rate limiting.

XML::PugiXML is a Perl binding for the pugixml C++ XML parser that gives you a DOM-style API for fast parsing, XPath queries, tree navigation, modification and serialization. You can load XML from files or UTF-8 strings, query with XPath or compiled XPath for repeated searches, edit nodes and attributes, clone subtrees and write the result back to a file or string with flexible formatting options. It is significantly faster than XML::LibXML for parsing, traversal and many common operations and is safe by default against XXE and entity expansion attacks. The module uses reference counting so node handles keep their parent document alive, but handles become stale if you reset or reload the document and different document instances may be used from different threads while concurrent access to the same document is not supported. Recent releases improve robustness by catching C++ exceptions at the XS boundary, reject cross-document node arguments and embedded NULs, and fix the default indentation handling.

Text::Stencil is a compact, high-performance template renderer for turning uniform lists or tables of data into text, HTML, JSON, or other flat formats using a precompiled row template with simple placeholders like {0} or {name}. It supports arrayref and hashref rows, rich transform chaining for escaping, formatting and logic (html, json, url, numeric formats, trimming, truncation, defaulting, pluralization, date and more), and can stream output to a filehandle or accept a callback for streaming generation, making it a good fit for fast table or list rendering tasks. Templates are parsed once for maximum speed, and the module exposes conveniences such as header/footer sections, custom delimiter characters, sorted rendering, and a clone method to reuse layout. Note that renderers are not safe for concurrent use from multiple threads and some case conversions are ASCII-only, so create separate objects per thread or serialize access. The recent 0.02 release fixes several safety and correctness issues including render-buffer use-after-free on croak, buffer freeing when a callback dies, an int_comma overflow for very large values, and a few transform validation and pluralization fixes.

JSON::YY is a high-performance Perl JSON module that uses the yyjson C library and offers three ways to work with JSON: ultra-fast functional keywords for one-shot encode/decode, an OO coder compatible with JSON::XS-style options for configurable use, and a Doc API that lets you inspect and surgically edit a mutable JSON document tree via JSON Pointer paths without materializing the whole structure. It provides zero-copy readonly decoding for very fast read access, path-based get/set/delete and iteration, file I/O, RFC 6902 patch and RFC 7386 merge-patch support, and convenient serialization and comparison helpers, making it particularly effective for large documents and operations that change only small parts of a JSON payload. The Doc API delivers big speedups over decode-modify-encode for medium and large payloads. Known limitations are that canonical (sorted-key) output is not implemented, NaN and Infinity cannot be encoded and will croak, and JSON true/false decode to Perl 1/0 rather than to overloaded boolean objects unless you use the Doc API jbool or special scalar refs. If you need very fast encoding or efficient, path-oriented manipulation of large JSON data in Perl, JSON::YY is worth considering.