CPANscan

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.

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.

Gzip::Libdeflate is a lightweight Perl wrapper around the libdeflate library that gives you fast DEFLATE-based compression and decompression from Perl with a familiar gzip/zlib/deflate interface. It exposes simple methods to compress and decompress scalars and to read/write compressed files, supports compression levels 0 (store) through 12, and defaults to gzip-format output while letting you choose zlib or raw deflate headers when needed. The module bundles libdeflate so you do not need it installed system-wide, but building the XS component requires an ISO C99 compiler. Error conditions return undef and emit warnings and the file convenience methods use File::Slurper for binary I/O. The current release updates the bundled libdeflate to version 1.26.

Dir::Rename::WD offers a single simple routine, rename_wd, that renames the directory your process is currently in and puts the process back inside the renamed directory. It does this by changing to the parent directory, performing the rename, and then changing into the new name so your program can continue running in the moved directory. The call returns true on success and false on failure, with $! set to explain errors such as missing or extra arguments (EINVAL), attempts to rename root (EBUSY), or inability to chdir back due to permission problems. This module is useful when scripts or tools need to rename their working folder without losing their working directory context, and it is small and focused so you can wrap it in a CLI or larger workflow as needed.

Alien::SNMP builds and installs a pinned copy of the Net‑SNMP C library together with the matching Perl XS modules and command‑line client tools so you can use SNMP from a non‑system Perl or get a selfcontained Net‑SNMP stack for your application. It ensures the SNMP.pm/NetSNMP::* XS modules are compiled against the very same libnetsnmp it installs, provides helper methods to find the shipped binaries and compile/link flags (bin_dir, cflags, libs), and lets you prefer its tools on PATH without disturbing a system Net‑SNMP installation. It does not ship MIB files by default, and it reads snmp.conf and MIBs from its own share and from ~/.snmp rather than from /etc/snmp or system MIB directories, so you must supply any vendor MIBs you need. The build produces client utilities like snmpget, snmpwalk and snmptranslate but not the agent daemon, and macOS users should build with a Homebrew or perlbrew perl rather than Apple’s system perl. Recent updates moved the build to the Alien::Build toolchain and preload the bundled libnetsnmp so the XS modules reliably load the right library, and a recent fix addresses a parallel make race and improves where the Net‑SNMP tarball is fetched from, plus added SECURITY.md for vulnerability handling.

Uniform::HTMX is an abstract, framework-agnostic Perl base for handling htmx client-server interactions that you subclass for your web framework rather than use directly. It normalizes a variety of incoming htmx header spellings and provides simple inspection methods to detect htmx requests and read information such as current URL, target, trigger identity or event payloads, prompts, and history restore flags. It also offers fluent helpers to set outbound htmx response behavior by emitting the proper headers for retargeting, reswapping, reselecting, client-side navigation and history updates, redirects, refreshes, and firing custom client events with automatic JSON serialization. The module sanitizes outbound values to avoid invalid headers and response-splitting, uses JSON::MaybeXS with a JSON::PP fallback for structured data, and is intended to be extended with a small framework-specific subclass that extracts raw headers and injects the module's outbound headers into framework responses.

Punk::Mailer is a small Perl library that builds RFC 5322‑compliant outbound email messages and hands them to configurable transports for delivery. You give it a plain hashref with the usual fields such as from, to, subject, text, html and attachments and it produces 7‑bit clean MIME bytes with the right multipart structure and content encodings, streaming file attachments in chunks so large files do not consume memory. It enforces safety and correctness up front by rejecting header values containing CR, LF or NUL, validating addresses, encoding non‑ASCII display names and subjects per RFC 2047, and generating required headers itself. You can configure transports (smtp, sendmail, resend, capture, log or a custom class) when creating the mailer so transport options are checked early, use send to hand a validated message to the transport and inspect a Punk::Mailer::Result for delivery status, or call build/build_to to get the raw bytes or stream them elsewhere. This is the initial 0.01 release.

Dist::Zilla::PluginBundle::RSRCHBOY is an opinionated Dist::Zilla bundle that packages up the set of plugins and default settings Chris Weyl (RSRCHBOY) uses to build, test, document, and release Perl distributions. Drop [@RSRCHBOY] into your dist.ini and it will wire together common tasks such as gathering files, generating metadata, running tests, shaping POD, updating GitHub metadata, handling release steps, signing tags and release artifacts, and optionally tweeting and installing the built distro locally. The bundle is configurable so you can toggle features like signing, tweeting, GitHub updates, and the post-release install command or pass options directly to the individual plugins. It is useful if you want a ready-made, maintained workflow that follows one experienced author’s conventions or if you want to reuse a curated collection of best-practice Dist::Zilla plugins. Recent changes removed Travis references, refreshed badges, and cleaned up documentation, and the defaults now leave tweeting and tag signing off while GitHub integration remains enabled.

Database::Abstraction is a read-only, ORM-like layer that gives Perl programs a single, simple API for querying data stored as CSV, PSV, XML, SQLite, BerkeleyDB, DBM::Deep or any DBI-compatible database without writing SQL. You express filters as plain values, comparison hashes, pattern and set operators, logical groupings, or by adding join specs, and you can chain queries with the provided Query builder or use AUTOLOAD column shortcuts for quick lookups. Small files can be slurped into memory for very fast reads, DBI statements are prepared/cached for speed, and optional CHI-compatible caching and schema introspection are built in. It is ideal when you need to switch storage formats without changing application code or want lightweight read-only access to a variety of backend files or databases. Note that it is intentionally read-only, the default CSV separator is historically "!" so you may need to set sep_char => ',' for standard CSVs, slurp mode assumes a unique key column and simple XML structures only, and BerkeleyDB has some feature limits. The recent 0.37 release added remote file support so candidate files can be fetched over SSH/SCP into a temporary directory, added DBM::Deep (.dbm/.deep) detection and in-memory support, and tightened identifier validation and other security and stability fixes.

DBD::Pg is the mature Perl DBI driver that lets Perl programs connect to and work with PostgreSQL databases using the familiar DBI interface. It handles connection details and SSL options, supports server side prepared statements and several placeholder styles, marshals Postgres arrays and bytea values into Perl structures, and provides convenient features for transactions, savepoints, bulk COPY I O, large object handling, asynchronous queries and even asynchronous connect. It also exposes rich metadata methods such as table_info, column_info and primary_key_info, plus utilities for quoting, last_insert_id and LISTEN/NOTIFY, so it suits everything from simple scripts to data‑heavy or low‑latency applications. The module is actively maintained and widely used, and recent releases fixed async prepare and COPY TO STDOUT issues and improved SSL documentation, with a very small packaging fix for Mac compilation in the latest point release. If you write Perl that talks to PostgreSQL, DBD::Pg is the standard, full‑featured driver to use.