CPANscan

Perl::Critic::Grape is a small collection of extra Perl::Critic policies that help teams catch and enforce clearer, more consistent Perl style choices during static analysis. It adds rules to require parentheses when calling builtins, forbid inline do blocks, discourage manual reference-type checks, insist on explicit sigils to signal variable types rather than relying on arrow dereferencing for methods, promote using array and hash slices for lookup sequences, and replace the topic iterator with named loop variables. If you already use Perl::Critic and want stricter, readability-focused checks this module plugs in easily. The latest release adds the RequireSlices policy to encourage slice-based lookups.

Hash::SharedMem provides a fast, memory-mapped, on-host key/value store that multiple Perl processes and threads can share for mutable data. It exposes a handle-based API to open a shared hash stored in a directory, read and write octet-string keys and values, perform atomic single-key operations like compare-and-set and get-and-set, take read-only snapshots, and enumerate keys or the whole content. The module is designed for datasets that fit in RAM or a memory-backed filesystem so access is low-latency, and complex Perl objects can be stored by serializing them first. Performance will suffer if the data mostly lives on disk and the module does not guarantee durability across an OS crash. The documentation also explains file-permission and ownership semantics, non-atomic creation edge cases, and provides maintenance operations to tidy storage and reduce resource use. Use this when you need efficient interprocess shared state on one machine and can accept the in-memory performance model and the stated durability and creation caveats.

File::Raw::Archive is a streaming, plugin-driven Perl toolkit for reading and writing archive containers with a focus on real-world tar usage. It ships with a tar plugin that understands ustar, GNU @LongLink and PAX extended headers, auto-detects or writes gzip compression, and provides simple helpers to open and iterate entries, list metadata snapshots, extract single files or whole archives, and build tarballs with per-entry metadata. The API offers both object methods and importable convenience functions and can be extended with sister plugins for zip, cpio or ar formats. It supports safe extraction that rejects path traversal by default, optional round-robin parallel extraction via forked workers on POSIX systems, PAX global metadata and xattr round-trip where the platform supports it, and configurable tar emission modes (auto, pax, gnu, ustar). The recent 0.03 release fixes loading on older Perls and Windows build issues, makes extraction tolerant when the destination filesystem cannot hold extended attributes, and now requires File::Raw 0.15 for matching export fixes. If you need a practical, extensible archive reader/writer that handles the tar dialects you actually encounter and can scale from single-file extracts to parallel extraction, this module is worth a look.

Punk::OAuth2 provides client-side OAuth2 and OpenID Connect support for Punk web applications, letting you add "Log in with" flows for Google, GitHub, or any OIDC provider. It implements the authorization code flow with PKCE, signed state parameters, and id_token verification via Crypt::JWS so authentication is secure and tokens are validated. The real behavior and helpers are exposed through Punk::Plugin::OAuth2, while this distribution module serves as the version anchor and documentation entry point. Use it to plug OAuth2 login endpoints into a Punk app and configure providers with client id, secret, scopes, and callback settings.

File::Raw::JSON is a fast JSON and JSONL plugin for File::Raw that registers "json" and "jsonl" handlers so you can slurp, spew, or stream NDJSON with one syscall path into a high-performance yyjson codec. It also exports direct in-memory functions file_json_decode and file_json_encode when you just want to convert bytes to Perl structures and back without touching the filesystem. The "json" mode handles single-document files and "jsonl" streams records via a brace‑balancing parser so pretty‑printed or multi‑line records and multiple records on one line are all handled correctly while keeping memory bounded. You get familiar encoding and decoding options such as pretty, indent, sort_keys/canonical, relaxed parsing, ordered hashes to preserve key insertion order, and configurable boolean handling. The dist also exposes a simple C ABI for XS consumers that want to call the codec from C with no per-call Perl dispatch. Recent fixes improved large integer handling on 32‑bit Perl builds and the release added the public C ABI while continuing to ship the bundled MIT‑licensed yyjson library.

File::Raw is a performance-focused Perl toolkit for file I/O that uses direct system calls and techniques like preallocated buffers and memory mapping to read, write and iterate files much faster than standard PerlIO. It exposes convenient helpers such as slurp/spew, append, atomic_spew, mmap access, efficient line streaming and iterators, and a stat() call that returns many attributes in a single syscall with an internal cache to reduce filesystem hits. The module includes cross-platform optimizations for copy/move operations and lets you register plugins to decode or encode file content (for example gzip or CSV) and to add per-record transforms, with support for plugin chains when slurping and writing; note that chained plugins can be eager (they slurp the file) and true stream-phase plugins must be implemented in C. If you handle large files, need zero-copy reads or many metadata queries, or want an extensible, low-level file API for high-throughput tasks, File::Raw is a very relevant choice.

Tie::OrderedHash is a drop‑in, Tie::IxHash‑compatible implementation of insertion‑ordered hashes for Perl that also exposes a public C API so XS code can read and write the underlying structure without the overhead of tie dispatch. You can use it as a tied hash or create the implementation object directly and call familiar methods like Push, Pop, Shift, Unshift, Keys, Values, Length, Clear or construct it with an initial list, and it preserves key positions when values are updated and iterates in insertion order. Its internal layout matches Tie::IxHash so migrating code that inspected internals is straightforward. Pure Perl use yields a modest speedup over Tie::IxHash because tie dispatch still applies, but the real benefit comes from the provided C header and functions which let downstream XS modules manipulate the ordered hash efficiently and support concurrent C-level iteration.

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.