CPANscan

Test::Simple is a tiny, easy-to-learn Perl testing module that gives you the basics for writing TAP-style tests. You declare a plan with use Test::Simple tests => N or finish with done_testing and use ok(EXPR, NAME) to report each pass or fail, producing the familiar "1..N" header and "ok"/"not ok" lines that test runners parse. The module enforces a plan and uses conventional exit codes so your test harness can tell whether everything passed, how many tests failed, or whether the test died or ran the wrong number of tests. It is intended as a gentle, no-friction way to get started with testing and is fully forward compatible with Test::More when you need richer assertions and diagnostics. The distribution is actively maintained and in recent releases has been updated to use the newer Test2 infrastructure and to improve subtest, IPC and formatter behavior so it remains robust for modern Perl testing.

Business::ISBN::Data is a data-only helper for Business::ISBN that bundles the official ISBN range information from the ISBN Agency so your code can validate and parse ISBNs correctly. You normally do not load it directly because Business::ISBN will load it for you, and it contains the RangeMessage.xml data packaged as a Perl data structure (available in %Business::ISBN::country_data with the original source recorded in the _source key). You can override the bundled XML by setting the ISBN_RANGE_MESSAGE environment variable or by placing a RangeMessage.xml in the working directory, which makes it easy to use the latest agency data without reinstalling the module. The module falls back to built-in data if no external XML is found and includes instructions for regenerating the default data, packaging with PAR, and keeping data up to date. Note that Business::ISBN 3.005 or later is required because of a prior fix around ISBN-13 handling, and the data in this module are updated frequently with the latest release recorded on 2026-09-03.

Catalyst::View::Wkhtmltopdf is a Catalyst view that converts HTML or Template-Toolkit output into PDF by calling the external wkhtmltopdf program. It integrates with your app via the stash (default key "wk") and exposes common PDF options such as the wkhtmltopdf command path, temporary directory, page size, orientation, filename and content disposition, and it can either stream the PDF to the client or return a filehandle for X-Sendfile style delivery. Template rendering is delegated to your TT view so you can render templates or pass raw HTML and let wkhtmltopdf produce the PDF. Be aware that wkhtmltopdf and its QtWebKit backend are no longer maintained and this module is deprecated, so migration to alternatives like Catalyst::View::ChromePDF is recommended. Also exercise caution with untrusted HTML and with temporary files because web-provided options must be validated and generated files may remain in tmpdir.

Net::OpenSSH::More extends Net::OpenSSH with a collection of practical helpers for remote administration and test automation, making common tasks like running commands, streaming prefixed output, writing files, backing up and restoring remote files, and caching SFTP sessions much easier. It adds a persistent Expect-driven shell mode for faster repeated commands, automatic temp-file cleanup, hooks to run commands on object destruction, retry and reconnection behavior, and a handy eval_full feature that serializes and runs a local Perl subroutine on the remote host. The module is aimed at sysadmins and test-suite authors who want higher-level convenience on top of OpenSSH while retaining control of authentication and execution options. Be aware that the persistent shell can be less stable, effectively requires bash, can hang on unterminated heredocs or long silent commands, and nonpersistent mode may merge stdout and stderr. Recent maintenance fixed DNS resolution logic in version 1.02 and the author documents other caveats and configurable behaviors so you can tune reconnection, timeouts, and debugging to match your environment.

File::SOPS is a pure-Perl implementation of the Mozilla SOPS encrypted file format that lets you encrypt values inside structured files while keeping keys readable for git-friendly diffs and partial inspection. It uses age for recipient-based key wrapping and AES-256-GCM for per-value encryption, and provides high-level operations to encrypt and decrypt data structures and files, edit secrets in your $EDITOR, rotate data keys, and extract single values by path. The module preserves value types across round trips, handles UTF-8 at the API boundary, supports multiple recipients and MAC verification to detect tampering, and intentionally refuses operations it cannot safely reproduce for other backends. In the recent 0.003 release it added multi-document YAML support, dotenv and INI format handlers, atomic file writes and several important security and interoperability fixes such as stricter MAC checks and safer handling of encryption rules, making it suitable for managing repository-backed secrets in Perl applications where compatibility with sops is required.

Net::Silverpeak::Orchestrator is a Perl client for the Silverpeak Orchestrator REST API that simplifies managing orchestration tasks from Perl scripts or automation tools. It supports login via username/password or API key and implements a broad set of high‑level operations for common resources such as template groups, appliances and groups, VRFs and firewall zones, BGP and IP SLA configurations, backups, address and service groups, and various application constructs, exposing create, read, update and delete actions as simple method calls that return data structures or true/throw exceptions on error. The module is aware of API differences introduced in Orchestrator 9.3 and is tested against 9.3.3, so it can handle both pre‑ and post‑9.3 endpoints. One known deployment caveat is that Orchestrator versions older than 9.0.4 may return HTTP 500 errors for API keys without an expiration date, so an expiration must be set for such keys.

Wasm lets you build Perl extensions with WebAssembly so Perl subs and Wasm functions can call each other almost transparently. It makes it easy to export and import functions, tie WebAssembly globals to Perl scalars, access linear memory and traps, and either inline WebAssembly Text or load .wat/.wasm files alongside your .pm files. The module integrates with Perl Exporter so exported Wasm functions can appear as normal Perl subs and it uses Wasm::Wasmtime under the hood, so the interface is still evolving and may change. Note that Wasmtime’s default memory strategy allocates large PROT_NONE pages which can conflict with strict virtual memory limits on some systems, but you can tune behavior via PERL_WASM_WASMTIME_MEMORY and the provided testing plugin helps detect problematic environments. If you want to mix Perl with code compiled from Rust C Go or other languages into a lightweight, callable WebAssembly component this module provides a practical bridge.

Net::NATS2::Client is a straightforward Perl client for the NATS messaging system that makes it easy to connect to a NATS server, publish messages, and create asynchronous or synchronous subscribers. It supports message headers and raw header access, request/reply patterns including a synchronous request helper, optional automatic reconnect with subscription restoration, and explicit hooks for NKey authentication. You can configure TLS and socket parameters, adjust read buffer size, and use Net::NATS2::JetStream for higher-level stream and consumer features. The client does not silently retry failed writes to avoid accidental duplicate delivery and is distributed under the MIT license.

Sys::Virt is a mature Perl binding to the libvirt virtualization API that lets Perl programs manage hypervisors, virtual machines, networks, storage pools, interfaces and host devices through a single, consistent API. You open a connection to a libvirt daemon by URI and then create, define, list or inspect domains, networks and storage, query host capabilities and resource statistics, stream data, and register event callbacks and authentication handlers. Errors are reported as Sys::Virt::Error exceptions and the module exposes many libvirt constants so you can use advanced features such as migration and CPU/check compatibility checks. Be careful to deregister any callbacks and close connections or the connection object may not be garbage collected. The project is actively updated to track libvirt features and in the latest 12.7.0 release it added I/O thread poll weight and richer guest device info constants for finer control and monitoring. Note that the XS layer interacts directly with the libvirt C library and the author flags that the XS code should be audited for potential memory leaks.

Protocol::HTTP2 is a Perl implementation of the HTTP/2 protocol that supplies stateful frame encoders and decoders along with an HPACK header compression component, letting you build custom HTTP/2 clients, servers, or intermediaries on top of plain or TLS sockets and your favorite event loop. It provides separate Client, Server and Connection modules so you can manage streams, construct requests and responses, and handle protocol negotiation and frame-level details while also offering a tracing helper for debugging. The library covers core features such as ALPN/NPN negotiation, the connection preface, header compression and many frame types including server push, but it is marked beta and several areas are incomplete or experimental, notably flow control, stream priority and some DATA/CONTINUATION handling, so it is best suited for learning, prototyping or nonproduction use unless you verify the parts you need.

Catalyst::View::ChromePDF is a Catalyst view that generates PDF files by rendering HTML or Template-Toolkit templates and driving a Chrome-compatible browser via WWW::Mechanize::Chrome. You configure it in your Catalyst app, put rendering parameters or raw HTML into the stash (default key "pdf"), and forward to the view to produce a PDF with options for page size, orientation, download disposition and filename. It is designed as a successor to Catalyst::View::Wkhtmltopdf and lets you supply Chrome launch arguments or a prebuilt mech instance, but some wkhtmltopdf features such as margins, DPI and image quality are not supported. Note that temporary HTML and PDF files are written to tmpdir and may need external cleanup, the default mech does not block file: URLs, improper shutdown can cause mech errors, and you must validate any parameters that come from users; the module requires Perl 5.24 or later.

HTML::FormHandler is a Moose-based Perl framework for building, validating and rendering web forms that keeps form structure separate from presentation. You can define forms as Perl classes with has_field or assemble them dynamically with a field_list, use compound and repeatable fields, attach validators and inter-field dependencies, and bind forms to DBIx::Class rows so validated input can create or update database records automatically. The module ships rendering roles and widgets for HTML output but also supports custom renderers and template-driven presentation and integrates simply with Catalyst and other web toolkits. It provides conveniences like init_object and defaults handling, a run/result API that carries values and errors, conversion from CGI-style to structured params, and flags to control posting and updates. The project notes Data::MuForm as its successor for new projects, and recent maintenance releases fixed security issues by HTML-escaping error messages and changing localization argument handling for CVE fixes, corrected an exception with garbage-collected field results, and adjusted optional prerequisites.

Net::Clacks is a lightweight, high-performance client/server messaging system for Perl that also doubles as an in-memory cache compatible with memcached, making it useful for real-time notifications and fast key/value storage alike. It supports scalable master/slave and tree topologies so you can distribute load across multiple servers, offers a DEBUG monitor mode to forward messages to a watcher, and includes focused components: Net::Clacks::Server, Net::Clacks::Client, a Cache::Memcached-style ClacksCache, and a write-only PostgreSQL2Clacks helper for emitting messages from database triggers. The module is actively maintained, requires Perl 5.36 or newer, and ships with examples to get you started. Recent releases have focused on reliability and performance, with a recent version bump addressing noping behavior and timing issues in the server and client.

App::Greple::xlate is a translation helper for the greple tool that finds matched text blocks in files and replaces them with translations from engines such as GPT-5 (via the llm command) or DeepL. It is designed for selective, repeatable translation workflows rather than one-shot document dumps: translations are cached per file so unchanged text is not re-sent, edits trigger only the changed paragraphs to be retranslated, and context-aware engines can receive surrounding text to preserve wording. The module supports masking and anonymization to protect markup and sensitive strings, understands template expression placeholders and YAML front matter, and can emit several convenient output formats for review or automated updates. You can run it from the command line or Emacs and it integrates with Docker if you do not have local CLIs for the backend engines, so it is a good fit when you need controlled, privacy-aware, and incremental translation of code or documentation.

Cavil::Matcher is a high-performance engine for finding license text and other keyword patterns in source code, designed to power the Cavil scanning tool. It tokenizes input and matches against compiled patterns stored as immutable, memory-mapped segments so you can add or remove patterns without rebuilding the entire cache and multiple worker processes can share one physical copy of the index. The module exposes a simple API to build an engine, parse human-readable pattern text (including limited $SKIP wildcards), add patterns, scan files for matches, and manage compiled segment files with load, attach and verify operations. It also provides streaming content hashing and a TF-IDF "bag of patterns" closest-match model for provenance-style queries, plus utilities to normalize text and compute an approximate token edit distance for legacy compatibility. Note that tokenization functions treat embedded NUL as a string terminator but the file-scanning path is NUL-tolerant for real source files. In the most recent 1.05 release the on-disk fingerprint index was removed so consumers must now keep the searchable fingerprint index in their own database, while the fingerprinting primitives remain unchanged.

App::PDFLibrarian is a command-line toolkit for researchers and LaTeX users who want to keep PDF copies of academic papers and their BibTeX metadata synchronized. It lets you import PDFs with embedded BibTeX, edit those embedded entries, export a combined .bib file, generate citation keys, replace or remove PDF files, rebuild internal links, and produce ISO4 journal abbreviations, so you can manage a searchable, versionable library of papers alongside your bibliography. The tools rely on common Linux utilities such as poppler and Ghostscript and are installed from CPAN. The module is practical if you need lightweight, file-centric BibTeX management and is distributed under the GPLv3.

PAGI::FastAPI is an asynchronous, FastAPI-inspired micro-framework for modern Perl that gives you non-blocking request handling on the PAGI spec, Type::Tiny driven validation for query, body and path parameters, a simple dependency injection style, and automatic OpenAPI 3.1 and Swagger UI documentation so you can build typed, documented HTTP APIs quickly. It includes route helpers for the usual verbs, WebSocket and Server-Sent Events streaming, middleware and CORS integration, pluggable authentication via dependencies or the companion PAGI::FastAPI::Security distribution, rate limiting, bot protection, CSRF helpers, response helpers for redirects and files, and a lightweight async queue facade. The recent 1.7.0 release adds proper RFC 7578 multipart/form-data parsing with form_data() and uploaded_files() context helpers, a $c->background API for fire-and-forget async tasks that continue after a response is sent, richer per-route OpenAPI metadata and Swagger UI customization options, plus a file response helper. Note that uploaded files and file_response currently read file contents into memory so you should plan request size limits accordingly. If you want a modern, type-safe, async-first framework for building Perl microservices with built-in docs and streaming support, this module is worth exploring.

Connector is a lightweight base class and adapter framework for accessing hierarchical configuration or similar structured data through a uniform get(KEY) style interface, letting different backends look and behave the same to your code. It is often used as a proxy to simple sources like YAML or Config::Std or to more complex systems such as LDAP or external processes, and it supports meta-connectors that combine multiple backends for redirection, cascading, or round-robin use. The interface includes methods to fetch scalars, lists or hashes, to set values, to inspect node metadata and to clean up resources, and it offers a die_on_undef option to control whether missing nodes trigger errors. Connector is intended as a base class for implementers rather than something you normally instantiate directly, and custom connectors must implement get_meta and at least one data getter to be efficient. Recent packaging updates include switching from Syntax::Keyword::Try to Feature::Compat::Try, raising the minimum Perl requirement to 5.014 and cleaning up dependency declarations, making it easier to use on modern Perl installations.

Alien::wasmtime is a helper module that finds or downloads the wasmtime WebAssembly runtime so other Perl modules can use it via FFI. It exposes a dynamic_libs method that returns the shared libraries you hand to FFI::Platypus and lets you override the downloaded version with the ALIEN_WASMTIME_VERSION environment variable. This distribution is aimed at module authors building FFI bindings rather than users who want a high level WebAssembly API, so if you want to call Wasm from Perl directly you should look at Wasm or Wasm::Wasmtime. Be aware that wasmtime and the wider Wasm ecosystem are still changing, so you may see occasional breakage, and this Alien currently prefers downloading a binary rather than probing system package managers.

SPVM::Resource::UV packages the libuv v1.52.1 C library as a build-time resource for SPVM projects, supplying the headers, sources, platform-specific compiler flags and link libraries needed to use libuv from SPVM native code. It makes it simple to register libuv with the SPVM builder so your module can add the required defines and libs, include uv.h and call into libuv to access its event loop, timers, async I/O, TCP/UDP and other cross-platform primitives. The resource targets C99 and includes Unix, Linux, macOS and Windows sources and flags, is distributed under the MIT license, and is maintained on GitHub by Yuki Kimoto.

Mojolicious is a modern, full-featured real-time web framework for Perl built on the Mojo toolkit. It provides RESTful routing, controller actions, Perl-style templates, content negotiation and signed cookie sessions, along with form validation, a static file server, an integrated command-line and a built-in HTTP server so you can prototype and deploy quickly. The framework exposes hooks and helpers for application-wide customization, a plugin system, bundled testing tools and a full HTTP user agent for calling other services. It ships with good documentation and sensible defaults while reminding you to replace insecure default secrets, making it a practical choice for building APIs, web services and interactive apps in Perl.

Geo::Elevation::HGT is a lightweight Perl utility for turning latitude and longitude into elevation values by reading HGT digital elevation tiles, by default pulled from the Mapzen/Amazon S3 terrain-tiles repository, or from a local folder or user-provided tile set. You call get_elevation_hgt with decimal-degree coordinates and it returns elevation in meters using bilinear interpolation by default and optional bicubic interpolation for slightly smoother peak estimates. The module streams gzipped or zipped HGT files, caches downloaded tiles if you provide a cache folder, and keeps tiles in memory so repeated lookups across a GPX track are very fast. Results reflect the underlying SRTM and similar DEM sources, which tend to smooth sharp peaks and may report values below commonly quoted summit elevations. The module has only core Perl dependencies, requires you to respect the data provider terms, and is handy for generating elevation profiles or enriching location data without heavy GIS toolchains.

JSON::Schema::Validate is a compact, dependency-light Perl validator for JSON Schema draft 2020-12 that emphasizes correctness and recursion safety while implementing the features most people need in production. It handles $ref, $dynamicRef and anchors, supports unevaluatedItems and unevaluatedProperties with proper annotation tracking, covers the usual keywords and combinators, includes builtin format validators for date/time, email, hostname, IP, URI, UUID and JSON Pointer and lets you register custom format or media handlers, and offers optional pruning of unknown object properties. The module provides a simple API to construct a validator from a decoded schema and call validate or is_valid, exposes structured error objects and tracing, and includes an optional compile mode that precompiles small closures for better steady-state performance. It can also generate a standalone JavaScript validator for client-side preflight checks while keeping the Perl engine as the source of truth. Recent releases fixed an internal compile node bug in v0.9.1 and tightened the IRI format validation in v0.9.0.

Perl::Critic::Policy::ProhibitUnusedImports is a Perl::Critic rule that helps you find and remove import lines that bring symbols into a file but are never actually used, reducing unnecessary dependencies and startup cost. It checks what each use statement imports and reports when none of those names appear later in the source, treating a plain use of a module as relying on that module's default exports and a use Module() form as importing nothing so the module name itself must be referenced. Common pragmas and modules that exist solely for side effects are exempt by default and you can add your own exceptions with the allow setting. Be aware that the policy may miss cases where names are introduced only at runtime by symbolic calls or eval, and that it may need to load a module to inspect its exports which runs top level code, so enabling this check requires Perl::Critic’s unsafe checks to be allowed. The rule is aimed at maintenance and performance improvements and is rated with low default severity.

Perl::Critic::Policy::ProhibitNoWarningsRedefine is a linting rule for Perl that stops you from turning off the "redefine" warning, a common but risky shortcut used when tests replace existing subs by hand because it can hide typos that install new, unused symbols and let tests pass incorrectly. The policy flags explicit no warnings 'redefine' and even a bare no warnings since that also suppresses the category, and it recommends using Test::MockModule instead because that checks the sub exists, scopes the mock, and restores the original at scope exit without disabling warnings. You can configure which warning categories are forbidden, the default is "redefine", and the policy is intended for test and maintenance code with high severity to help avoid subtle, hard‑to‑find bugs.

Perl::Critic::Policy::RequireFatalWarnings is a linting policy that insists Perl files turn Perl-raised warnings into fatal errors by using use warnings FATAL => 'all' instead of plain use warnings or no warnings at all, so problems like uninitialized values fail fast instead of getting buried in logs. It helps catch subtle bugs early in development and in long running programs by forcing execution to stop where Perl itself raises a warning. The policy can be told about equivalent modules that already enable fatal warnings for you so it does not produce false positives. Be aware that making warnings fatal in a module used by others can cause callers to die unexpectedly, which is why this rule is opt in for many distributions.

Lucy is a Perl interface to a high-performance, modular full‑text search engine that makes it easy to index and search large document collections with features such as incremental and near‑real‑time updates, Unicode-aware analysis, boolean and phrase queries, stemming, stoplists, customizable analyzers, result highlighting, and flexible sorting. It offers both a full-featured API for building complex indexing and query pipelines and a simpler Lucy::Simple wrapper plus tutorials for quick starts. Distributed search support exists via companion LucyX::Remote modules which are no longer shipped on CPAN but remain available from the project repository. The recent 0.8.0 release fixes several security issues and robustness bugs. Be aware that the main Lucy namespace is an API-unstable development branch, the library is not thread-safe, and some exceptions can leak memory. Lucy is distributed under the Apache 2.0 license.

Catalyst::Seal is a drop-in performance addon for Catalyst web apps that freezes the application at setup and compiles its runtime metadata into constant, fast paths so requests do far less work. You enable it by putting use Catalyst::Seal above use Catalyst in your app and nothing else changes in your code. At a high level it makes the application immutable, replaces repeated metaobject lookups and wrapper trampolines with constant or XS accessors, memoizes frequent action and encoding decisions, avoids rebuilding common structures like headers and canonical URIs, and skips or defers work that cannot change after setup. The net effect is a large reduction in per-request overhead and a several-fold increase in throughput in benchmarks, for example improving a simple app from about 6.6k to about 20.4k requests per second in the author’s tests. There is a hard kill switch via the CATALYST_SEAL environment variable and a debug flag to report what was sealed. This is the initial 0.01 release.

MIDI::Util is a compact collection of helper routines for creating, inspecting and playing MIDI from Perl, designed to sit alongside MIDI::Simple and make common tasks easier. It gives you setup_score to build a ready-to-use score with sensible defaults like tempo, channel, patch and optional lead-in, utilities to normalize note names and compute duration sizes and ticks, functions to inspect internal MIDI tables and produce reverse lookups, and simple ways to set time signatures and channel patches. It also computes timing in microseconds, converts a MIDI::Simple score into raw event arrays, and can generate timidity configuration snippets or drive timidity and fluidsynth for immediate playback. Nothing is exported by default so you import just the helpers you need. This module is useful if you generate MIDI programmatically, need quick utilities for debugging or transforming MIDI data, or want a straightforward path to play scores through software synths.

Perl::Critic::Policy::RequireQwForLiteralLists is a Perl::Critic rule that spots runs of plain quoted words used as a list and recommends replacing them with a qw() literal to make command-style argument lists shorter and easier to read. It emits a single low-severity violation per run and lets you configure how long a sequence must be before it triggers (min_run_length, default 3), so very short lists are left alone. The policy ignores cases where qw() would change meaning, for example interpolated strings, items containing whitespace or escapes, and hash initializers, and it will not detect a run that is split by an existing qw() fragment. This is a cosmetic maintenance rule intended to reduce punctuation noise and clarify intent in Perl list usage.