CPANscan

Crypt::NaCl::Sodium is a Perl wrapper around libsodium that brings modern, easy to use cryptography to Perl applications. It exposes high level primitives for secret key and public key encryption, authenticated encryption with additional data, signatures, generic and short-input hashing, password hashing, stream ciphers and Diffie-Hellman, plus utilities for secure random bytes, constant time comparisons and hex conversion. The module emphasizes security and performance and includes guarded data storage via Data::BytesLocker so keys and secrets can be held and wiped safely. If you need a portable, well maintained way to build encryption, signing or password hashing into a Perl project this provides a comprehensive, production-ready API backed by the libsodium library.

URI is the standard Perl toolkit for creating, parsing and manipulating Uniform Resource Identifiers and URLs. It turns URI strings into objects you can inspect and modify with simple accessors for the scheme, authority, host, port, path, query and fragment, and provides higher level operations like canonicalization, equality testing, resolving relative URIs against a base and producing IRIs. The module also includes helpers for working with query forms and parameters and offers scheme-specific behavior for many common schemes such as http, https, file, mailto, ftp, ws/wss and others. Use it when you need reliable construction, normalization, comparison or component-level editing of web and network resource identifiers in scripts or applications. Recent updates improve IDNA handling by applying Unicode NFC normalization so host encoding matches other clients and avoid non-round-tripping A-labels, and they preserve leading and trailing whitespace in file:// paths.

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.

CPANSA::DB is a small, focused module that packages the CPAN Security Advisory reports as a ready-to-use Perl data structure so tools can consult a local copy of known CPAN security issues. It exposes a single subroutine, db, which returns a hash reference containing the advisory records, and it is primarily consumed by CPAN::Audit but can be used by any script that needs offline access to CPAN vulnerability data. Each release is published on GitHub and distributed with a GPG signature and GitHub attestation so you can verify the archive you download, and a JSON export of the same data is also provided for non-Perl consumers. The data is updated regularly with new reports and CVE mappings, making the module a convenient way to embed an authoritative, versioned snapshot of CPAN security advisories into audit or monitoring workflows.

Data::URIID is a utility for pulling structured identifiers and display metadata out of URLs, QR codes, barcodes and related objects so your app can present, link and normalise referenced items. You create an extractor, call lookup on a URI or QR text and get back a Data::URIID::Result that exposes canonical IDs, display names, thumbnails and other attributes; the module supports both offline and optional online lookups and is configurable with user agent, language preferences and per‑service online settings. It integrates with Data::Identifier and recognises many common schemes and host patterns (including geo and digest/ni URIs, tag:/acct: forms, image and barcode sources), accepts various input object types and will die on unrecoverable lookups. The project is actively maintained and recent changes added Convert::Color conversion and improved handling of unknown types, making it a good fit for applications that need to extract, normalise or enrich identity information from URIs.

Punk::Queue is a durable, multi-process job queue for Perl with a C-based core that stores jobs as rows in a database and ships backends for SQLite and PostgreSQL. It gives you a simple API to register task handlers, enqueue jobs with priorities, delays, dependencies, dedupe keys and per-queue or per-task defaults, and to atomically dequeue, perform and record job outcomes while retaining a full attempt log. The system is designed for at-least-once delivery so tasks must be idempotent and it provides configurable retries with randomized exponential backoff, layered timeouts with supervisor enforcement, repair to reclaim orphaned work, leases and counted locks, broadcast commands to control workers, and admin-facing listing, stats and history plus a CLI and UI. Heavy lifting lives in the XS layer for performance and connection pooling is per-process to play well with forking. Recent maintenance releases have focused on robustness and test fixes and simplified the admin UI while keeping the core behavior stable.

Punk::Mailer is a lightweight Perl module for composing and sending well-formed RFC 5322 email from simple hashrefs. You describe a message with fields like from, to/cc/bcc, subject, plain text and/or HTML body, headers and attachments and Punk::Mailer builds the exact bytes or streams them to a callback, producing multipart/alternative and multipart/mixed structures and the appropriate encodings. It validates and enforces the rules that matter so headers cannot contain CR or LF, addresses are checked, non-ASCII display names and subjects are encoded correctly, and attachments named by path are read in chunks to avoid blowing out memory. For delivery it wraps multiple transports including SMTP, sendmail, a resend mode, logging and custom transport classes and it performs option validation up front so misconfiguration fails early. Sending returns a result object rather than throwing on network errors which makes handling delivery outcomes straightforward. If you need to integrate mail into a Punk web app use Punk::Plugin::Mailer which wires this module into the framework.

Net::FullAuto is a Perl toolkit for automating and coordinating work across many machines by keeping persistent SSH and SFTP sessions open and treating each remote host as a programmatic handle you can run commands against and transfer files with. It is agentless so it works with any reachable SSH/SFTP server and can proxy‑chain through intermediate hosts, making it useful for complex multi‑network deployments, managed file transfers, automated builds and cloud demos like the included Amazon/Hadoop Instruction Set. The API exposes simple connect and host methods for running commands, changing directories, uploading and downloading files, locking and logging, and the project bundles a lightweight interactive menu system for guided workflows; it runs on Unix and on Windows via Cygwin. Note that the maintainer recommends key/identity file authentication rather than passing clear text passwords and that the installer historically updates many CPAN dependencies, so installing into a separate Perl environment or container is advised. Recent releases continue active maintenance and the latest version adds a Linux script command prepend to improve command capture on Linux hosts.

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.

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.