CPANscan

Dist::Zilla::Plugin::IRC is a tiny Dist::Zilla plugin that adds an IRC channel entry to your distribution metadata so users can find the project's chat room. You enable it in your dist.ini with a stanza like [IRC] and channel = distzilla and you can optionally set network (defaults to "perl" but accepts values such as "libera", "freenode", or "oftc") or supply an explicit host to control the resulting link. It is useful when you want to advertise a real-time support or community channel alongside other resources in your CPAN distribution.

Task::Devel::Essentials is a lightweight meta-module that installs a curated toolkit of commonly used Perl modules so you can set up a developer environment with one cpan or cpanm command. It brings together testing and QA tools, profilers, packaging helpers, object systems like Moose/Moo/Mouse, JSON/YAML, file and date utilities, networking and MIME helpers, and many small conveniences that most Perl authors use every day, with a few optional XS or GNU-readline variants included where available. If you want a ready-made collection rather than picking dozens of dependencies by hand, this bundle saves time and keeps your toolchain consistent. The package was recently bumped to newer bundled versions, added CPAN::DistnameInfo, and moved its repository and issue tracker to Codeberg.

ClearPress is a lightweight, pragmatic Perl web framework that provides a simple, scaffolded way to build CRUD-style applications with a loosely MVC-inspired layout. It prescribes a project structure with a controller script, model and view modules, and Template Toolkit templates so you can quickly create list, add, edit, read, update and delete pages. Models are explicit Perl classes that declare their fields and use Class::Accessor-generated accessors instead of inspecting the database for schema, and the framework offers helpers for common associations and templates get convenient objects like the requestor and model injected. There is no built-in authentication and views behave more like controllers than in a strict MVC pattern, but that minimalism makes ClearPress well suited for rapid development and straightforward deployment using standard Perl components such as CGI, Template and Config::IniFiles.

Perl7::Handy provides a Perl 7-style scripting environment for older Perl 5 interpreters by importing safer, modern defaults into the caller package. It enables strict and warnings where supported, disables legacy bareword filehandles and multidimensional array emulation, enables subroutine signatures on capable Perls, lexically disables the indirect call feature, and removes the current directory from @INC to address a known security issue. The module runs on Perl 5.00503 and later and will use optional helper modules when available, with some behaviors only available on newer Perl releases. Use Perl7::Handy when you want the safer, modern defaults of Perl 7 for your scripts without upgrading your Perl interpreter.

Params::Validate::Strict is a Perl utility for checking and coercing function or API parameters against a rich, declarative schema so you can enforce types and business rules before your code runs. You describe each parameter with simple types or detailed rules for length, numeric ranges, regexes, allowed or forbidden values, transforms, defaults and optionality, and the module also supports nested structures, per-element checks for arrays, reusable custom types, cross-field validators and relationship rules like mutually exclusive or required groups. Validation returns a new hashref of validated and coerced values or dies with a clear error by default though you can configure warnings or ignore unknown parameters and plug in a logger. It is handy for API input checking, web application firewalls, improving documentation and driving black-box test case generation.

Mojo::SQLite is a lightweight Mojolicious-aware wrapper around DBD::SQLite that makes embedding SQLite in web apps straightforward by providing pooled, fork-safe connections, built‑in schema migrations, SQL generation via SQL::Abstract::Pg and convenient query and result helpers. It uses synchronous DBI calls and raises exceptions for errors, supports transactions and JSON parameters, caches handles for performance and emits a connection event when new connections are created. You can enable WAL journaling for better concurrent read/write behavior but note that as of v4.0.0 WAL is off by default for new databases and remains persistent once set, and in-memory databases are per-connection only. If you need a compact, well integrated SQLite backend for a Mojolicious app with easy migrations and CRUD generation, Mojo::SQLite is a good fit.

Net::BCCN is a small Perl module that implements a lightweight LISTEN/NOTIFY style notification fabric over UDP broadcast for a single local network segment. It lets processes and machines broadcast short, opaque messages on named channels without a central broker so you can publish events with notify(channel,payload) and receive them with listen(channel,options). The module handles socket setup, optional per-message deduplication and simple message-rate statistics, and uses nonblocking I/O with an optional timeout for efficient polling. It is intentionally fire-and-forget with no acknowledgements, persistence, or replay so occasional packet loss is expected. Envelope-level integrity and directed or multicast delivery are part of the protocol design but are not yet implemented in this release. This is the initial CPAN release (version 1.11, 2026-05-25).

Protocol::Tus is a Perl implementation of the Tus resumable upload protocol that makes it easy to accept, resume, and manage large file uploads from web clients. It offers a framework-agnostic API centered on HTTP_request, which takes an HTTP method, headers, an optional upload id and a body scalar reference and returns a Protocol::Tus::Response object for your application to turn into an HTTP reply. Storage is pluggable via a model object that implements the Protocol::Tus::AbstractModel interface or via a class spec such as Protocol::Tus::LocalDir for filesystem storage. Convenience methods cover the common HTTP verbs used by Tus including POST, PATCH, HEAD, OPTIONS and DELETE and the module honors X-HTTP-Method-Override for middleware compatibility. You can supply an id_to_location callback to generate Location headers after creating uploads and you are responsible for mapping URL paths to upload identifiers. Methods return response objects rather than throwing exceptions and the module requires Perl 5.24 or later. This is the initial 0.001 release.

IO::Tty is a low-level Perl module that allocates pseudo-terminals and exports the constants you need to work with them, but it is intended to be used internally by IO::Pty so most users should use IO::Pty to create ptys rather than calling IO::Tty directly. It supports modern POSIX systems and Cygwin and is tested on Linux, macOS, FreeBSD, OpenBSD and NetBSD, with known platform quirks documented in the POD because pty behavior is system dependent. The module is useful if you need direct control over pty allocation or just want the ioctl and terminal constants from IO::Tty::Constant. Recent 1.31 fixes a regression that stopped the slave from becoming a controlling terminal by always passing O_NOCTTY and improves openpty detection on some glibc builds.

YAML::Syck is a fast, lightweight Perl interface to the libsyck serializer that converts Perl data structures to YAML and back with simple functions like Load, Dump, LoadFile and DumpFile, plus newer encoding-aware helpers such as LoadBytes and LoadUTF8. It is designed for speed and interoperability with other Syck/YAML bindings and offers configurable behaviors through global flags for implicit typing, Unicode handling, key sorting and how code or blessed objects are treated. The module implements YAML 1.0 and bundles its own libsyck sources, so it may not match newer YAML 1.1/1.2 semantics and the author notes it has known issues and is only semi-actively maintained, so you may prefer YAML::XS for strict YAML 1.1/1.2 compatibility. Recent maintenance releases have fixed a number of parsing and memory issues and, as of 1.46, ensure numeric-looking strings are preserved as strings when dumping and accept trailing commas in flow sequences and mappings for better round-trip fidelity.

Concierge is a lightweight service-layer orchestrator that centralizes user authentication, session management, and user record storage for Perl applications, presenting a single, simple API and Concierge::User objects instead of exposing the underlying components. It wires together three pluggable cores for passwords, sessions, and user data so you can create a "desk" directory with Concierge::Setup and then open that desk at runtime to register users, create visitor or guest sessions, authenticate logins, restore users from cookies, and manage user records and passwords, with every method returning a clear success/message result rather than throwing exceptions. The module supports anonymous visitors, temporary guest sessions that can be upgraded to logged-in accounts, and persistent user records, and it persists a random user_key mapping to make cookie-based restores reliable. If you need custom backends or extra record types you can swap any of the core components for a drop-in replacement and add new components that follow the same conventions. The recent 0.7.0 release added Concierge::Base and expanded the extensibility documentation to make building and attaching new components easier.

App::Test::Generator is a toolkit that automates the creation of thorough test harnesses for Perl modules by turning simple input/output schemas into ready-to-run .t scripts that mix randomized fuzzing, deterministic boundary checks, optional static corpora, and property-based tests. You feed it a YAML or Perl schema describing function parameters and expected outputs and it generates Test::Most/Test::LectroTest-based tests that handle functional and OO calls, seedable reproducible fuzz runs, semantic generators for realistic data, transform-based invariants, and configurable edge cases for strings, numbers, arrays and hashes. The suite ties into mutation testing and LCSAJ metrics so surviving mutants can drive new schemas and tests, and it can produce a mutation and coverage dashboard and CI-ready workflows for continuous fuzzing. Helpers for serializing Perl values into test code and a SchemaExtractor that infers schemas from POD and source make it easy to bootstrap tests from existing modules. The recent 0.39 release tightens the mutation dashboard scoring and fixes a range of SchemaExtractor edge cases by adding Input formal spec parsing, better list-return handling, and several false positive fixes so the generated schemas and mutant-guided tests are more accurate and reliable.

Error::Show is a utility for locating and diagnosing Perl syntax errors and runtime exceptions by printing numbered, annotated source code around the problem and a readable stack trace. You can enable it from the command line with -MError::Show to have Perl run normally while the module intercepts syntax errors and warnings and emits context, optionally piping explanations through the diagnostics helper splain. Inside programs it exports a context function that accepts a die string or common CPAN exception objects and returns nicely formatted code snippets and frame context, and it integrates with several popular exception classes. For debugging dynamically generated code it provides streval, which preserves the original string so Error::Show can show accurate context and traces, and throw to create a simple exception object with captured frames when you need a lightweight throw. Recent releases added streval and throw and in v0.5.1 introduced an option to limit reported call stack depth while tidying output formatting. You can tune output with options for pre and post lines, limits, reversing order, and whether to include the raw Perl error text, and you should note it does not support programs supplied via STDIN or Perl -e and -E switches and splain may produce more output than ideal.

Git::Libgit2 provides low-level FFI::Platypus bindings to the libgit2 C library via Alien::Libgit2 so you can call libgit2 functions directly from Perl. It exposes a near-C API for initializing and shutting down the library, querying the version, checking return codes and converting object IDs, and for working with repositories, refs, blobs, trees and commits as well as remotes and authentication, clone/fetch/push operations, revwalks, branches, tags, diffs, status and related helpers. The module is intentionally close to the C surface, making it a good fit when you need direct, fine-grained control or plan to build higher-level helpers, and if you prefer an idiomatic Perl wrapper with RAII you can use Git::Native instead. This initial 0.001 release ships a broad set of bindings and has been tested against libgit2 1.5 and 1.9.

WWW::MailboxOrg is a Perl client for the Mailbox.org API that makes it simple to automate and manage Mailbox.org accounts and services from Perl programs. It speaks JSON-RPC 2.0 over HTTPS and uses session tokens for authentication, letting you log in and out and then call API areas such as account, domain, mail, mailing list, blacklist, spam protection, video chat, backup, invoices, password reset, validation and utility functions through dedicated helper objects. The module defaults to the official API endpoint and stores the session token for subsequent calls so you can focus on tasks like listing accounts, querying domain info or managing mail settings rather than HTTP plumbing. It is suitable for Perl developers who need to integrate Mailbox.org administration or mail workflows into scripts and applications, and links to the upstream API documentation and a GitHub issue tracker for support and contributions.

Travel::Status::DE::DBRIS is an unofficial Perl client for bahn.de that helps you fetch live departure boards, search stations by name or coordinates, and retrieve trip details and carriage formation for German trains. You can use it synchronously or asynchronously with promises and Mojo::UserAgent, and it returns rich objects for departures, journeys, locations, and formations so you can easily display times, delays, lines, destinations and route stops. The module supports optional caching to reduce repeated realtime requests, a failure cache to avoid hammering the backend, filtering by modes of transit, fetching intermediate stops, and injecting prepared JSON for testing. It is actively maintained but still described as work in progress and includes mitigations for Deutsche Bahn's rate limiting and web application firewall, so you should use sensible caching and request rates. Recent releases add nicer location output by showing distances when GIS::Distance is installed and keep train and operator names up to date to match backend changes.

Hypersonic is a Perl micro HTTP server that JIT-compiles your routes and its event loop into native C so the hot path can run with virtually no Perl overhead, delivering very high throughput. Static route handlers are executed once at compile() time and their complete HTTP responses are baked into C as constants, while dynamic routes still invoke Perl per request with JIT-compiled request objects where needed. It supports WebSocket connections and optional room-based broadcasts, server-sent events and streaming responses, TLS via OpenSSL, gzip compression compiled into the server, sessions, an async thread pool, and on-disk caching of compiled XS modules, so it is well suited for low-latency APIs, static asset serving, and benchmarking. You register routes with familiar get/post/websocket/static methods, call compile() to generate and build the native code, then run() to start workers and listen on a port. The module is explicitly performance-focused and claims very high request rates, and its JIT features require a C toolchain and native libraries such as zlib for compression and OpenSSL for TLS.

File::Copy::clonefile is a tiny Perl wrapper around the clonefile system call that lets you request a filesystem-level clone of a file from Perl. It exports a single function, clonefile, which you call with a source and destination path and then check the return value and $! on error. Because it delegates to the underlying clonefile syscall it only works on platforms that provide that facility, for example macOS, so it is useful when you need fast, space-efficient copies on systems that support copy-on-write cloning but not applicable on other platforms.

Perl500503Syntax::OrDie is a simple compatibility watchdog that helps you catch syntax and runtime constructs introduced after Perl 5.005_03 before you deploy to old systems. When you add use Perl500503Syntax::OrDie to a script it reads the calling file, masks comments and quoted literals, scans for newer language features and regex constructs, and dies with a filename and line number if anything unsupported is found. It also installs runtime guards to prevent certain unsupported uses of open and mkdir, and provides a programmatic API so you can scan strings or files on demand or run it from the command line. The module intentionally does not inspect the contents of string literals or the bodies of regexes and it is not a full Perl lexer so unusual quoting or dynamically generated code may evade or trigger false alarms. It is written to run on Perl 5.005_03 through modern releases, but be aware that its CORE::GLOBAL:: overrides affect the whole interpreter so it is not intended for use inside production processes.

File::FindRoot is a small Perl utility for locating a project's root directory by walking up the filesystem from a starting point until it finds a file, directory name, or pattern you specify. You give it a relative path or regex and it returns the ancestor directory that contains that target or undef if none is found. You can also supply a custom callback to decide what counts as a match, and tune behavior with options such as start_at to change the starting directory, limit to cap how many ancestors are checked, and debug/debug_fh to see progress. The module is minimal and easy to drop into scripts that need to locate config files, libraries, or VCS markers without relying on fixed paths. This is a newly released module with its initial user release in May 2026.

CPANSA::DB provides the CPAN Security Advisory reports as a ready-to-use Perl data structure, primarily to feed tools like CPAN::Audit but available to any code that needs a curated list of security advisories for CPAN distributions. You access it with CPANSA::DB->db and get a hashref of reports, and a matching JSON file is also provided if you prefer non-Perl consumption. Releases are published on GitHub and shipped with both GPG signatures and GitHub attestations so you can verify an archive came from the official source before trusting the data. The database is actively maintained with frequent updates and has recently been made more compact by switching to a terser internal format, so it is a convenient, verifiable source for integrating CPAN security information into scanners, audits, or dashboards.

HP::Handy is a compact, single-file template engine that brings Jinja2-style templating to Perl 5.5.3 and later without any external dependencies. It offers familiar {{ }} variable output, {% %} control tags, filters, tests, loops, template inheritance, macros and includes, plus simple customization like auto-escaping and configurable delimiters, and it exposes render_file and render_string methods as well as hooks to add custom filters and tests. The implementation is intentionally minimal and portable, using a regex-based evaluator so you can drop the file into small web projects or pair it with HTTP::Handy and DB::Handy to build a lightweight MVC stack. Because templates are parsed on each render there is no compiled cache, recursion and some advanced features like super or imports are not supported, and string operations are byte-oriented to preserve compatibility with older Perl versions. If you need a zero-dependency, Jinja-compatible templating layer for legacy or small-scale Perl apps, HP::Handy is a practical and easy-to-use choice.

aozora is a greple module for proofreading texts destined for Aozora Bunko that scans Japanese documents for common OCR and transcription problems, odd punctuation and spacing, kana and katakana anomalies, ruby/annotation issues, rare or old character usage, and other formatting oddities. It integrates with the greple search tool and exposes many command line checks you can enable to flag likely errors so you can inspect and fix them before submission. The module speeds up quality control for contributors preparing texts for Aozora Bunko, but it only highlights potential issues and can produce false positives, so manual review is still required.

App::cpm is a fast command-line installer for Perl modules from CPAN that aims to make installs more stable and predictable. It prepares dependency builds first and performs the final installation separately, so dependency graphs and parallel work complete more reliably. By default it installs the requested distributions and their runtime dependency closure, and it supports reading from cpanfile or STDIN, cached prebuilt builds for speed, and clear terminal progress and logging so failures are easier to diagnose. It targets modern Perls (requires v5.24 or later) and is a practical alternative to cpanminus and other installers for users who need repeatable, efficient installs. Recent releases added GitHub Artifact Attestations for CPAN tarballs to help verify provenance and an opt-out mechanism to report local Perl version usage to MetaDB.

App::ArithmeticsUtils is a tiny Perl distribution that provides a simple command-line utility and helper function for computing a division result and its remainder in one step. The core routine, calc_divide_remainder, takes two numeric arguments a and b and returns the quotient and remainder together as a pair, for example passing 140 and 6 yields [23, 2]. The function is not exported so you can use the provided script or call the function by its fully qualified name in your code. This module is useful when your scripts or command-line workflows need both parts of a division operation without extra boilerplate. The release is the initial 0.001 version and the project is hosted on MetaCPAN and GitHub.

XS::JIT is a compact runtime JIT compiler for Perl that lets you compile and load C/XS code on the fly without the heavier machinery of Inline::C. It is aimed at situations where you generate C dynamically and need fast, in-process compilation and symbol installation, and it avoids C parsing and xsubpp by emitting C directly and invoking the system compiler, with optional caching of compiled modules. You call XS::JIT->compile with your C source, a unique module name and a map of Perl function names to C functions, and you can choose between simple wrapper-style functions or XS-native functions for best performance, or use its generate_code, is_cached, cflags and libs helpers when embedding the JIT into build systems or other XS modules. The module also exposes a C API and Inline::C-compatible macros so existing XS code can be adapted easily. Recent fixes improve cross-platform linking and error reporting so dlopen failures now croak with the .so path and underlying OS error and the link order has been corrected for more reliable builds.

Time::Str is a Perl module for reliably parsing and formatting date and time strings across a wide range of standards. It exposes three main routines: str2time to convert a timestamp string into a Unix epoch (including fractional seconds), str2date to return parsed components such as year, month, day, hour, minute, second, nanosecond and timezone annotations, and time2str to render an epoch into many standard textual formats. The module understands ISO 8601 / RFC 3339, RFC 2822, HTTP dates, SQL/ISO9075, ASN.1 GeneralizedTime and UTCTime, RFC 9557 and common Unix and ECMAScript variants, and includes a permissive DateTime parser for many real-world forms. You get fine control over fractional precision and rounding, an explicit nanosecond override for exact output, a pivot_year option for two-digit years, and the ability to format with arbitrary timezone offsets. str2time requires a UTC designator or numeric offset and will croak on unresolved timezone abbreviations while str2date preserves such abbreviations for external resolution. The module integrates with Time::HiRes, DateTime and Time::Moment, and ships with optional fast C/XS parsers plus a pure-Perl fallback. Note the documented limitations: English-only month and day names, no ISO week or ordinal dates, a supported year range of 0001-9999, and no built-in resolution of ambiguous timezone abbreviations.

App::PTP is a small command-line toolkit that helps you build and run compact Perl-based pipelines and text transformations without writing a full script. It provides many convenience commands and switches for common pipeline tasks such as loading modules on the fly, running shell fragments, feeding arguments like xargs, deduplicating or uniquely filtering streams, grepping with flags, handling quoting modes for shell escaping, merging pipeline stages where specified, and even sorting version strings by semantic version with the new --semver-sort option. The distribution also includes a printable cheat sheet and a built-in set of commonly used modules to make one-liners and ad-hoc processing easier to write and reuse, and it adds workflow helpers like --push/--pop for saving and restoring file content. If you frequently use Perl from the command line to manipulate files or streams and want a richer, opinionated toolkit for composing pipelines, App::PTP is a practical, installable helper to simplify those tasks.

CPAN::Mirror::Tiny is a lightweight tool for building a private or partial CPAN mirror, often called a DarkPAN, so you can host and serve only the distributions you need. It lets you "inject" packages from local tarballs, HTTP URLs, Git repositories, or CPAN itself and then generates the standard CPAN index files so clients like cpanm or cpm can install from your mirror. The module is designed for embedding into CPAN clients and keeps dependencies tiny with no XS modules, making it portable and easy to deploy. A small command line interface is provided, metadata caching speeds up index generation, and Windows support has been improved. The latest stable release raised the minimum Perl requirement to v5.24 and the project publishes GitHub Artifact Attestations for release tarballs if you need provenance.

Proc::ForkSafe provides a small, practical wrapper to make objects safe to use across forked processes by ensuring the wrapped object is reinitialized in child processes instead of being accidentally shared. You supply a factory coderef that creates your persistent resource and then invoke methods through the wrapper; after a fork the wrapper gives the child its own fresh instance so sockets, database handles, and other non-fork-safe resources are not reused across processes. The module is lightweight and easy to integrate into code that uses long-lived clients or handles, and it is distributed under the same license as Perl. Note that the 1.0.0 release raised the minimum required Perl version to 5.24.