CPANscan

Perlanet is a Perl library for building "planet" style sites that aggregate RSS and Atom feeds into a single feed or rendered page. It fetches feeds, filters and selects entries, sorts and trims them by date, applies simple spam filtering and HTML cleaning, and then constructs an aggregate feed that you can render however you like, with hooks for customization by subclassing or roles. The module exposes a straightforward API including methods to fetch feeds, select and clean entries, cutoff by date, build the combined feed and run the whole process, and it can be used directly from code or via the provided perlanet command line and the batteries‑included Perlanet::Simple. If you need a flexible, Perl-native way to collect and publish multiple web feeds into a single stream or page, Perlanet is designed for that use.

SPVM::Resource::Coro packages the libcoro coroutine implementation for use in SPVM native extensions, making it easy to add coroutine context structures and the necessary headers, source and compiler defines to your SPVM C99 build. It bundles the coro.h and coro.c files (from Coro 6.57) and configures platform-specific compile-time flags so your native code can declare and use libcoro types such as coro_context for context switching and lightweight threads. The resource integrates with SPVM::Builder::Config so you can call use_resource and import the supplied defines into your build, and the distribution includes instructions to extract the upstream Coro files and apply a small patch before building. This is a first release distributed under the MIT License and is intended for developers who need coroutine support in SPVM native modules.

SPVM::Resource::SQLite bundles the SQLite C amalgamation and header files so you can build the SQLite engine directly into SPVM extensions without depending on a system SQLite installation. It is intended to be added to an SPVM::Builder::Config and then used from C code included in your SPVM module, for example by including sqlite3.h and calling the SQLite C API. The packaged code targets C99 and is built with flags that enable thread safety, column metadata, FTS5 full text search, R*Tree spatial indexes, JSON functions, math functions and the dbstat virtual table, so common SQLite features are available out of the box. The resource is based on the SQLite amalgamation (originally 3.45.1) and is distributed via GitHub under the MIT license, making it a convenient way to ship a self-contained, feature-rich SQLite engine with SPVM projects.

SPVM::Resource::RE2 packages the Google RE2 regular expression engine as a build-time resource for SPVM projects, making the RE2 C++17 headers and sources available to native SPVM extensions so you can call RE2 APIs from embedded C++ code. It automates pulling the upstream RE2 2023-02-01 sources into your project, provides the core headers and implementation files used by the library, and includes the necessary compiler flags, so adding fast, safe RE2 regex support to an SPVM extension is as simple as declaring the resource in your builder config. The resource mirrors the original RE2 distribution and is provided under the MIT license.

Dancer2::Plugin::Auth::Extensible is a plugin for Dancer2 web apps that provides a ready-made, extensible authentication and authorization framework. It gives you route guards like require_login and require_role, helper keywords such as logged_in_user and authenticate_user, built‑in password reset and user management features, support for multiple authentication realms, and a pluggable provider model so you can authenticate against config files, system users, databases, LDAP, IMAP, or your own provider. The module encourages secure password handling with RFC2307‑style hashed passwords and includes a small utility to generate them, and it supplies default login/logout routes while letting you override handlers or use a no-redirect “humane” login flow. It requires session support, exposes hooks for customization, and includes safeguards around email-generated links; a recent release added an uri_base setting to close a security hole that could let attackers craft malicious links in password reset and welcome emails and fixed related host handling and test issues. Use this plugin when you want a flexible, configurable authentication layer for a Dancer2 application without building everything from scratch.

SPVM::Resource::Libpng packages the libpng C library as a ready-to-use resource for SPVM so native SPVM classes can include png.h and call libpng APIs directly. It bundles the libpng v1.6.45 headers and source files and requires SPVM::Resource::Zlib for compression support, targeting the C99 standard. You enable it in your build by calling use_resource('Resource::Libpng') from SPVM::Builder::Config, which makes the needed headers and sources available when compiling SPVM native code. Recent updates raise the SPVM requirement to 0.990195, add AddressSanitizer and MSVC tests, and tweak the build config extension for improved portability and testing.

SPVM::Resource::Eigen makes the C++ Eigen linear algebra library (v3.4.0) available to SPVM projects by bundling Eigen header files and wiring them into the SPVM build environment for C++17 native code. By adding use_resource('Resource::Eigen') to your SPVM::Builder::Config you can include Eigen headers such as Eigen/Core and Eigen/Dense in your native .cpp files and use matrices, decompositions and solvers from Eigen directly inside SPVM extensions. This module is a convenience packaging of the real Eigen library for SPVM native development rather than a Perl reimplementation, so it is relevant if you plan to write performance‑sensitive numeric or linear algebra code in C++ within SPVM.

SPVM::Resource::SocketUtil provides a compact C resource for SPVM that exposes portable socket helper functions to native extensions, making it easy to read socket error numbers and obtain human readable socket error messages across platforms. You enable it in your SPVM build config and on Windows you also link the wsock32 and ws2_32 libraries, after which your C code can include the supplied header and call functions such as spvm_socket_errno and spvm_socket_strerror_nolen, with support for UNIX domain socket structures where applicable. The code targets the C99 standard for portability, is MIT licensed, and is useful whenever you need consistent, low level socket error handling in SPVM modules. Recent updates raised the SPVM requirement, improved portability and testing including ASan and MSVC, and adjusted build/config behavior.

SPVM::Resource::Utf8proc packages the utf8proc C library so SPVM native code can perform robust UTF‑8 processing without needing an external native dependency. It installs the utf8proc headers and source into your SPVM build tree, exposes the utf8proc API for inclusion from SPVM native C files, and sets the needed compile flags such as -DUTF8PROC_STATIC and the C99 standard. You use it by adding Resource::Utf8proc to your SPVM::Builder::Config and then including utf8proc.h in your SPVM native implementation to call functions like utf8proc_map. The bundled library is utf8proc v2.9.0, the package is MIT licensed, and recent updates bumped the SPVM version requirement, added ASan and MSVC tests, and adjusted build configuration handling to improve portability.

Text::ASCII::Convert is a Perl module that normalizes text by replacing non-ASCII characters with visually similar ASCII letters so you end up with a plain ASCII string. It accepts Unicode strings or UTF-8 octets and always returns bytes in the ASCII 0x00-0x7F range. The module is aimed at cases like spam detection where attackers use lookalike characters to hide words, so it maps by appearance rather than by linguistic meaning, for example turning certain accented or foreign letters into familiar Roman letters. Characters that have no ASCII lookalike are replaced by spaces and consecutive spaces are collapsed, zero width characters used for obfuscation are removed, and control characters such as tabs and newlines are preserved. If you need language-aware or semantic transliteration this is not the right tool, but if your goal is practical visual normalization for matching or filtering, this module provides a simple GPL-licensed solution.

PlackX::Framework is a lightweight framework that makes it easy to build PSGI/Plack web applications in Perl by tying together Plack::Request, Plack::Response and a small router into a minimal, easy to override structure. It automatically creates or loads per-application subclasses for handler, request, response, router and optional pieces like templating or URI helpers and exports a simple app() entry point and a compact routing DSL with route, base and filter keywords. Request and response objects include useful conveniences such as a per-request stash, a one-cycle flash cookie, rerouting and easier streaming, templating support via an optional Template component, and a hook to wrap your app in middleware. The project prioritizes low memory use, fast start-up and few dependencies while avoiding excessive magic, and it is designed to be easily extended by subclassing. The author notes the framework is still in an experimental alpha stage but used in production, and recent updates added a render_file helper, improved URI utilities and URL generation fixes along with a more consistent $response->last name for halting a request.

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.

WebDyne is the primary runtime for the WebDyne framework that renders ".psp" templates to HTML, either as a server-side request handler under Apache/mod_perl, PSGI or PAGI, or as a standalone tool from scripts via the exported html and html_sr functions. It supports embedding Perl in HTML, compile-time parsing and caching, chained handlers, filters, template composition and simple parameter passing, and can either return generated HTML as a string or scalar reference or stream output directly to a filehandle. Use handler() as the main entry point when running under a web server, or use html/html_sr for tooling, diagnostics and offline or static generation, and supply custom handler classes, parameters or a prebuilt request object as needed. Comprehensive usage notes and examples live in the module source and the project GitHub repository.

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.