CPANscan

Atomic::Pipe gives you a reliable way to send discrete messages through a POSIX pipe without them getting interleaved when multiple writers are active. It splits larger payloads into PIPE_BUF-sized atomic chunks with headers so a reader can reassemble complete messages, and it exposes simple reader and writer objects via pair, from_fh, or FIFO helpers along with write_message and read_message operations. The module supports non-blocking writers with buffered output, lets you resize or query pipe capacity where supported, and offers a special mixed-data mode that embeds atomic bursts and marked data into otherwise noisy STDOUT/STDERR streams so you can extract messages from interleaved prints. Note that it only works on POSIX-compliant pipes and that message ordering is not guaranteed across different processes, and mixed-data mode uses control characters that could be confused by arbitrary binary output. Recent maintenance includes fixes for EOF and race conditions in mixed-data mode and a 2026 update to avoid test lockups on systems with 16k pipe buffers.

Text::Minify::XS is a small, fast Perl XS module for trimming multi-line text by removing leading indentation and trailing whitespace, collapsing repeated blank lines, and normalizing carriage returns to newlines while leaving in-line text and markup intact. It exposes a simple minify function (with minify_utf8 as an alias) and a minify_ascii variant optimized for 8-bit text, and is useful when you want to shrink or tidy plain text without parsing HTML, code, or other markup. The module requires Perl 5.14 or newer and is designed for speed and low overhead, but you should ensure input is properly encoded UTF-8 because malformed UTF-8 can be mangled or may trigger an exception; the latest release (v0.7.8) includes a fix for handling malformed UTF-8 (CVE-2026-7040).

Test2::Plugin::MemUsage is a tiny Test2 plugin that reports a test process's memory usage by reading /proc/PID/status and printing values like RSS, size, and peak when the test run finishes. It integrates simply by adding use Test2::Plugin::MemUsage to your test files or by invoking perl -MTest2::Plugin::MemUsage on the command line for a one-off measurement. Because it depends on /proc/PID/status it only works on Unix-like systems that provide that file and is essentially a no-op elsewhere. This makes it a handy, low-friction tool for spotting memory regressions or verifying memory behavior during test runs.

App::papersway is a small Perl utility that brings the PaperWM style of scrollable, stacked tiling to Sway and i3 window managers, letting you organize windows into a vertically scrollable stack so you can switch focus and navigate workspaces with smooth scrolling or keybindings rather than juggling floating windows. It is aimed at users who like a compact, keyboard-driven tiling workflow and want the PaperWM experience on Wayland or X via Sway/i3. The tool is actively maintained by Sean Whitton and is released as free software under the GNU General Public License v3.

Data::Checks provides a compact set of ready-to-use value constraint checks for Perl together with an XS-level framework so other modules can build and embed those checks efficiently. It exports familiar predicates like Str, Num, Object, Maybe, Any and All and also parametric checks such as StrEq, StrMatch, NumGT/GE/LE/LT, NumRange, NumEq, Isa and Can plus ArrayRef, HashRef and Callable, and works with common extension points like Signature::Attribute::Checked, Object::Pad::FieldAttr::Checked and Syntax::Operator::Is to enforce argument or attribute validation. Each constraint can be queried via a check method and the XS API exposes functions to construct, assert and run checks from compiled code. The checks differ slightly from Types::Standard by being more accepting of objects that overload string or numeric conversion and the author lists planned additions such as unit and structural constraints and some performance tuning.

Dist::Zilla::Plugin::GitHub::CreateRelease is a Dist::Zilla plugin that automates creating a GitHub Release for your distribution and attaches the CPAN release archive to that release. It can generate release notes from various sources, apply a title template, mark releases as draft, add a checksum for the uploaded archive, and target a specific repo, remote or branch using simple settings in dist.ini. The plugin uses Config::Identity::GitHub for credentials and supports encrypted identity files so you can feed it a personal access token with the appropriate repository write permissions. It is intended to run after your AfterBuild and VCS tagging/pushing steps so the tag and code are already on GitHub before the release is created. A recent update removed the Module::Signature dependency to simplify installation and reduce required prerequisites.

MetaCPAN::Client is a Perl library that gives you programmatic access to the MetaCPAN API with DWIM-friendly search behavior, so you can easily find authors, distributions, releases, modules, files, POD, mirrors, CVEs and more from scripts or applications. It offers simple high-level methods such as author, distribution, module, release, file, pod, download_url, recent, autocomplete and reverse_dependencies and returns typed objects or iterable result sets for integration into CLIs, daemons or UIs. The client is designed to be lightweight and flexible and lets you plug in a custom HTTP user agent to enable caching or alternate transport layers. It aims to mirror the MetaCPAN API closely and is kept up to date against the beta API, so it is best suited for projects targeting the current MetaCPAN endpoints. If you need reliable, scriptable access to CPAN metadata from Perl, this module is a good fit.

Log::Any is a small, dependency-free logging facade for Perl modules that separates log production from log consumption so libraries can emit log messages without forcing an application to adopt a particular logger. Modules obtain a lightweight logger and call familiar level methods like debug, info, warn or error, attach a single structured hashref or contextual data to messages, and test whether a level is enabled to avoid unnecessary work. Applications decide where logs go by configuring Log::Any::Adapter to forward messages to Log::Log4perl, Log::Dispatch, files, stderr, syslog, a capture collector for tests, or custom sinks, and the default null adapter makes logging safe when no consumer is set. The project includes testing helpers and supports common log levels and categories while keeping a tiny footprint so it is suitable for CPAN modules. Recent updates include continued fixes and performance improvements in the 1.720 release.

IO::Barf is a tiny, focused utility that writes a string to a file or filehandle with a single call. It exports one function, barf($file_or_handler, $content), which accepts a filename or a filehandle and dumps the provided content, reporting errors if it cannot open or close the target or if given an unsupported reference. The module is lightweight and designed for simple, fast output operations and performs well in microbenchmarks versus alternatives like Path::Tiny, File::Slurp and IO::All. The 0.12 release mainly refreshed the documentation and benchmarks to include File::Raw and updated the SEE ALSO section and copyright years.

Try::ALRM gives you compact, try/catch-style blocks that add alarm-based timeouts and automatic retries to Perl code, so you can run a block with a per-attempt timeout and optionally retry it a fixed number of times. You use keywords like retry, try_once, ALRM and finally along with timeout and tries modifiers to declare what happens when a run times out, to handle the timeout, and to clean up after all attempts. When an alarm fires the ALRM block is executed and the current attempt is aborted, retry moves to the next attempt if any remain, and finally always runs at the end; nested retry or try_once scopes are supported and inner timeouts do not permanently cancel outer ones. The module exports a small set of keywords, provides global default variables for timeout and tries, and relies on localized SIG{ALRM} handlers so it behaves predictably across nested calls. It is handy when you need structured, declarative timeout and retry logic in scripts but the author notes there may still be bugs, so exercise normal caution.

Legba provides fast, globally shared named storage slots that any package can access by importing the same slot name. You can install accessor functions that act as both getter and setter or use the functional API (Legba::get, Legba::set) and you can add slots explicitly with Legba::add. When a slot name is a literal constant created at compile time, Legba optimizes calls into custom ops for much higher speed and you can also resolve a numeric index for ultra-fast repeated access. Optional watchers let you react to every set operation with no runtime cost unless you register a watcher, and per-slot locking and freezing let you prevent or permanently disallow changes. It interoperates with threads by storing threads::shared variables in slots and children after fork inherit copy-on-write slot values. Advanced helpers expose low-level hooks such as raw SV pointers and op creation for embedding in XS. Recent 0.08 updates addressed Kwalitee issues reported by packaging tools.

File::Raw is a lightweight Perl toolkit for high-performance file I/O that bypasses PerlIO and talks to the OS directly to speed common tasks. It exposes convenient file_* functions for slurping and spewing whole files, appending, efficient line iteration and callbacks, memory‑mapped zero‑copy reads, atomic writes, filesystem helpers (copy, move, mkdir, readdir, basename/dirname, etc.), and a stat call with caching to avoid repeated syscalls. The module also supports pluggable read/write hooks and provides a documented XS C API so other extensions can register fast, low‑level hooks without Perl callback overhead. Platform optimizations such as sendfile on Linux and copyfile on macOS and MULTICALL optimizations for callbacks make it a good fit for processing large files or low‑latency file workloads, while the import style installs functions with a file_ prefix for simple use. Recent updates focus on cross‑platform build fixes and portability, and add platform-aware file_join plus C implementations of mkpath and rm_rf and improved selective importing.

Numeric::Vector brings fast, SIMD-accelerated numeric vectors to Perl by automatically compiling for the best available instruction set on your machine and falling back to a scalar implementation when needed. It stores 64-bit floating point values and provides a familiar API for creating vectors (new, zeros, ones, linspace, range, random), accessing and slicing elements, and performing element-wise arithmetic with overloaded operators and in-place variants for low-allocation updates. You get a wide range of vectorized math and trig functions, reductions like sum, mean, variance, median, min/max, dot, norm and cosine similarity, boolean and comparison masks, selection and transformation helpers such as where, sort, argsort, cumsum and diff, plus BLAS-style operations like axpy and fused multiply-add for performance-critical loops. The module exposes both an object interface and optional zero-overhead functional imports implemented in XS, reports which SIMD backend was used via simd_info, and is a good fit if you need compact, high-performance numeric arrays in Perl for data processing, scientific computing, or machine learning workflows. Note that all data are double-precision floats and many operations require matching vector lengths.

IPC::Manager::Client::SharedMem is a plugin for IPC::Manager that implements a simple interprocess message store using System V shared memory so multiple processes can share client state, messages, and statistics without a separate broker. It serializes access with a System V semaphore and stores the data as JSON with a 4‑byte length prefix, automatically allocating a larger segment if the data grows beyond the current capacity. You use it by spawning an IPC::Manager server with protocol => 'SharedMem', then connect clients with ipcm_connect or the spawn handle to send and receive messages; routes are passed as "shmid:semid". The module requires IPC::SysV 2.09 or later and the source is on GitHub. Recent work split the test suite into per-subtest files so prove -j can run tests in parallel and bumped the IPC::Manager test prerequisite for that change.

MCP is a Perl SDK that connects Perl applications to AI models using the Model Context Protocol, making it easy to expose functions, prompts, and resources as discoverable tools for model-driven workflows. It integrates with Mojolicious so you can add an MCP HTTP endpoint to a web app or use a stdio transport for local command-line testing, and it validates tool inputs with JSON Schema so your tool interfaces stay well defined. The module supports tool calling, prompts, sessions, structured and multimedia results, resources, and streaming responses via SSE, and recent releases added resource and audio support plus tool annotations for richer metadata. If you want a Perl-native way to let AI systems discover and invoke your services while keeping authentication and scaling under your application’s control, MCP is a practical and actively developed choice.

Crypt::OpenSSL3 is a Perl wrapper around OpenSSL 3 that brings OpenSSL's TLS and cryptographic primitives into Perl programs. The distribution is split into focused submodules for actual work, including SSL for TLS connections, PKey for asymmetric keys, Cipher for symmetric ciphers, MD for message digests, MAC for message authentication codes, KDF for key derivation functions and X509 for certificate handling. The top-level Crypt::OpenSSL3 package itself mainly offers basic error handling and build-time introspection and version information, so you load the specific submodules when you need particular crypto or SSL features. Choose this module when you want direct, modern OpenSSL-backed cryptography and TLS support from Perl code.

Horus is a high-performance Perl extension for generating and handling UUIDs that implements all RFC 9562 versions from v1 through v8 and also provides NIL and MAX values. It is written in XS with no external C library dependencies and exposes both simple functions and an OO interface so you can generate single UUIDs, bulk batches for speed, or deterministic namespace UUIDs, validate and parse strings, convert between formats, extract timestamps and compare values. You get ten built-in output formats including standard hyphenated strings, compact hex, URN, binary, 22-character base64, RFC4648 base32 and Crockford base32, plus upper-case variants. The module is tuned for throughput with buffered random pools and minimal Perl/C crossings and aims for multi-million v4 UUIDs per second generation. Recent updates focused on compatibility and robustness with various Perl builds and test environments by widening timing tolerances and fixing op-level issues on debugging Perls, so it should work reliably across platforms.

Enum::Declare gives you a clean, declarative way to create enums in Perl by installing compile-time constant subs and a lightweight metadata object for introspection. You can define integer enums that auto-increment, string enums, and bitflag enums for powers-of-two masks, assign explicit values, and optionally export constants to callers. The enum metadata exposes names, values, name/value lookups, exhaustive pattern matching via a match method, and a count of variants so your code can validate and dispatch safely. The companion enumSet feature lets you build frozen or mutable typed sets over an enum with fast membership tests, set algebra, and optional Object::Proto type constraints so you can use enum values as slot types. Recent releases added the enumSet system and Object::Proto type registration, making it easy to both declare enums and work with typed sets in application code.

Chandra provides Perl bindings to the webview-c library so you can build cross‑platform desktop apps with standard web technologies like HTML, CSS and JavaScript while driving the UI from Perl. It runs on macOS, Linux and Windows and will use Edge/WebView2 on modern Windows with an automatic fallback to the legacy MSHTML engine when needed, so installing the WebView2 runtime is recommended for best results. The module offers a simple OO API to create windows, run a blocking or manual event loop, evaluate JavaScript or dispatch JS safely from callbacks, bind Perl subs to be callable from JS, inject CSS, resize or toggle fullscreen, and control common window properties. If you want more structure there is a higher‑level Chandra::App and a growing ecosystem of helpers for elements, forms, IPC, system tray, clipboard, canvas and app packaging that expose native features to web UIs. The recent 0.24 release added a reactive component system plus built‑in UI components such as a sortable, paginated table, theme support, toasts, modals, form validation and navigation widgets, making it much easier to assemble modern, interactive desktop interfaces with Perl.

Loo is a fast XS-based Perl data introspector and code deparser that gives you Data::Dumper-compatible, human-friendly output with built-in ANSI colouring and themes. It can pretty-print scalars, arrays, hashes and objects with the familiar Dump API or an OO interface that mirrors Data::Dumper options so you can control indentation, tabs, quoting, key sorting, max depth, handling of circular refs and whether code references get deparsed back to Perl source. Colouring is auto-detected from NO_COLOR, terminal status and TERM, but you can force it on or off with simple functions or configure per-element colours and themes like monokai. There is also a utility to strip ANSI escapes for plain text output. If you want a drop-in, faster alternative to Data::Dumper that adds attractive, configurable coloured dumps and the ability to reconstruct code refs for debugging and inspection, Loo is a good fit.

Test::IsAny supplies a tiny testing helper called is_any that lets you assert that a scalar result matches any value in a supplied list and integrates directly with Test::More. It is intended primarily as a teaching example showing how to write your own test function, so it is intentionally lightweight and easy to read rather than a full-featured matcher framework. Use it when you want a simple, readable way to check that a result is one of several acceptable values in your unit tests.

WWW::OpenBao is a compact Perl HTTP client for OpenBao and HashiCorp Vault that gives application code a straightforward way to talk to Vault's KV v2 secrets engine and a few basic sys endpoints. It supports reading, writing, listing and deleting KV v2 secrets, checking metadata existence, Kubernetes ServiceAccount login (it will store the returned token), and simple sys helpers like health, init, unseal and enable_engine. The module intentionally stays minimal with no caching, lease renewal or policy management, so it is a good fit if you just need to perform day-to-day secret operations from Perl rather than full Vault administration. Configure it with an endpoint, token and a KV mount (defaults to "secret"), and note that most methods croak on non-2xx responses while read_secret returns undef on a 404 to make "not found" easy to handle. This initial release was extracted from HI::Daemon and focuses on providing a tiny, pragmatic client surface.

Module::Generic is a highly practical base class for building Perl objects quickly by providing a large toolbox of ready made helpers for common tasks such as automatic getters and setters, typed accessors for numbers, booleans, datetimes, UUIDs, IPs, URIs, files and more, dynamic class and method generation via create_class, and an AUTOLOAD that maps hash keys to methods. It includes utilities for serialization and deserialization using CBOR, Sereal, Storable or JSON when those modules are installed, portable error and exception handling that prefers returning errors over dying, flexible logging and colored terminal output with TTY awareness, and a suite of object construction helpers that make nested objects and arrays easy to declare and use. Performance sensitive routines are implemented in XS when available with transparent pure Perl fallbacks so you can install without a C compiler, and the distribution also contains null objects and helpers to keep method chaining safe on error. The module aims to speed development and enforce consistent patterns, and it is conscious of threaded and mod_perl environments with global storage safeguards, however some dynamic features such as runtime symbol injection and on the fly class creation are not safe to use after threads are started so they should be performed at initialization time. If you want a single, feature rich superclass to avoid writing repetitive accessor and serialization code and to rapidly prototype structured object APIs, Module::Generic is likely to be very useful.

JQ::Lite is a pure-Perl, jq-compatible JSON query engine that gives you familiar jq-style filters and helpers without needing the jq binary or any XS compilation, making it ideal for minimal containers, CI systems, restricted servers, or air-gapped environments. You can traverse and transform JSON with dot-notation, safe optional access, array indexing and flattening, boolean filters like select(), pipe-style chaining, map/reduce/foreach helpers, and a large library of jq-like built-ins for strings, arrays, objects, and statistics, and it ships with a jq-lite CLI and an interactive REPL. The module is usable as a library via JQ::Lite->new and run_query($json, $filter), defaults to core JSON::PP but can opt into faster JSON XS modules, and exposes CLI options for decoder selection, debug logging, and function listings. If you need jq-style querying where installing native binaries is not possible, this module gives a compatible, well-tested alternative in pure Perl with stable CLI packaging. The latest 2.44 release mainly refactors path traversal helpers to centralize array index normalization and bumps the version.

RT::Extension::FormTools is an add-on for Request Tracker that lets administrators build multi-page, wizard-style ticket creation forms using a browser-based drag-and-drop UI, so users can submit structured tickets without custom coding. You pick the target queue and available custom fields, add core fields or freeform HTML blocks, and include non-persistent ShowQuestion controls to drive conditional display or requirements. The extension supports alternate routing to different queues based on form answers, optional grouping of forms, per-user and per-group visibility rights, and simple JSON export/import for moving forms between systems. Forms created with FormTools appear in RT's main and self-service interfaces and will create normal tickets, and the package also exposes Mason components and helper functions for developers who need to extend or embed forms. It is maintained by Best Practical, works with RT 6 and newer, and is distributed under the GNU GPL v2.

MCP::Run is a small base class for building MCP servers that expose a "run" tool so remote clients can execute shell commands and receive exit code, stdout, and stderr in a standardized MCP response. Subclasses implement an execute method to run the command and the base class handles tool registration, per-call overrides for working directory and timeout, optional command whitelisting, and customizable result formatting. The distribution includes a ready-made MCP::Run::Bash implementation, a Compress helper that runs a filter pipeline to trim and compress noisy command output for LLM efficiency, and convenience entry points for running as a stdio tool or installing command hooks. Recent work adds a Docker image for the compression tool so the Claude Code hook can be installed and used without a local Perl toolchain, with environment variables to select native or docker mode and to override the image, making it easy to enable output compression in environments that lack a Perl runtime.

YAML::PP is a modern, modular YAML processor for Perl that aims to fully support the YAML 1.2 spec while also offering YAML 1.1 compatibility, letting you load and dump YAML streams with one or more documents and choose schemas like Core, JSON or Failsafe. It is schema aware so it resolves types such as booleans and numbers in a standards-compliant way, can serialize Perl-specific types via a Perl schema, and offers options for handling cyclic references, duplicate keys and document headers, plus experimental preservation of key order, scalar styles and flow styles. The module exposes a friendly API and drop-in Load/Dump functions for scripts, includes utility CLI tools for debugging and highlighting, and supports plugins including a libyaml-backed parser for better performance. YAML::PP emphasizes correctness and interoperability with other languages, but the author notes that some inner APIs and preservation features remain experimental, a few rare YAML syntax cases are not yet supported, and it is generally slower than XS-based bindings.

Business::ISBN::Data is a companion data module for Business::ISBN that supplies the ISBN group and prefix ranges published by the ISBN Agency in RangeMessage.xml so your application can validate and classify ISBNs without parsing that file yourself. Business::ISBN will load this module automatically and it includes a bundled RangeMessage.xml and a built-in fallback dataset, but you can point to a different RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable or placing the file in the current directory; note you must use Business::ISBN 3.005 or later because the data structure changed to address an ISBN-13 issue. The package includes tooling and instructions for regenerating the embedded data from the official RangeMessage.xml and the source is on GitHub so you can update or contribute newer range data when accuracy is important.

HTTP::Promise is a Perl client library that makes true asynchronous HTTP requests by forking and using Promise::Me, returning promise objects you can chain with then and catch or resolve synchronously if you prefer. It supports all common HTTP methods and features like redirects, cookie jar integration, configurable SSL options, and sensible header handling while streaming large request or response bodies to memory or temporary files so you can work with very large payloads without blowing memory. The module provides helpers to build form-encoded and multipart requests, automatic content encoding negotiation, threshold and max size controls, and utilities such as prepare, simple_request, mirror, fetch, and promise combinators like all and race. It is optimized for performance with XS components, implements robust parsing and multipart support, reports errors as HTTP::Promise::Exception objects, and is thread-safe, so it is a good fit for applications that need high-throughput nonblocking HTTP interactions in Perl.

Changes is a Perl module for reading and updating "Changes" or "CHANGES" files that hold release notes and changelogs. It lets you parse an existing file or string, add, edit or remove releases and individual change lines, and write the result back to disk while preserving the original formatting of any sections you do not modify. You can customize date formatting, time zone, line wrapping, and other defaults or provide your own wrapper callback for text formatting. Errors are returned as objects rather than causing the program to die. This module is useful for module authors, packagers, and automation scripts that need reliable, programmatic editing of change logs for CPAN or other distributions without wrecking the file layout.