CPANscan

SPVM::Resource::Zlib is a resource wrapper that bundles the zlib compression library for use in SPVM projects, letting you call zlib C APIs from embedded SPVM C code without managing the upstream source yourself. It packages zlib v1.3.1 with the necessary headers and source files, targets the C99 standard, and provides build flags for large file support. To use it add use_resource('Resource::Zlib') to your SPVM Builder config and then include <zlib.h> in your SPVM C files to access functions like gzopen, gzread and gzwrite. The resource is maintained by Yuki Kimoto and is released under the MIT License.

Crypt::Age is a pure-Perl implementation of the age file-encryption format that lets Perl programs generate age keypairs and encrypt or decrypt data, files, or streams in a way that is interoperable with the age and rage command-line tools. It uses modern primitives via CryptX—X25519 for key agreement, ChaCha20-Poly1305 for authenticated encryption and HKDF-SHA256 for key derivation—and emits and accepts Bech32-encoded public and secret keys, making it suitable for simple, secure file encryption in Perl projects. The module covers keypair generation, encrypt/decrypt for multiple recipients, and filehandle-based streaming, and it reads and writes the standard age format. It does not implement ASCII armor, scrypt/passphrase recipients, or post-quantum recipient types. The recent 0.002 release adds the upstream age test kit for broader compatibility testing and tightens format and security behavior with stricter header and base64 parsing, improved final-chunk handling, a low-order point check for X25519, and safer MAC verification.

Mail::BIMI is a Perl module for mail systems and tools that need to discover, validate, and process BIMI (Brand Indicators for Message Identification) data for a message sender. It ties into existing authentication checks by consuming DMARC and SPF objects, looks up and parses BIMI DNS records, fetches and validates visual indicators and Verified Mark Certificates (VMCs), and produces a structured result plus Authentication-Results entries and optional BIMI-Location and BIMI-Indicator headers you can add to messages. The module includes caching, configurable network and security options, SVG and X.509 checks, and helpers to report warnings and errors for integration into mail pipelines. Recent updates ensure XML::LibXML is created with the correct network and security options and tighten record validation, so it is well suited for systems that need robust, standards-aware BIMI handling.

Uniform::HTMX::Dancer2 adds lightweight HTMX support to Dancer2 applications by exposing two helpers, htmx and is_htmx, so you can easily inspect incoming HTMX headers and set HX-... response headers from inside route handlers. The plugin builds a per-request Uniform::HTMX object from the incoming request, makes all core Uniform::HTMX methods available, and automatically writes any accumulated outbound headers back onto the Dancer2 response via an after hook so you do not need to call apply. Use is_htmx to detect HTMX-initiated requests and use htmx->res_trigger, htmx->res_retarget, htmx->target and similar methods to drive partial updates and client-side events in apps that use the htmx JavaScript library.

Dist::Zilla::Plugin::Test::CVE is a Dist::Zilla plugin that adds an author test based on Test::CVE to your distribution so you can automatically check declared dependencies for known CVEs before releasing. It writes a test file (defaults to xt/author/cve.t) and forwards configuration options to Test::CVE, letting you control whether to check author-only deps, runtime deps, core modules, and Perl itself. The module is marked experimental and documents important limitations, including that it only finds CVEs in declared prerequisites and may miss deep or undeclared dependencies, and that skipped issues can be forgotten if not tracked. If you publish Perl modules with Dist::Zilla and want a simple way to include automated CVE checks in your release tests, this plugin is relevant; recent updates clarified the minimum Perl version requirement and added tests and documentation improvements.

Log::Munger is a Perl library that turns raw log lines or decoded log records into structured fields using human-readable YAML rule files. You write or load rule files that define named regular expressions and gate checks, and the processor runs records against those rules in order, returning the named captures from the first match as a hashref and optionally enriching IP fields with GeoIP lookups when given a MaxMind MMDB. It works with JSON-style syslog output or plain log lines, validates rule files at load time so broken rules fail early, and provides a non-fatal matching API plus an explain mode to show which rule fired and why. This initial 0.0.1 release offers a lightweight, grok-like approach to log parsing without requiring Logstash and includes a CLI and companion modules for testing and conversion.

Fugu is a collection of Perl utilities that give you the common plumbing OpenBSD daemons use, packaged as small, focused modules so you can assemble the pieces you need. It provides daemonization, a simple event loop for single-process services, config parsing, control sockets and PID file handling, privilege dropping and sandbox abstractions, logging, signal handling, child process management, and a variety of helpers including JSON-over-socket, an imsg codec, an MQTT subscriber, and even a tiny caching HTTP proxy. The distribution is designed to run on core Perl 5.36 with optional CPAN features loaded only when needed, making it a practical choice if you want to build compact, Unix-friendly daemons in Perl that follow OpenBSD conventions.

Net::HTTP2::nghttp2 is a Perl XS wrapper around the mature nghttp2 C library that brings full HTTP/2 support to Perl applications, including RFC 9113 protocol handling and HPACK header compression. It provides client and server session objects with a callback-driven API for frame and header events, built-in flow control, server push, streaming request and response bodies, and support for bootstrapping WebSocket over HTTP/2 (RFC 8441). The module exposes nghttp2 constants and error codes, includes example client and server code, works with TLS/ALPN for h2, and offers a handy available method to detect a working nghttp2 installation or use Alien::nghttp2 to install the library. Recent releases added end-to-end trailer support and improved constant exports for wire error codes and header categories while preserving backward compatibility for existing streaming callbacks. The package has been exercised against the h2spec conformance suite with a high pass rate and deliberately follows nghttp2s lenient interoperability choices for a few edge cases rather than strict RFC enforcement.

CPAN::Testers::ParseReport is the parsing engine used by the ctgetreports tool to fetch and interpret CPAN Testers reports from cpantesters.org or local caches. It reads distribution summary files and individual report articles in JSON, ndjson or compressed formats, extracts useful metadata such as Perl version, OS, toolchain and test outcomes including failing test names, and returns that data in a structured hash for further analysis. The module also includes helpers to cope with imperfect MIME and HTML, a backdoor to parse a supplied article text, and a solve function that runs quick statistical regressions to highlight variables that correlate with failures. You will normally use it via the ctgetreports command, but the parse_distro, parse_report and parse_single_report functions let you integrate report parsing into custom workflows, and the recent 0.6.0 release updates the code to work with the updated cpantesters web app and modern transport formats.

Statocles is a command-line static site generator that builds websites from simple YAML frontmatter and Markdown content, letting you create sites and blog posts, build the output, preview it locally with a daemon, and deploy the result. It includes a full-featured blog engine with RSS and Atom feeds, tags, post-dating, crosspost links, and pagination, and it supports customizable themes written in the Mojolicious template language with a clean default theme based on Skeleton CSS. Statocles adds SEO-friendly features such as sitemaps, automatic broken-link checking, syntax highlighting, and hooks for plugins and custom applications, so it is a good fit for developers who prefer text editors and command-line workflows for producing rich static content. The recent 0.099 release fixed a security issue related to Git's "file" protocol and addressed YAML and link-checker edge cases, improving safety and robustness.

Quiq is a comprehensive Perl class library that speeds development by providing a large collection of reusable, consistently designed components. It bundles more than 260 application‑independent classes for everyday tasks like file and path handling, data structures and persistence, SQL and database helpers, HTTP/IMAP/SMTP clients, HTML/JavaScript and template generation, plotting and image manipulation, time and timeseries utilities, XML and wiki integration, command‑line and process utilities, and many other helpers. The modules are intended as building blocks across projects, are actively maintained, and can be installed from CPAN with cpanm. If you want a ready toolkit of tested Perl utilities to avoid reinventing common functionality, Quiq is worth a look.

Punk::Sqitch stitches Sqitch into Punk applications so you can run schema deploys, reverts, verifies and status checks against the database your app is already configured to use, instead of managing a separate Sqitch target. It converts DBI DSNs into Sqitch target URIs while keeping passwords out of the URI and supplying them via SQITCH_PASSWORD, discovers and runs the project's sqitch/ layout in the application root, and performs lightweight checks of plan versus registry to tell you what is pending or if there is drift without loading the full app. The module also offers helpers to scaffold deploy/revert/verify scripts from model metadata, to register custom engine and client mappings, and to find plan, conf and registry locations for apps and plugins. Note that actual deployments require the database client binary (psql, mysql or sqlite3) on the host that runs them, and there is a documented App::Sqitch test issue that may require installing App::Sqitch without running its tests.

Mojo::ATProto::OAuth is a Perl client for the ATProto/Bluesky style of OAuth that handles the whole login lifecycle, from sending PAR authorization requests to exchanging codes for DPoP-bound access tokens, refreshing tokens, and upgrading scopes without a full re-login. It is framework neutral so you can use it inside Mojolicious routes with non-blocking promises or in a standalone script, and it ships pluggable session stores (in-memory, SQLite, Postgres) so session and auth-request state can be persisted. The module also provides a ResourceClient helper to make authenticated XRPC calls against a user’s PDS and transparently manages DPoP proofs, nonce rotation, and token refresh retries. There are conveniences for local development such as a loopback new_localhost constructor, support for confidential clients via a private key and key id, and debug logging options; callers must supply client_id, callback_url and a compatible store when running a full auth flow.

Pod::DokuWiki converts Perl POD documentation into DokuWiki markup so you can publish POD as DokuWiki pages with minimal fuss. It builds on Pod::Simple and can read from files or strings and write to a filehandle or a string, performing a best-effort translation because DokuWiki cannot represent every POD construct, especially complex lists. The module recognizes extra directives such as =for highlighter language=perl to set syntax highlighting for subsequent code blocks and =begin dokuwiki/=end dokuwiki to embed raw DokuWiki markup verbatim. You can supply callbacks to resolve man-page and POD links to URLs, and by default core perldoc pages are mapped to perldoc.perl.org while other modules go to metacpan. This is the initial release.

DBIx::Loop is a minimal, practical layer that lets event-driven Perl programs run DBI database work without stalling their event loop by turning queries and writes into futures that settle asynchronously. You supply your own event loop adapter and DBIx::Loop picks one of two execution modes automatically: a universal worker pool that runs blocking drivers in forked workers, or a native nonblocking path for drivers that expose a socket and async execute (currently DBD::Pg). Queries return simple result structures and the familiar DBI select helpers are available as async versions so most code needs only small changes. It also supports transactions pinned to a single connection, process-global observers for monitoring each statement, and a C ABI so XS modules can call into the same async engine with no Perl frame. Note the module is about keeping your loop responsive and isolating latency rather than making individual queries faster, you must provide a loop implementation, and SQLite users should be aware of writer contention with multiple worker processes and may prefer a single worker or longer busy timeouts for heavy writes.

DBD::Cego is a Perl DBI driver that lets Perl applications connect to and work with the open source Cego relational database using the familiar DBI API. It provides a drop-in way to open connections, run SQL queries and fetch results from Cego while behaving like other DBI drivers, so existing DBI-based code can be adapted easily. Before using the module you must install the Cego C++ client library and its dependencies on the host. The driver was developed using the SQLite DBD implementation as a starting point and aims to offer a simple bridge between Perl and the Cego server; consult the module README and DBI documentation for installation and API details.

Uniform::Upload::PAGI is a small Perl driver that connects the Uniform::Upload API to asynchronous, non-blocking multipart file uploads running on the PAGI stream pipeline. You explicitly instantiate it with a PAGI connection scope so there is no implicit guessing about the incoming data and it normalizes raw stream payload into file objects you can inspect. Those file objects support chainable validation calls like maximum size and allowed MIME types and provide methods to save files, making it easy to handle uploads inside async event loops without blocking. The constructor requires a valid PAGI scope hash reference so it plugs directly into PAGI-based frameworks.

Uniform::Upload is an abstract, framework-agnostic base for handling multipart form file uploads in Perl that lets you keep upload validation and storage logic portable across web frameworks. Subclasses populate a simple files hash with the raw metadata their environment provides and this base class lazily wraps those entries into Uniform::Upload::File objects so validation, persistence and other higher level operations can be performed consistently. The API includes has_file to check for an upload for a given form field and file to retrieve the wrapped file object, and file will raise Uniform::Exceptions for missing or invalid field names. Do not instantiate Uniform::Upload directly; implement or install a small framework-specific driver such as Uniform::Upload::PSGI and then use the uniform interface for upload handling in your application.

PAGI::FastAPI is a FastAPI-inspired micro-framework for modern Perl (5.38+) that brings non-blocking async routing, Type::Tiny request validation, dependency injection and automatic OpenAPI 3.1 plus a hosted Swagger UI to Perl web apps. It lets you write async handlers with Future::AsyncAwait, mount sub-apps, add middleware, serve WebSocket endpoints, stream Server-Sent Events, and handle CORS, CSRF, rate limiting and cryptographic proof-of-work bot protection with built-in helpers and pluggable drivers. Authentication is left to middleware or per-route dependencies and a companion PAGI::FastAPI::Security distribution supplies common extraction schemes while letting you perform verification with your own logic. The framework compiles to a PAGI-compliant async app for servers and tests and recommends using Future::IO for loop-agnostic timers while documenting how to bridge Mojo-style loops when necessary. Notable in the 1.1.0 release is PAGI::FastAPI::Queue, an async-first message queue facade with a pluggable driver API and a built-in in-memory driver for simple topic-based push, pop and size operations.

Punk::OpenTelemetry provides OpenTelemetry instrumentation for the Punk web framework, giving you traces, metrics and correlated logs and exporting them to an OTLP collector over HTTP or gRPC. Add the plugin or set the OTEL_* environment variables and each incoming request becomes a server span named by the route pattern, outbound HTTP calls become client spans with trace context injected, and database queries are captured without leaking bound values. Telemetry is batched and sent asynchronously on the worker event loop so a downed collector does not block requests, and both protobuf and JSON OTLP encoders are supported for size or readability tradeoffs. The module also handles context propagation for W3C Trace Context, Baggage, B3 and Jaeger, offers configuration via punk.yml and environment variables, and includes an example app and collector for demonstration. You can disable the SDK completely by setting OTEL_SDK_DISABLED to true, making this a practical, production-oriented choice for adding standardized observability to Punk applications.

Reverse::Proxy is a lightweight PSGI reverse proxy that forwards incoming HTTP requests to upstream backends using the Fetch HTTP client, and it can be configured to send every request to one backend, route by path-prefix, or pick a target per request via a resolver. It runs on any PSGI server and can operate fully non-blocking on servers that implement psgix.loop and psgi.nonblocking such as Hyperman while falling back to blocking Fetch calls elsewhere, and it manages a per-worker keep-alive connection pool to reuse connections. The module handles standard proxy header semantics and multi-valued headers, supports optional streaming so response bodies are passed through chunk by chunk without buffering, and tunnels Upgrade requests like WebSocket when the server exposes psgix.io, though that tunnel is blocking and will be rejected with 501 on servers that do not provide psgix.io. You can tune behavior with options for host preservation, timeouts, TLS verification, pool size, Via header and streaming, and the proxy re-encodes PATH_INFO on the outbound request to avoid request smuggling.

Fetch is a high-performance HTTP client for Perl that gives you asynchronous futures for every request while also working synchronously out of the box by pumping its built-in event loop. Its performance-sensitive socket, TLS and HTTP/2 code runs in bundled C for low overhead and it supports HTTP/1.1 and HTTP/2, connection pooling, redirects, per-request timeouts, streaming bodies, JSON helpers, a cookie jar and native WebSockets. Each request returns a Fetch::Future you can await with ->get so the same code works for simple scripts and for thousands of concurrent requests on a single loop. Fetch integrates with popular Perl event loops or uses its own standalone loop and exposes a C ABI so other XS modules or proxies can drive it without Perl round trips. It also provides hooks to observe outbound requests and a clone method to cheaply get per-request isolation for things like cookie jars. Recent noteworthy additions include a request-observer API and an ABI version that lets callers upgrade plaintext tunnels to TLS (STARTTLS style) and a recent fix for an io_uring deadline cancellation crash.

Punk::Queue is a durable, multi-process job queue for Perl with a C-based core that moves SQL, JSON and the claim state machine into XS for speed and minimal per-call overhead. You register named task handlers in your process and enqueue jobs into a database-backed queue (SQLite and PostgreSQL backends ship, and custom backends are supported), then worker processes atomically claim, run and record job results while the system handles retries with jittered backoff, timeouts, logging, priorities, dependencies, uniqueness and retention. The module also provides schema migration, job inspection and logs, worker and lock management, broadcast commands and a repair routine to recover crashed workers and stale state. It guarantees at-least-once delivery, so task bodies must be written idempotently to tolerate repeated runs.

PDF::Make is a comprehensive Perl toolkit for generating, parsing and editing PDF files that offers three levels of API to match different needs. At the top is a template-driven Markup API that lets designers write simple document templates and Perl supply the data, a high-level Builder API provides a chainable, layout-aware interface that handles pages, word wrap and font metrics for common tasks, and a low-level XS API exposes the raw PDF primitives when you need full control over content streams and object graphs. The distribution also includes parsing and extraction tools, font and image handling, form and interactive action support, layers, attachments, accessibility helpers, watermarks and redaction, encryption and digital signatures, and output options such as linearisation for web viewing. Runtime dependencies are minimal with Object::Proto for the Builder and Template::Stencil required only if you use the template renderer. Recent maintenance fixes in v0.12 ensure Font::Metrics is properly declared as a prerequisite and address build issues on older Perl versions, making installs more reliable. If you need to produce invoices, reports, complex print-ready output or to inspect and modify existing PDFs from Perl, PDF::Make provides a flexible, well layered solution.

OrePAN2 is a lightweight DarkPAN manager that helps you build and maintain a private CPAN-style archive. You can inject distribution tarballs from a git repository or remote archive and then generate the standard CPAN index file so tools like cpanm can install directly from your local mirror. It provides simple command line utilities and an OO-ish library interface so you can automate or embed it in other tools. OrePAN2 relies on modern CPAN components for parsing and indexing, offers a cleaner API than its predecessor, and is actively maintained, making it a handy choice for teams or individuals who need to host or distribute private Perl modules.

Uniform::HTMX::PAGI is an asynchronous adapter that plugs the Uniform::HTMX layer into the event-driven PAGI HTTP stream pipeline, giving you a clear non-blocking way to detect and handle htmx-driven requests inside a PAGI scope. The constructor validates and prepares a PAGI scope and automatically normalizes inbound header arrays, while apply() commits your accumulated htmx directives into the scope (stashing compiled headers in $scope->{'htmx.outbound'}) and returns the object for method chaining. If you are building real-time or incremental HTML fragments with htmx in an async PAGI environment this module handles the plumbing so you can focus on the response logic. This initial standalone release also stabilizes the asynchronous array-of-arrays request and response header flattening subsystem.

Uniform::HTMX::PSGI is a compact adapter that brings the Uniform::HTMX interface to PSGI/Plack applications, allowing Perl web apps to detect htmx-driven requests and emit the proper htmx response headers or retarget DOM fragments without tying you to a specific web framework. It is framework-agnostic and middleware-friendly, so you can either apply header changes directly to a Plack::Response object or let the adapter stash compiled headers into the PSGI environment for later middleware to apply. You instantiate it with the PSGI env hash and call its apply method to flush response modifiers into the response or into env->{'htmx.outbound'}, which keeps integration straightforward and compatible with existing Plack stacks. The module was released as a production-ready PSGI/Plack connector on 2026-08-22.

Uniform::HTMX::Mojolicious is a compact adapter that makes it easy to handle htmx-driven interactions inside Mojolicious controllers, letting your server detect htmx requests, set response targets and client triggers, and publish the necessary htmx headers. You explicitly construct it with the current Mojolicious::Controller so there is no background auto-detection, it normalizes incoming request headers for you, and it exposes methods like is_htmx, res_retarget, res_trigger and apply so you can build header changes fluently and inject them into the outbound response. Use it when your app serves fragments or partial updates to an htmx-enabled frontend and you want a minimal, predictable way to emit the correct response headers inside Mojolicious routing.

Uniform is a specification and utility anchor for building framework-agnostic web components in Perl. It defines a common interface and shared helper libraries so you can write drivers that wrap different Perl web frameworks and keep your core application logic decoupled from deployment engines like Dancer2, Mojolicious, Catalyst or plain PSGI. The spec requires explicit framework subclasses, fluent mutator methods, an explicit apply() call to flush outbound side effects, and strict fail-fast validation, which together reduce framework lock-in and simplify testing and migrations. The root distribution provides documentation and utilities while companion Uniform::* driver modules implement the concrete behavior for each target framework.

Lingua::Text is a small, practical Perl object for keeping the same piece of text in multiple languages and automatically returning the right translation based on the process or HTTP locale. It overloads stringification so you can print or interpolate a Lingua::Text object directly, provides two-letter language accessor methods and a set() method for runtime updates, can be built easily from key/value pairs or a database hashref, and can convert stored Unicode to HTML entities for safe HTML output. The module memoises locale detection and installs fast accessors for good performance in web scenarios. Be aware that encode() is destructive and cannot be undone, storage keys are effectively two-letter language codes so locale fallback is limited, and typos in auto-generated accessors return undef without warnings. If you need a simple way to manage localized labels and messages in scripts or web apps, Lingua::Text is a convenient fit.