CPANscan

CPAN::Test::Dummy::Perl5::SKAJI is a minimal placeholder Perl distribution meant for testing CPAN-related tooling and workflows. It provides a harmless module you can "use" in build, install, upload, or test scenarios to exercise packaging and continuous integration pipelines without adding real functionality. This makes it handy for developers working on CPAN clients, CI configurations, or test automation who need a predictable, no-op package to validate processes. The module is maintained by Shoichi Kaji and is licensed under the same terms as Perl, so you can freely redistribute and modify it.

BsDiPa is a Perl binding for Colin Percival's BSDiff that creates and applies compact binary difference patches between in-memory data or files. It provides simple core_diff_* and core_patch_* functions to produce and restore deltas, returns clear status codes, and can detect when inputs are identical. Patches are compressed by default with zlib and the module can be built with optional bzip2, xz, or zstd support, while a raw uncompressed mode is available for testing. You can control compression strength with a global setting or with per-patch I/O cookies to reduce memory use and tune performance. The implementation uses a 31-bit size mode and integrates libdivsufsort for speed, and a few global options and cookies are not multithread safe. Use BsDiPa when you need efficient binary diffs for distributing updates, storing deltas, or minimizing transfer sizes.

SPVM is a statically typed programming language with a Perl-like syntax that aims to give Perl developers a faster, compiled alternative while preserving familiar language features. It provides static types with type inference and static analysis, ahead-of-time and just-in-time compilation, native threads and goroutines for concurrency, and C and C++ binding so you can call native libraries. You can run scripts and one-liners with the spvm command, produce standalone executables with spvmcc, and invoke SPVM classes and methods directly from Perl using its bindings. The project includes standard modules, CPAN support, tutorials and examples on GitHub. SPVM is actively developed and has not reached a stable 1.0 release, so backward compatibility is not yet guaranteed.

Tie::OrderedHash provides an insertion-ordered hash implementation compatible with the Tie::IxHash API but implemented in XS and exposing a public C ABI. You can use it as a normal tied hash and get the same insertion-order semantics and familiar methods such as Push, Pop, Shift, Unshift, Keys, Values, Length and Clear, or construct and manipulate the underlying implementation object directly with an OO interface. The main advantage is that downstream XS code can include tie_orderedhash.h and call tie_oh_* functions to read and write the ordered hash without the overhead of Perl's tie dispatch and with support for concurrent C-level iteration. At the Perl level it is a modest speedup over Tie::IxHash, while the C API delivers the big performance win. The initial 0.01 release adds the public C header and build conveniences for Windows so other XS modules can link to its exported symbols automatically.

lazy is a tiny convenience module that automatically installs missing Perl modules at runtime so your one-off scripts and development workflows stop breaking on first use. It leverages App::cpm to fetch and install modules either globally or into a local lib when you pass -L or set up local::lib, and you can forward any App::cpm options through the import list or via PERL5OPT for tools like prove. The goal is to reduce friction during development and ad hoc use by handling dependency installation for you, and it defaults to global installs while still supporting local installations. The author advises removing lazy before deploying code to production.

Finance::Tiller2QIF is a command line tool and Perl module that converts Tiller Money CSV exports into QIF files ready for import into personal finance programs such as GnuCash, KMyMoney, Quicken and others. It loads Tiller CSVs into a small SQLite database, optionally applies a simple, line-oriented mapping file to translate categories or assign destination accounts and to suppress duplicate card-payment credits, and then emits QIF transactions; you can run the ingest, map and emit phases individually or together. The mapping file supports Perl-compatible regexes scoped to one or more accounts, field-based matching, special actions like keeping the source category, leaving the category blank, or skipping a transaction, and you can run custom SQL before or after mapping for advanced preprocessing. The module is primarily a CLI but exposes submodules if you want to script its parts directly, it accepts U.S. and ISO date formats, and recent updates added a preview command so you can inspect what will be emitted before writing the QIF.

AtteanX::Store::LMDB is a Perl module that provides a persistent RDF quad store built on the LMDB key/value database, making it a good choice when you need durable, high‑performance storage of triples and named graphs. It implements the Attean quadstore API so you can open a store, add and remove quads, count entries, and run pattern queries that return streams of matching statements or iterators of graph names. Common operations like get_quads, get_graphs, add_quad, remove_quad, drop_graph and clear_graph are supported, and the module shares its on‑disk format with the Diomede project. If you work in Perl with RDF data and want a compact, efficient persistent backend that plugs into the Attean ecosystem, this module is directly relevant.

File::Raw::Hash is a lightweight File::Raw plugin that computes checksums and digests without altering the streamed bytes, delivering results to a caller-provided scalar, hash, or array reference via the "into" option. It supports common cryptographic hashes (sha256 default, sha512, sha1, md5), integrity checks like crc32, fast non-cryptographic xxh64 with an optional seed, and blake3, plus multi-algo runs in a single pass so you can collect several digests at once. The module offers HMAC mode for the applicable algorithms, multiple output formats (hex, HEX, base64, base64url, raw), and works across read, write, stream, and record phases so it can digest large files with bounded memory or be inserted into File::Raw plugin chains to hash either on-disk bytes or decoded payloads. All algorithms are vendored reference implementations with no external crypto dependencies. This initial 0.01 release includes verified test vectors for HMAC and blake3 and is aimed at easy, composable checksum and fingerprinting tasks rather than replacing full-featured crypto libraries.

OMOP::CSV::Validator is a Perl module and command line tool for developers and data engineers working with OMOP Common Data Model files that checks CSV files for correct data types and structure. It reads PostgreSQL DDL to auto-generate JSON schemas, maps those schemas to CSV filenames, and then validates each CSV row against the expected column types, reporting row-by-row errors to help catch issues before loading data into an OMOP database. The tool is useful for ETL and data quality workflows involving OMOP CDM datasets, and it is open source software written by Manuel Rueda and distributed under the same terms as Perl.

Params::Validate::Strict is a schema-driven validator for Perl that lets you declare precisely what arguments your code expects and then checks, coerces and sanitizes incoming data accordingly. You define a schema with types like string, integer, number, arrayref and hashref plus constraints such as min, max, regex matches, enum/memberof, optional/default, transforms and element schemas for nested structures. The module supports reusable custom types, union types, object checks, callbacks, cross-field validations and relationship rules like mutually exclusive or required groups, and it returns a new hash of validated and coerced values or raises a clear error when validation fails. It is useful for hardening input to functions or web endpoints, generating black box tests or improving API documentation, and it aims to be a powerful, explicit replacement for older validators while being provided under GPL2 and offered as-is without warranty.

Promise::XS provides a fast, XS-backed Promise implementation for Perl that gives you deferred objects, thenable promises, and common aggregators like all and race so you can write asynchronous code without pulling in heavy pure-Perl promise libraries. It favors Perl conventions, allowing promises to resolve or reject with multiple values and accepting lists of promises rather than arrayrefs, and it intentionally does not unwrap promise objects passed to resolve. The module is designed for performance and is compatible with Promise::AsyncAwait for async/await style code, and it can be hooked into event loop adapters such as AnyEvent, IO::Async, or Mojo::IOLoop when you need Promises/A+ style scheduling instead of immediate callback execution. It includes conveniences like preresolved and prerejected promises, a finally implementation that matches ECMAScript semantics, optional memory leak detection, and support for subclassing Promise objects for custom behavior. The project is stable and production ready, though you should be aware of a few platform caveats such as uncertain support for interpreter threads and problematic interaction with fork on Windows. If you want a lightweight, high-performance promise backend for Perl code that integrates with async tooling, Promise::XS is a strong choice.

Dist::Zilla::Plugin::SigStore::SignRelease is a Dist::Zilla plugin that signs your distribution archives with SigStore using the cosign command line and can upload the resulting signature bundle to CPAN alongside your release. It integrates into your dist.ini in place of the standard UploadToCPAN behavior and by default writes a signature file with the .sigstore.json extension; you can also configure it to answer cosign prompts automatically. You will need the cosign tool installed and be aware that CPAN/PAUSE do not yet perform SigStore signature verification, so recipients may need to verify signatures manually with cosign. Recent fixes in 0.05 corrected an example in the synopsis and earlier releases clarified the upload behavior and integration with UploadToCPAN.

Physics::Ellipsometry::VASE is a Perl/PDL toolkit for analyzing variable angle spectroscopic ellipsometry measurements. It wraps core capabilities you need for thin film optical characterization, including transfer matrix calculations, a suite of dispersion models (Cauchy, Sellmeier, Tauc‑Lorentz, Drude, Genosc), effective medium approximations, and a material file loader with unit conversion. The module reads common data formats including Woollam VASE, fits models with Levenberg‑Marquardt or global differential evolution optimizers, supports circular Delta residuals and robust LM regularization, and returns fitted parameters, covariance and model spectra. Plotting is supported through PDL::Graphics::Gnuplot and the distribution includes example scripts to jumpstart typical workflows. This is a good choice for researchers and engineers who want a scriptable, extensible Perl-based environment for ellipsometry modeling and fitting.

Dist::Zilla::Plugin::IRC is a small Dist::Zilla plugin that adds an IRC channel link to your distribution's resources so your CPAN page can point users to a live chat for support or community. You enable it in dist.ini with a simple [IRC] section and the required channel name, and you can optionally supply a network name like perl, libera, freenode or oftc or an explicit host to control the generated link. This is handy if you want to advertise a project channel without hand-editing metadata.

tstregex is a compact Perl library and command line tool that helps you figure out why a regular expression did not match by finding the longest partial match and highlighting the exact token where the match breaks. It pre-parses common regex delimiters and modifiers, exposes a simple API to run diagnostics and retrieve the matching portion, match length, failing token and cleaned subpattern, and offers an enriched CLI view that highlights the failing substring, points to the offending token and reports execution time so you can spot performance issues like exponential backtracking. The module uses a "nibbling" approach that decomposes the pattern and searches for the maximal sequence that can match before failure, making it easier to diagnose anchor, quantifier or group problems without digging into engine internals. You can use it interactively on the command line for quick troubleshooting or embed it in test suites and tools to produce clearer, actionable regex failure messages.

Archive::Lha is a Perl module for reading and extracting LZH/LHA archives, the format once popular on Amiga and MS-DOS and still common in Japan and Amiga collections. It handles header levels 0 to 2 and supports stored and common LHa compression methods lh0, lh5, lh6 and lh7, using XS/C decompression code based on LHa for UNIX for performance-critical parts. The module automatically decodes raw filename bytes by guessing the archive charset from the header so you get UTF-8 paths by default and you can override the source encoding when needed. It is read-only so you cannot create or modify archives, and decompression of very large archives may be slower than native tools; header level 3 is not supported. The distribution also includes plha and plhasa command line tools to list and extract archives with LhA-compatible output.

Test::Most is a convenience wrapper for Perl testing that bundles the most commonly used test modules so you can write less boilerplate and get useful features and bug fixes without having to manage many imports. It automatically enables strict and warnings by default and re-exports functions from Test::More, Test::Exception, Test::Differences, Test::Deep and Test::Warn while also adding helpers like explain for nicely dumper-based diagnostics and an experimental show that tries to reveal lexical names. You can make your suite stop on the first failure by importing die or bail, by calling die_on_fail or bail_on_fail at runtime, or by setting environment flags, and you can replace that behavior with restore_fail or a custom handler via set_failure_handler. An optional timeit helper reports timing with Time::HiRes and you can exclude entire test modules or individual symbols if they conflict with your environment. A few features such as deferred plans and all_done are deprecated in favor of Test::More done_testing, and there is a caveat that the module may only take action on a failing test when the next test is invoked because of how Test::Builder works. If you want a compact, batteries-included test import that gives more control over failure handling and better diagnostics, Test::Most is a good fit.

Term::ReadLine::Repl is a lightweight, batteries-included framework for building interactive command-line REPLs on top of Term::ReadLine. You define commands in a cmd_schema that maps names to exec coderefs and optional argument descriptors for tab completion and then call run to drop into a prompt. The module handles common REPL plumbing for you including tab completion, in-session history with optional persistence to a hist_file, built-in help and quit/exit commands, optional shell passthrough for lines beginning with !, and hooks for Getopt::Long style parsing and custom per-loop logic. It is a good fit when you need a quick interactive console for scripts, debugging, or admin tools and want to focus on command logic rather than terminal handling.

MCP::Run is an abstract helper for building MCP servers that expose a "run" tool to execute shell commands remotely. It registers a standard run tool and expects subclasses to implement an execute method that returns an exit code, stdout, stderr and an optional error string. The module supplies common policy and convenience features such as an allowed_commands whitelist, a validator coderef for custom checks, defaults for working directory and timeout, a compress option to shrink output for LLMs, and a run_stdio shortcut for simple command-line servers. Results are formatted into a readable MCP tool response and the companion MCP::Run::Bash module provides a ready-made bash-backed implementation. Use MCP::Run when you need a controlled, pluggable way to expose command execution from an MCP server.

App::rdapper is a compact command-line RDAP client for fetching and displaying registration data about internet resources such as domain names, top-level domains, IPv4/IPv6 addresses and prefixes, and autonomous system numbers in a readable, terminal-friendly format. You can give it many forms of input including forward or reverse domain names, CIDR notation, ASNs, direct RDAP URLs or tagged entity handles, and you can override type detection when needed. It supports registry versus registrar queries or both, raw JSON output, concise output mode, simple domain search across RDAP servers, basic HTTP auth when pointing at a URL, optional local caching, color control, debugging, and disambiguation for in-bailiwick nameservers. The tool is internationalized and will request localized responses where available and can read default options from ~/.rdapper. Install via cpanm or run the official Docker image. Recent releases tighten requirements on the RDAP backend library by requiring Net::RDAP >= 0.42 and add features such as support for the ttl0 extension and improved handling of internationalized names and entity contact data.

Net::RDAP is a Perl library that makes it easy to query the Registration Data Access Protocol, the modern replacement for Whois, to retrieve information about domain names, IP addresses and ranges, autonomous system numbers, and tagged registry entities. It hides the details of finding the right RDAP service, issuing HTTP requests and parsing JSON responses and exposes tidy objects for domains, IP networks, autnums and entities while also offering limited server-side search, direct fetches and a configurable HTTP client for cookies, proxies and headers. The module can optionally cache responses on disk and supports IDN handling and RDAP features such as tagged objects and redacted fields. Recent updates added support for ttl0 and an accept-language option and changed the default cache location to use File::XDG so cached data lives in a sensible per-user directory rather than /tmp. If you need to build tooling that consumes registry data for troubleshooting, automation or research, Net::RDAP provides the plumbing so you can focus on your application.

App::cpm is a fast, command‑line CPAN installer that focuses on reliable, predictable module installs by preparing all dependencies first and doing the final installation step separately. You use it like "cpm install Module" and it will, by default, fetch and ready the requested distributions along with their runtime dependency closure, which makes installs more stable for large dependency trees and when running in parallel or CI environments. It is a pragmatic alternative to tools like cpanminus and integrates well into workflows that need speed and reproducible installs, and documentation and a tutorial are available to get you started.

Gazelle is a high-performance Plack/PSGI handler that preforks worker processes to run Perl web applications and is optimized with XS for maximum throughput. Derived from Starlet, it uses the picohttpparser for fast HTTP parsing, uses accept4 and writev where available, and integrates Parallel::Prefork and Server::Starter for graceful shutdowns, hot deploys, and unix-socket deployments. It implements HTTP/1.1 but does not provide Keep-Alive support itself, so it is most suitable behind a reverse proxy such as nginx. Gazelle exposes a psgix.informational callback for sending 1xx responses and offers command-line controls for worker count, timeouts, and request limits per child, making it a good choice for performance-focused Perl apps. Recent releases include an important security fix addressing HTTP request smuggling (CVE-2026-40562) along with ongoing portability and test improvements.

Authen::Radius is a mature Perl client library for talking to RADIUS servers, letting you build, send and receive RADIUS requests and responses from Perl programs with minimal fuss. You create a client with the server host and shared secret, optionally bind a local address, set timeouts, enable RFC3579 Message-Authenticator generation, or provide a list of cluster nodes; you can load standard FreeRADIUS/GNU dictionaries (a default set is bundled), add attributes by name or raw type, and send or receive common packet types such as access, accounting, CoA and status-server. The module also includes a handy check_pwd wrapper for quick username/password checks, supports vendor and tagged attributes, IPv6 and various attribute types, and exposes debugging and error helpers so it is useful for integrating authentication, accounting or policy changes into Perl-based systems. It is actively maintained by the PortaOne team and the recent 0.36 release fixed signal handling on receive so an interrupted system call (EINTR) no longer causes spurious retransmits.

WWW::MailboxOrg is a Perl client that wraps the Mailbox.org JSON-RPC v2 API over HTTPS to let you manage mailboxes, domains and related services from Perl code or the included command line tool. It implements session-based authentication and exposes a clear object interface for account and domain management, mail operations like send, fetch and folder handling, mailing lists, blacklist and spam settings, backups, invoices and system utilities. Built with Moo, the module offers pluggable HTTP I/O backends, typed entity objects for accounts and domains, utility functions and support for environment variables, config files and interactive credential prompts, which makes it suitable for automation and administrative scripting. The initial release provides full API coverage and ships with an mborg CLI, so if you need to script or integrate Mailbox.org functionality in Perl, this module is likely relevant.

Business::ISBN is a Perl module for working with ISBN-10 and ISBN-13 identifiers. It accepts messy input and normalizes it, checks and can repair checksums, and converts between ISBN-10 and ISBN-13 when appropriate. The module parses and reports prefix, group, publisher, and article codes and can hyphenate ISBNs at standard or custom positions. You can increment or decrement the article number to walk through sequences of ISBNs. A simple exportable function valid_isbn_checksum is provided if you only need checksum validation without building objects. It can also produce EAN-13 barcode images in PNG format using GD::Barcode::EAN13. The ISBN range data come from Business::ISBN::Data so registry updates can be applied separately, and the constructor returns objects even for near-ISBN input while exposing error codes and human readable error_text to explain validation problems.

AtteanX::Parser::JSONLD is a compact JSON-LD 1.11 RDF parser designed to plug into the Attean Perl RDF toolkit, making it easy to convert application/ld+json documents into Attean binding and statement objects; you obtain it with Attean->get_parser('JSONLD')->new and can feed it a filehandle or a UTF-8 byte string to receive results via iterator or callback interfaces. The module advertises application/ld+json as its canonical media type, supports common JSON-LD file extensions, and implements Attean roles for mixed-statement parsing, abbreviating output, and pull-style parsing so it fits idiomatically into Attean-based workflows. It was first released as version 0.001 on 2020-01-26, is intended to be a straightforward, interoperable parser for JSON-LD input, and bug reports or feature requests are handled through its GitHub tracker.

SPVM::Sys is a comprehensive, cross-platform bridge to operating system services for SPVM programs, wrapping common system calls for file and directory I O, sockets, processes, signals, users and groups, environment variables, and time and stat utilities. It gives you high level helpers for opening, reading, writing and locking files, directory traversal, socket creation and messaging, process control like fork, exec and wait, signal handling and user lookup, plus Perl-style file tests such as -f, -d, -r and -s. The module also handles platform differences, providing Windows UTF 16 filename conversion and portable TCP keepalive configuration so you can write code that runs consistently across Unix and Windows. Use SPVM::Sys when you need direct, portable access to low level system functionality from SPVM without dealing with OS specific details.

Alien::cares is a helper module that makes the c-ares C library available to Perl projects by either using a system-installed copy detected via pkg-config or downloading and building the latest release as a bundled static library. It follows the Alien::Base convention so XS modules can obtain the necessary compiler and linker flags via simple calls like cflags and libs, and you can inspect the installed version or install type with version and install_type. You can force which route to use by setting the ALIEN_INSTALL_TYPE environment variable to system or share. This is useful whenever a Perl extension needs asynchronous DNS resolution or wants to link against c-ares, and it integrates cleanly into Makefile.PL workflows and alienfile-based packaging.

MCP is a Perl SDK that lets you integrate Perl applications with AI agents using the Model Context Protocol. It provides a simple server object, MCP::Server, so you can register named tools with descriptions, JSON Schema input validation, and Perl callbacks, and then expose them as an HTTP endpoint in a Mojolicious app via to_action. For local development and testing you can run a stdio transport with to_stdio and interact with MCP clients from the command line. Authentication and routing remain under your application's control and the module avoids server-to-client streaming when possible to stay compatible with prefork servers. MCP is currently focused on tool calling and prompt workflows and will be extended to support more MCP features in the future. This is a lightweight, Perl-friendly way to make your text-processing code available to LLMs and other MCP-compatible systems and it is released under the MIT license.