CPANscan

DBIx::Lite is a lightweight, chainable ORM for Perl that lets you build SQL with minimal setup and little boilerplate, so you can compose selects, joins and updates using fluent method calls without having to declare a full schema or even be connected to a database. It works with a supplied DBI handle or can manage connections via DBIx::Connector, provides automatic accessors and result/resultset subclassing, supports relationships, transactions and pagination, and can still produce raw SQL for inspection or offline use. Advanced behaviors such as defining primary keys, related-object helpers and SQL::Abstract::More options live in an optional schema object when you need them. Recent releases have added modern conveniences such as UPSERT support and, in version 0.39, support for using CTEs with INSERT, UPDATE and DELETE, making DBIx::Lite a pragmatic, minimal alternative to heavier ORMs like DBIx::Class.

This is a tiny placeholder module created so the distribution is discoverable on CPAN. It has no functional purpose at runtime and is not normally installed on users systems. Unless you are publishing or maintaining the distribution you can safely ignore it.

Number::Phone is a Perl base class and dispatcher for country-specific phone number handling that builds Number::Phone::XX objects by detecting a number's country code or by accepting an explicit country and phone string. It provides a common API for validating numbers and checking their type with methods like is_valid, is_mobile and is_tollfree, and for exposing metadata such as country_code, areacode, areaname, operator, timezones and approximate geographic location. The module can format numbers into E.123 or via custom formatters, compute how to dial from one number to another, and map numbers to canonical targets when numbering plans overlap. If a full country module is not available it will fall back to libphonenumber-derived stub classes unless you disable that behaviour with 'nostubs', and you can force libphonenumber data by using Number::Phone::Lib. Subclasses are expected to accept both international and local forms, implement validation and formatting, and return undef for invalid numbers. The module requires 64 bit integers and generally Perl 5.14 or newer, and the author notes that alphabetic characters and underscores in phone numbers will soon be treated as errors. The project imports data from Google's libphonenumber, is updated regularly, and is maintained on GitHub with an issues tracker and mailing list for support.

VPNDetection is a Perl client for the vpndetection.io API that lets you classify IP addresses as VPNs, residential or datacenter proxies, mobile proxies, Tor nodes, hosting providers, CDNs or privacy relays. It talks to the remote service and returns VPNDetection::Result objects, while raising VPNDetection::Error on failure, and it supports single lookups, batched lookups with deduplication, per-client caching with configurable size and TTL, retries, concurrency limits, timeouts and a custom Mojo::UserAgent for proxy or TLS needs. The module recognizes that which fields are returned depends on your API plan and warns that an absent field means “not in your plan” rather than false. There is a free tier with basic fields and a 1000 requests/day source limit, a database API for licensed dataset downloads, and nonblocking promise-based methods (lookup_p, lookup_batch_p and database_p) for use inside event loops.

SPVM::UV is a libuv binding for SPVM that brings a fast, cross-platform event loop and non-blocking I/O primitives into SPVM programs. It exposes the loop plus handle and request classes such as timers, pipes, async handles, streams and poll handles, together with callback helpers so you can schedule timers, perform async writes, watch file descriptors and integrate low-latency I/O into your application. A strerror helper returns human readable libuv error messages. This module is a good fit if you need event-driven networking or timer-based tasks in SPVM and is provided under the MIT license by Yuki Kimoto.

Alien::Xmake::Project is a Perl builder that lets you generate and control xmake build scripts from Perl instead of editing Lua by hand. It offers a fluent API to declare project identity, global options, targets, options, rules, toolchains, packages and xpack installers and then writes a xmake.lua file you can save and reuse. The module returns an Alien::Xmake handle so you can run configure, build, run, install, pack and query actions directly from Perl and inspect rich target metadata. It covers the full range of xmake features from compile and link flags to language standards, platform and architecture constraints, conditional when blocks, raw Lua hooks and package definitions while rendering correct Lua tables and booleans. Use it when you want programmatic, reproducible xmake projects or need to drive xmake from Perl-based tooling and automation.

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.