CPANscan

Perl::Dist::APPerl delivers APPerl, a single-file portable Perl runtime that runs the same binary across multiple x86_64 operating systems and can carry Perl modules and scripts inside the executable as a ZIP filesystem. Using the apperlm command you can create and manage build configurations, build from an existing APPerl or compile Perl and the Cosmopolitan libc from scratch for static builds that support XS extensions, and include CPAN distributions by pointing apperlm at tarballs or folders. At runtime APPerl can dispatch embedded scripts by path, by an environment variable, or by argv[0] so you can ship standalone Perl applications, bundle a consistent interpreter for teams, or carry Perl on a USB drive without installing anything. It also supports debugging features like syscall tracing and function tracing and notes that building from source requires Linux. Recent releases added official builds for Perl 5.42 and 5.44 along with a variety of build and test fixes to improve compatibility.

CPANSA::DB is a data-only Perl module that packages the CPAN Security Advisory database as a ready-to-use Perl data structure. Calling its single db() subroutine returns a hash reference containing all advisory reports so tools like CPAN::Audit or your own scripts can programmatically check modules and versions for known security issues. The distribution also provides the same data in JSON and is published on GitHub with GPG signatures and GitHub Attestations so you can verify authenticity. The dataset is updated regularly and recent releases have focused on trimming the data into a more compact format and keeping the advisory records current.

Catalyst::Plugin::JSONRPC::Server is a small plugin that adds JSON-RPC 2.0 request handling to Catalyst apps by giving your context two helpers, jsonrpc_register and jsonrpc_dispatch, so you can register method handlers inside a request and have the plugin parse, route and respond to JSON-RPC calls over HTTP. It builds a fresh dispatcher per request so handlers and any closures do not leak between requests, and you can tune behavior with configuration like max_body_bytes (default 10 MiB) or supply your own dispatcher to change limits such as max_batch (default 1000). Handlers receive the JSON-RPC params and return results or throw a Catalyst::Plugin::JSONRPC::Server::Error to signal JSON-RPC errors while a plain die becomes a guarded internal error. Dispatch writes the appropriate HTTP response, returning the response payload or undef for notifications, and there is a jsonrpc_dispatch_with method if you need to reuse or preconfigure a dispatcher. The distribution includes a runnable example app and client so you can see echo and sum handlers in action.

Stats::LikeR brings a compact, R-like toolkit of data frame operations and statistical routines to Perl with an emphasis on speed and familiar idioms, offering frame-aware functions that work on array-of-arrays, array-of-hashes, hash-of-arrays, and hash-of-hashes and a large suite of stats tools such as lm, glm, aov, anova, t_test, wilcox_test, chisq_test, fisher_test, kruskal_test, and many correlation and descriptive routines, plus data wrangling helpers like agg, group_by, merge, concat/rbind, melt, pivot_table, assign, dropna, fillna, ffill/bfill, drop_duplicates, select/drop_cols, csort, and utilities like vals, colnames, rownames, qcut, quantile, rank, and uniq. The API is styled to feel like List::Util and R idioms so you can group, aggregate, reshape, and join tables with concise calls while benefiting from XS-accelerated numeric cores for heavy work. The module also includes robust I/O with read_table and write_table that handle CSV/TSV and XLSX, the latter much faster and leaner in recent releases, and it aims to be portable back to older Perl 5.10. In the recent 0.24 release the interpolate routines were moved into XS giving large speedups for linear, pchip and spline methods and now match pandas/scipy behavior to high precision, read_table gained much faster XLSX parsing and lower memory use, and several convenience frame operations such as bfill, ffill, melt, pivot_table and drop_duplicates were added, so if you need R-style data frame workflows or statistical tests inside Perl with production performance, Stats::LikeR is likely relevant.

Gherkin is the Perl implementation of the Gherkin language parser and compiler used by the Cucumber project. It reads feature files (including Markdown-formatted Gherkin), parses them into an AST and compiles executable scenarios known as pickles, and emits protobuf-based Cucumber::Messages wrapped as NDJSON envelopes so downstream tools can consume a standard message stream. The API is stream-oriented: call Gherkin->from_paths or from_source and supply a unique-ID generator coderef and a sink coderef to receive Envelope messages, and control whether the Source, GherkinDocument (AST) and/or Pickle messages are included via options. The module respects encoding headers in feature files and provides a to_json helper on envelopes for UTF-8 NDJSON output. Note that older releases used plain hashes but modern versions send Cucumber::Messages objects, and recent updates added Markdown Gherkin support and the ability for a step to carry both a DocString and a data table, keeping the parser aligned with the evolving Gherkin grammar. If you are building Cucumber tooling or any pipeline that needs a canonical Gherkin parser in Perl, this module is directly relevant.

Pod::Simpler::Aoh is a small Perl module that takes POD documentation and converts it into a simple, program-friendly array of hashes so you can inspect, search, and manipulate sections of documentation from code. You create a parser, feed it a file or a string, and it returns an arrayref or array of hashes where each entry represents a POD section with keys like identifier, title, and content. There is an option to split content into element-level hashes for finer-grained processing, and convenience methods let you retrieve a single section by index or search the parsed POD by a key and value. The module builds on Pod::Simple and aims to make POD easier to work with in scripts and tools that need structured access to documentation.

Net::BitTorrent is a full-featured, modern BitTorrent client library for Perl 5.40+ that lets you embed a complete torrent engine into your programs while remaining agnostic about how you do I/O. It supports BitTorrent v2 and hybrid v1/v2 swarms, DHT, uTP, protocol encryption, magnet links and .torrent files, per-torrent storage and piece verification, and a simple event/callback API so you can add torrents, drive the engine with a tick loop or integrate it into IO::Async or Mojo::IOLoop, and control download/upload limits or persistent session state. The module exposes high-level methods such as add, add_magnet, add_infohash, wait, tick, save_state, and DHT helpers so developers can quickly join or seed swarms and react to events without reimplementing protocol details. The recent 2.1.0 release focuses on comprehensive security and robustness hardening, fixing several CVE-class issues, replacing insecure RNG usage, adding SSRF and IP safety checks, capping message and queue sizes, and tightening protocol validation and resource limits to make the client safer for use in production. If you need a configurable, actively maintained BitTorrent engine in Perl that emphasizes v2 support and secure defaults, Net::BitTorrent is a strong choice.

SQL::Abstract::Plugin::TableAlias is a lightweight plugin for SQL::Abstract that automatically assigns and applies table aliases when generating SQL, so your SELECT, FROM, JOIN, WHERE and ORDER BY clauses are consistently qualified without hand‑crafted aliasing. You enable it by loading the plugin into SQL::Abstract and optionally provide a talias list to control alias names, and it will rewrite column and join references to use those aliases which helps avoid ambiguous column names in complex queries. It builds on the ExtraClauses plugin and is designed to be simple and unobtrusive to existing SQL::Abstract usage. Recent fixes include correct handling of aliased column expressions using {-as => ...} and a housekeeping release that removed PAX headers.

YAML::Ordered::Conditional is a Perl helper that lets you put simple templating and conditional logic into an ordered YAML document and then compile that template into YAML text, a YAML file, or a native Perl data structure. It provides familiar constructs such as for/each loops, if/elsif/else branches and placeholder substitution so you can generate lists and records from a parameters hash while keeping the original key order intact. The interface is minimal: instantiate with new and use compile to process a YAML template with your parameters, or use the encode/decode helpers to convert between YAML and Perl structures. The module reuses the Struct::Conditional markup style and is handy for Perl developers who need predictable, order-preserving YAML generation for configuration or data templating.

YAML::As::Parsed is a lightweight fork of YAML::Tiny that reads and writes YAML while preserving the order of mapping keys. It substitutes Perl's normal unordered hashes with ordered hashes so iterating or rewriting a document returns keys in the same sequence they appeared in the file, which is handy for human-readable configuration files or any situation that needs deterministic output. The module keeps the familiar YAML::Tiny interface so you can use the same simple read/write operations and data access patterns. Recent updates moved the implementation to Tie::OrderedHash for ordering and refreshed tests and minimum Perl requirements.

YAML::Conditional provides a simple templating layer inside YAML so you can embed conditional and looping constructs (for, each, if, elsif, else and key matching) directly in a YAML document and compile it against a parameters hash to produce concrete YAML or a Perl data structure. You write YAML that describes conditional logic and placeholders and then call compile with your input YAML and a params hashref to render a final YAML string, write to a file, or return a Perl struct, while encode and decode methods offer convenient YAML serialization and deserialization. This is useful for generating environment-specific configs, data fixtures, or any YAML-driven output that changes based on input data without writing a separate templating system. Recent releases fixed file handling in decode (v1.01) and removed PAX headers (v1.03).

JSON::Ordered::Conditional is a Perl module that turns JSON documents into simple, ordered templates with conditionals and loops so you can generate JSON or Perl data structures from a set of input parameters. You write familiar constructs like if, elsif, else and a given block for switch style logic, chain tests with and or or, use regex and equality or numeric comparisons, interpolate placeholders from a params hash, and loop over arrays or hash keys with a for block to build arrays or objects. The API is straightforward you create a JSON::Ordered::Conditional object and call compile to produce a JSON string, a file, or a Perl structure, and helper methods handle encode and decode. This is handy for producing dynamic, predictable JSON output such as API payloads or configuration files without hand coding procedural generation.

JSON::Conditional is a small templating tool that lets you embed conditional logic and simple loops inside a JSON structure and then "compile" that template into a concrete JSON document or Perl data structure based on a parameters hash. You write JSON that contains blocks like if/elsif/else, given, and/or, plus for-each and for-keys loops, and use expressions such as regex matches, equality or numeric comparisons to drive which parts of the template are emitted, while placeholders like "{key}" are filled from your params. The module provides a compile method to produce a JSON string, a Perl structure, or write to a file, plus handy encode/decode helpers and file variants. If you need rule-driven or param-driven generation of JSON from declarative templates this makes the job simple and readable. Recent fixes addressed file handling in the decode method so decoding from files works correctly.

Struct::Conditional embeds a small conditional language inside Perl hashes so you can declaratively transform input parameters into an output data structure. You write a template struct that uses familiar keywords such as if, elsif, else, given, and, or, for and each to express branching, pattern or equality checks, placeholders like {param}, and loops over arrays or hashes. The module provides a simple API with new, compile and itterate to evaluate that template against a params hash and produce a populated Perl structure. This makes it easy to map, filter and reshape incoming data or build rule-driven templates without imperative code, and it is useful when you want readable, data-driven generation of nested structures in Perl.

PerlIO::via::UnComment is a tiny PerlIO layer that automatically strips lines that start with '#' from a file or stream on input or output, letting you open files with :via(UnComment) or apply it to STDIN/STDOUT so only uncommented source flows through; it is intended mainly as a development tool for tasks like testing or producing comment-free output and can be stacked with other PerlIO filters such as PerlIO::via::UnPod. The module has no extra dependencies, is simple and stable, and was adopted by a new maintainer in 2019.

Module::ScanDeps::Static is a small, pragmatic tool for discovering direct Perl dependencies by statically scanning a script or module for common declarations like use, require, parent and base. It can read files or STDIN and produce text, JSON, raw, or RPM-style requirement output, with options to include or exclude core modules, append installed versions when none are specified, and set a minimum Perl version to be considered core. The module itself returns only direct dependencies, and the distribution supplies a find-requires helper for recursive directory scans and cpanfile-style outputs. The scanner relies on regular expressions so it handles many common coding patterns, including base/parent with qw or curly braces, and the recent 1.8.1 release added recognition for Moo and Role::Tiny::With's with syntax and fixed RPM output. It is very useful for quick dependency audits but may miss complex or multi-line constructs because it is a static parser rather than a runtime resolver.

PersonName::Format is a pure-Perl library that renders personal names using CLDR person-name patterns so names appear correctly across languages and writing systems. It inspects the name parts to detect script and likely subtags, chooses an effective formatting locale when scripts differ, and applies configurable options such as length, formality, display order, usage, and optional surname-all-caps. You can format individual name hashes or objects, compile a frozen formatter for repeated use, or get structured parts for custom rendering or markup. The module is useful for web and application interfaces that must present, address, or monogram names in a standards-driven, locale-aware way.

Mojolicious::Plugin::BarefootJS integrates the BarefootJS server-side JavaScript runtime into Mojolicious by registering a per-request "bf" helper that lazily creates a BarefootJS instance backed by BarefootJS::Backend::Mojo and lets you render compiled BarefootJS templates as ordinary Mojolicious templates. It is a straightforward way to add server-side rendering of BarefootJS components to a Mojolicious app and to access the runtime from controllers and templates. If you run outside Mojolicious or under PSGI look at BarefootJS::Backend::Xslate which drives the same runtime without a web framework. A recent improvement makes the plugin load the build manifest lazily and cache it by mtime and size so booting before the first build no longer breaks SSR defaults and manifest changes are picked up without restarting the server.

BarefootJS::Backend::Xslate is a rendering backend that lets the BarefootJS runtime render Kolon ".tx" templates with Text::Xslate. It binds the runtime into templates as the bf object so templates emitted by the @barefootjs/xslate adapter can call runtime helpers and Kolon builtins, and it handles HTML auto-escaping and JSON encoding for you. You can give it a prebuilt Text::Xslate instance or just a list of template paths plus options, and it exposes simple methods like render_named, encode_json, mark_raw and materialize to integrate rendering into your app. The backend is framework-agnostic so it runs under PSGI/Plack or standalone, making it an easy drop-in for projects using BarefootJS and Kolon templates.

BarefootJS is a lightweight server-side runtime that lets templates compiled from JSX/TSX call into Perl during rendering, providing a consistent runtime API while delegating framework- and engine-specific tasks to a pluggable backend. It handles things like JSON marshalling, marking raw strings, materializing JSX children, and named-template rendering without tying you to a particular template engine or web framework, so you can plug in backends such as Xslate for PSGI/Plack or a Mojolicious plugin as needed. The core keeps dependencies minimal by loading only core Perl modules unless a backend requires more, the project is actively maintained with frequent releases, and it is available under the MIT license.

Cucumber::Messages is a Perl library that implements the Cucumber messages protocol and provides Perl classes for every message type used across the Cucumber ecosystem, together with NDJSON serialization and deserialization. It lets you build, inspect and emit Envelope-wrapped messages that Cucumber tools expect, for example converting Location, Attachment or TestCase objects to and from JSON with methods like to_json and Envelope->from_json. Use it when you need to integrate Perl test runners, formatters or reporters with other Cucumber components, handle attachments or externalized attachments, or consume/produce NDJSON message streams generated by the broader Cucumber toolchain. The module follows the shared cross-language message schema maintained by the Cucumber project and is kept in step with upstream protocol improvements.

Geo::Address::Formatter converts a structured postal address (a Perl hash of components like house number, street, postcode and city) into a human readable, country‑specific formatted address using templates for each country. You must supply a configuration path of templates, and the module supports per-call options such as forcing the country, producing abbreviated forms, or limiting output to just address components rather than place names. It returns a multiline string ready for display or printing and exposes the final resolved components of the last formatted address for further use. The distribution includes a minimal configuration for testing but is designed to be used with the comprehensive OpenCage address-formatting templates on GitHub, making it useful for any application that needs consistent, global address formatting.

Text::Hogan is a Perl port of Twitter’s hogan.js that implements the Mustache templating language statement-for-statement. It lets Perl applications precompile Mustache templates into plain Perl code so rendering is very fast and it passes the full Mustache specification, including lambda sections, making it suitable for web pages, emails, APIs or static site generation where simple logic-less templates are preferred. If you are familiar with hogan.js or need a compatible, high-performance Mustache engine in Perl this module will behave as expected and supports dumping compiled templates for reuse. The 2.05 release modernized dependencies and includes various speedups to make compilation and rendering even faster.

CPAN::Test::Dummy::Perl5::SKAJI is a tiny placeholder CPAN distribution intended for testing packaging, upload and release workflows rather than providing useful runtime functionality. It is useful when you need a predictable, no-op distribution for exercising CPAN toolchains, continuous integration pipelines, or publication steps that involve signing and provenance. Recent work has focused on supply-chain hygiene: release tarballs are signed and accompanied by GitHub Artifact Attestations and the project now makes GitHub releases immutable, so it is a convenient testbed for trying out Sigstore signing, PAUSE uploads and attestation-based provenance. The module is maintained by Shoichi Kaji and is licensed under the same terms as Perl.

GraphQL::Houtou is a high-performance, XS-backed GraphQL parser and execution toolkit for Perl that makes it easy to run GraphQL queries with production features and low overhead. It exposes a canonical Perl AST for parsing, an XS native runtime for execution, and multiple APIs so you can pick a simple one-off entry point or build a long-lived runtime for repeated queries. The library includes efficient batching via a bundled DataLoader and an on_stall hook to collapse N+1 database lookups, a direct JSON rendering path that emits UTF-8 bytes without building Perl data structures, a one-line PSGI adapter for HTTP endpoints, and support for persisted queries as compiled bundles or programs for maximum throughput. It also offers async schemas that recognize Promise::XS promises, program caching and cost limits for production safety, and utilities to import or emit SDL. Limitations noted by the author include no subscription execution or streaming transports in the 0.01 profile, no generic promise adapters, fixed native bundles cannot accept GraphQL variables, and the runtime is not compatible with Perl ithreads so use process-based concurrency.

ExtUtils::MakeMaker::CPANfile lets authors drive ExtUtils::MakeMaker's WriteMakefile from a cpanfile so you can declare distribution prerequisites in a modern cpanfile and have them translated into Makefile.PL parameters automatically. It loads a cpanfile found next to Makefile.PL, converts its requires/recommends/suggests/conflicts into WriteMakefile arguments, and strips unknown parameters that older EUMM versions would warn about. It does not fully handle complex version ranges and it sets dynamic_config to false by default though you can enable dynamic configuration via META_ADD or META_MERGE when needed. Recent releases improve dependency handling by merging prerequisites with CPAN::Meta::Requirements so combined constraints are resolved more sensibly.

Complete::KDEActivity is a small helper module that plugs into the Complete family to provide tab-completion data for KDE activities. It exposes two optional functions, complete_kde_activity_guid and complete_kde_activity_name, which return lists of existing KDE activity GUIDs or activity names for use in completion routines. The functions are not exported by default so you can import them only when you need KDE activity completions. This is a focused, first-release utility best suited to developers writing shell completion scripts or command-line tools that need to look up KDE activities, and the source and docs are available from its CPAN and GitHub pages.

String::Mask is a small Perl utility for hiding sensitive parts of strings while leaving a usable, realistic fragment visible for testing or display. It provides a single mask function that takes the text, a visibility position (start, middle, end, or email), an optional count of characters to keep (defaulting to half the string), and an optional mask character (default '*'), so you can easily obfuscate emails, phone numbers, IDs, or other personally or commercially sensitive data while preserving structure and readability. The email mode preserves the @ and domain layout and there is an XS variant available for much higher performance when processing large volumes.

Google::Ai::Generativelanguage::V1 is a Perl client for Google Cloud's Generative Language API that makes it easy to call generation and embedding services from Perl programs. It is an auto-generated gRPC/Protocol Buffers client that integrates with Google::Auth for Application Default Credentials and lets you choose between gRPC and REST transports. The library exposes high-level methods such as generate_content, embed_content, batch_embed_contents, and count_tokens so you can create text, produce embeddings, run bulk embedding requests, and estimate token usage without dealing with low-level RPC plumbing. It is intended for Perl developers who want to add AI-powered text generation or embedding functionality to their applications and is released under the Apache 2.0 license. The bundled documentation notes a couple of POD formatting errors, but the client functionality itself targets standard Google Cloud authentication and transport workflows.