CPANscan

App::ghmulti is a Perl module that provides the functionality behind the ghmulti command-line tool to help you use multiple GitHub accounts with different SSH keys on the same machine. It helps manage how Git and SSH pick the right key and remote configuration so you can work with separate personal, work, or project identities without constantly reconfiguring Git. The module relies on the git command-line tool and integrates with GitHub SSH user data and remote URL parsing, so it is most relevant if you routinely push or pull across repositories tied to different GitHub accounts. For usage details see the ghmulti program documentation and the project repository, and note that git must be installed and available in your PATH.

Net::Async::SOCKS provides lightweight SOCKS5 proxy support for IO::Async by adding an extension that exposes a SOCKS_connect method on your IO::Async::Loop so you can establish TCP connections through a SOCKS5 server from asynchronous code. It is intentionally minimal and designed for simple use cases, making it easy to have your IO::Async loop open proxied connections without changing your architecture. The current implementation only supports IPv4 destination addresses and numeric ports, so it is best suited for straightforward proxying needs rather than advanced SOCKS features. If you already use IO::Async and need a small, no-fuss way to route connections through a SOCKS5 proxy, this module is a convenient option.

IO::Async::SSL adds TLS/SSL support to the IO::Async event loop by plumbing IO::Socket::SSL into IO::Async so you can make nonblocking secure client and server connections or upgrade existing sockets and streams to use TLS. It exposes high-level helpers like SSL_connect, SSL_listen and SSL_upgrade that return futures or accept callbacks, forwards any SSL_* options through to IO::Socket::SSL, and will try to auto-populate verification CA settings from IO::Socket::SSL::default_ca otherwise warning and falling back to no verification. Use this module when you need to add secure transport to an IO::Async-based program without reworking your event loop, and expect it to handle the usual interoperability and error cases while being kept up to date with routine compatibility and bug fixes.

IO::AsyncX::Sendfile is a small, proof-of-concept add-on that injects a sendfile method into IO::Async::Stream so you can stream a file to a socket without copying its contents into Perl memory first, using the kernel sendfile facility via Sys::Sendfile when available. You call it with either a filename or an open filehandle and an optional length, and it returns a Future that resolves to the number of bytes written or fails with an error and details if the send fails. It is intended as a temporary workaround until a more general async file I/O API is merged into IO::Async, so the API may change in future releases.

File::Sticker is a Perl utility for reading and writing file metadata in a consistent way and keeping that information mirrored in a database, making it easy to manage, search and update metadata across many files. It can extract metadata from files using multiple methods, add, delete or replace fields (including multi-value fields), and push or pull metadata to and from a backing database, with convenience methods for searching by tag, listing tags, finding files missing from disk, spotting files not yet in the database, and removing database entries for missing files. The module supports derived values through plugins, picks an appropriate "scribe" for different file types, and includes features for common formats such as ID3v2 tags. Recent releases added a derive-plugins system and improved handling of relative paths, including support for more than one top directory and a bug fix around relative-path derivations, so it is well suited for projects that need robust, extensible metadata management and synchronization.

Data::Hash::Patch::Smart is a small Perl utility for applying structured, JSON-Pointer-like patches to nested Perl data structures, letting you add, change, or remove values with path expressions and wildcards rather than hand-editing hashes and arrays. It supports both ordered and unordered array semantics, structural wildcards that match multiple children, an option to auto-create missing intermediate containers, a strict mode that validates paths and indices, and cycle-safe wildcard traversal, and it returns a deep-cloned copy with the changes applied. Its main uses are configuration management, data migrations, and round-tripping diffs and patches, and it is driven by a simple patch( $data, \@changes, %opts ) call. This initial CPAN release documents and tests those features and adds support for wildcards, unordered arrays, strict validation, create_missing behavior, and cycle-safe traversal.

Modern::Perl::Prelude is a small lexical prelude that gives you a ready set of modern Perl conveniences while staying runnable on Perl 5.30 and later. It enables strict and warnings, brings features like say, state and fc into the caller, provides try/catch compatibility and imports handy functions such as blessed, refaddr, reftype, trim, ceil, floor, true/false and weakref helpers so you can write cleaner, more idiomatic code without hand-rolling boilerplate. You can opt into source-level UTF-8 or into backported class and defer syntax with the -utf8, -class and -defer flags and those extra compatibility layers are lazy-loaded so they only load when you ask for them. no Modern::Perl::Prelude reliably turns off the native pragmata it manages but backported feature modules are treated as import-only and may not be symmetrically undone. Recent updates added the optional -class and -defer imports and improved unimport behavior while keeping default behavior unchanged.

Bitcoin::Crypto is a Perl library that provides the cryptographic building blocks and utilities needed to work with Bitcoin keys, mnemonics, address formats, scripts, transactions, PSBTs, blocks and UTXOs. It supports generating BIP39 mnemonics and deriving BIP32/BIP44 extended keys and also exposes lower level primitives for public and private keys, signatures, encodings and script handling so you can create, parse and manipulate raw Bitcoin data structures. The distribution offers convenient shortcut imports that load the relevant object classes on demand, making it easy to instantiate extprv/extpub, basic keys, script trees, transactions and PSBTs without boilerplate. This module is a good fit for Perl developers building wallets, signing tools, transaction constructors or any application that needs direct control over Bitcoin cryptography and data formats. For network RPC work see Bitcoin::RPC::Client and consult Bitcoin::Crypto::Manual for detailed usage.

Config::Model::Itself is a helper library for people who build and maintain Config::Model schemas; it gives you a programmatic way to load, edit and save the model files that describe the structure and rules of configuration data. The module exposes an object for reading all model files from a directory tree, filtering or force-loading broken files, writing models back while preserving layout, emitting model plugins, and producing Graphviz dot diagrams and class/element listings. It is useful if you create, test or distribute Config::Model-based configuration schemas or want to drive the model editor from scripts or the cme tool and its Tk or Curses UIs. One known limitation is that test menu entries are generated from the application list and cannot be updated without restarting cme. Recent work keeps compatibility with evolving Config::Model and UI components and release 2.028 fixes a backend detection problem introduced in 2.027.

Net::Async::HTTP is an asynchronous HTTP client built for IO::Async that returns Future objects and also supports callback-style usage, making it ideal for event‑driven Perl programs that need nonblocking HTTP I/O. It manages multiple concurrent connections with configurable per‑host pooling and optional HTTP/1.1 pipelining, supports streaming request and response bodies, per‑request and stall timeouts, cookie jars, and optional SSL when IO::Async::SSL is available. The module also supports proxies including SOCKS5 and UNIX socket proxies, can optionally decode compressed response bodies when the right decompression modules are installed, and provides convenience methods such as GET, POST, PUT, PATCH and DELETE for common operations. Recent releases added support for proxying via UNIX sockets and a DELETE convenience method and continue to refine documentation and tests.

Test2::Harness is the powerful backend that runs and processes Test2/TAP test suites, providing the orchestration, event parsing, logging, parallel job scheduling, resource management and plugin hooks that higher-level tools need to run tests reliably at scale. It is not a user-facing command line tool by itself but is the engine behind App::Yath, which provides the interactive and command-driven UI most people use. Over the years it has gained features for persistent runners, smarter reloading, coverage and rerun support, shared job slots and advanced scheduling, while focusing on robust handling of TAP/Test2 events and integrator-friendly hooks. Recent maintenance adds a --no-final-table display option and fixes for several edge-case bugs to improve output control and stability.

Imager::QRCode is a small Perl wrapper that generates QR Code images by combining the libqrencode library with the Imager image toolkit. You create a generator object or call the exportable plot_qrcode function, supply the text to encode and a few options such as module size, margin, error-correction level, symbol version, encoding mode and case sensitivity, and you get back an Imager object ready to write to GIF, PNG or other formats. The module supports kanji mode (encoded as Shift-JIS) and an 8-bit mode that lets you embed UTF-8 data, and you can control foreground and background colors via Imager::Color. It requires libqrencode 2.0.0 or newer and has seen updates to support newer libqrencode releases and a 2016 bugfix to handle defined-but-zero text values, making it a good choice if you already use Imager and need simple, configurable QR generation in Perl.

DBIx::Class::MockData generates realistic test rows for DBIx::Class schemas by inspecting a connected Schema, resolving foreign key insertion order, and creating values that match each column's declared data_type. It offers chainable actions to deploy or wipe test schemas, perform dry runs, and populate tables while honoring nullability and unique constraints, and it can target or skip specific tables. You can control the volume and shape of data with a global row count, per-table row counts, custom per-column generator callbacks, and an optional seed for reproducible output. The 0.04 release added rows_per_table and generators, switched to bulk insert for much faster population, and improved salt and unique-constraint handling so reproducible runs stay distinct and safe for parallel testing. Connection and schema loading are left to the caller and the distribution includes a dbic-mockdata CLI for scripting.

Amazon::Sites is a lightweight Perl class that models Amazon's regional storefronts and makes it easy to work with country codes, domains, currencies and affiliate codes. You create an Amazon::Sites object and can get lists or hashes of site objects, fetch a single site by its two-letter code, or obtain the canonical two-letter codes for all supported markets. The constructor lets you restrict the sites with include or exclude lists and you can supply associate codes so generated links include your affiliate tracking. It also builds per-country ASIN URLs for easy cross-market linking, which is handy for building localized links, feeds, or affiliate tools that must handle multiple Amazon locales.

Alien::nghttp2 is a Perl Alien module that makes the nghttp2 HTTP/2 C library available to Perl build scripts. It will detect a system installation or download and build nghttp2 for you so downstream modules can compile and link against it. You call it from ExtUtils::MakeMaker or Alien::Build to obtain compiler and linker flags via methods such as cflags and libs. It also exposes dynamic_libs to list runtime library paths and install_type to report whether the library is from the system or built locally. Use this module when you need the native nghttp2 implementation for Perl extensions so you do not have to install or configure the HTTP/2 C library manually.

Data::Hash::Diff::Smart is a modern, recursive diff engine for Perl data structures that produces a stable, structured list of change operations for nested hashes, arrays, scalars and objects and can render those changes as human-readable text, JSON, YAML or Test2 diagnostics. It is configurable with ignore rules, path-specific comparator callbacks and multiple array diff strategies including index-based comparison, minimal diffs via LCS and unordered multiset mode, making it useful for generating readable diffs, producing test diagnostics or creating machine-readable change sets for configuration and data migration. This is the initial 0.01 release and the distribution is provided as-is with a licensing note that personal single-user use is under GPL2 while other uses require contacting the author for a licence.

Business::ISBN::Data is a support module that supplies the ISBN range data used by Business::ISBN, so you normally do not load it directly. It bundles the ISBN RangeMessage.xml from the ISBN Agency and will automatically be loaded by Business::ISBN, but you can point the module at a different RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable before loading Business::ISBN. If no external file is available it falls back to embedded data or looks in the current directory, though those fallbacks may be older than the official feed. Note that Business::ISBN 3.005 or later is required because the data structure changed to fix an ISBN-13 issue. The source and updates are on GitHub, so you can fetch newer range files or contribute fixes if you need the latest allocation information.

mdee (em-dee) is a terminal-focused, multi-column Markdown viewer that makes raw Markdown easy to read by applying syntax highlighting, hiding most markup characters by default, wrapping long list items, and aligning tables with ANSI-aware formatting. It can produce paged n-up output or simpler pager/filter styles, keeps links clickable via OSC 8 when the terminal supports it, and offers light/dark themes plus fine-grained color and element overrides so you can tune headings, code, emphasis, and other elements. The tool is a small Bash pipeline that coordinates App::Greple::md, ansifold, ansicolumn, and nup to perform highlighting, folding, table formatting, and layout rather than converting Markdown to another format. It intentionally does not reflow paragraphs and has a few limitations such as no multi-line emphasis, no reference-style links, HTML comments are only matched at line start, and OSC 8 hyperlinks require terminal and pager support. The recent 1.07 release added the "nomark" theme to the default set for a cleaner reading experience and adjusted pagination behavior (requires App::nup 1.07).

Dist::Zilla::PluginBundle::Author::DBOOK is a ready-made collection of Dist::Zilla plugins that codifies Dan Book's preferred workflow for building and releasing Perl distributions. It wires together metadata creation, README and CONTRIBUTING generation from POD, dependency extraction from cpanfile or prereqs files, Git-based commit, tag and release handling, version bumping, and test and packaging steps so you can automate consistent releases with minimal setup. The bundle assumes your repo contains a prereqs file and a populated Changes entry and a sensible .gitignore, and it can copy useful files like INSTALL, LICENSE, Makefile.PL and META.json into the repository during regenerate or release. You can tweak which installer plugin to use, enable optional pod tests, slice or remove individual subplugins, and run a dry run of the whole release process with FAKE_RELEASE=1. Use this if you want a well-integrated, opinionated Dist::Zilla configuration that saves time and reduces release friction.

Image::PNG::Libpng is a mature Perl wrapper around the C libpng library that lets you read, write and manipulate PNG images from Perl using both a direct libpng-like API and higher-level convenience helpers. It exposes most libpng functionality in a Perl-friendly way so you can read files or scalars, write to files or scalars, copy PNG structures, inspect and set the IHDR and all common chunks (text, palette, gAMA, tIME, tRNS and many extensions), apply built-in libpng transforms, tune compression and compare image data. The module does not bundle libpng, so you must have a compatible libpng installed and some features or tests depend on the libpng version you compile against. A number of lower-level or deprecated libpng functions are intentionally omitted and the documentation flags several untested or version-dependent routines, but everyday tasks like reading image rows, changing metadata, stripping or handling alpha, and round-trip chunk copying are well supported. It is actively maintained and stable for production use, with the most recent release 0.60 (2026-03-17) providing a bug fix to keep things reliable.

CPAN::Maker is a command line utility for packaging a Perl project as a CPAN distribution. It reads a YAML "buildspec" that describes your module layout, tests, scripts and extra files, discovers dependencies (using scandeps or Module::ScanDeps::Static), generates a Makefile.PL and can invoke a companion bash script to assemble a release tarball. You can also run it without a buildspec to emit a Makefile.PL for manual tweaking. It supports control over author, abstract, required/test/build dependencies, minimum Perl version, provided modules, postambles and a variety of packaging paths so you can tailor what gets included. If you publish modules to CPAN or need a repeatable way to produce CPAN-ready tarballs, this tool automates the common steps while letting you tweak the inputs. The recent 1.7.0 release added a recommends option to record optional/recommended dependencies for installers that support them.

cpanminus, or cpanm, is a tiny, dependency-free command line tool for fetching, unpacking, building and installing Perl modules from CPAN with zero configuration and minimal memory usage. It can bootstrap itself via a simple curl one-liner or be installed from distribution packages, or used as a standalone executable, and it respects local::lib, perlbrew and plenv installs or will automatically create a per-user install path when you lack system permissions. cpanm uses the CPAN Meta DB and MetaCPAN APIs to locate distributions, unpacks temporary files under ~/.cpanm, and relies only on standard system tools such as tar, make and a C compiler when building XS modules. It intentionally keeps features to a minimum, so it does not provide CPAN testers reporting, RPM packaging, outdated-module listings or interactive build handling, and it can struggle with distributions that prompt for input or use nonstandard VERSION values. If you want a fast, simple installer for adding modules to a Perl environment without the complexity of CPAN or CPANPLUS, cpanm is an excellent choice.

PAGI::Middleware::Session::Store::Cookie provides a stateless session backend that encrypts and authenticates session data into a cookie so no server-side storage is required. You create it with a secret key and use its set method to produce an encrypted blob to put in the response cookie and its get method to decode that blob back into a session hash. Encryption uses AES-256-GCM with the key derived from your secret and a random IV so the same data looks different each time. This makes it a good fit when you want simple, serverless session management and can keep session payloads small. Be aware of practical limits though because browsers cap cookies at around 4KB and large sessions will fail. Also revoking a client session still requires server-side state such as a blocklist. On systems without /dev/urandom the module falls back to a weaker random source and emits a warning, and installing Crypt::URandom is recommended.

PAGI is an async web application specification and toolkit for Perl that modernizes PSGI for evented servers and supports HTTP/1.1, WebSocket, and Server-Sent Events. It defines a simple async app signature of async sub { my ($scope, $receive, $send) = @_; ... } so servers, frameworks, and apps can interoperate while giving you helpers like a reference PAGI::Server, request/response wrappers, WebSocket and SSE helpers, routers, middleware and bundled apps for static files, health checks and more. The spec itself is stable and intended for developers who want to write loop-agnostic, async-capable Perl services, but the distribution is beta so some convenience modules may evolve and the reference server is not yet battle tested so running behind a reverse proxy is recommended for production. Recent work focuses on hardening and usability, including security fixes for transfer-encoding and header validation, improved TLS 1.3 support, and a refactored session middleware with pluggable state and store backends. Requirements include Perl 5.18+, an event loop like IO::Async for the server, and Future::AsyncAwait for async/await support.

Data::Path::XS is a small, C-backed Perl module that makes it easy and fast to read, write, delete, and test values deep inside nested hashes and arrays using slash-separated paths. It offers four APIs to suit different needs: a string-based API for general use, an arrayref API for components that include special characters or empty keys, a compiled-path API you can reuse for max speed, and a keywords API that compiles to very low-overhead ops for hot code paths. pathset will autovivify intermediate containers and will replace non-reference scalars as needed while pathget and pathexists do not autovivify, numeric components map to array indices (including negative indices) and numeric strings with leading zeros or very large integers are treated as hash keys, so use the array API when keys contain slashes or empty strings. The module is designed for single-threaded use and compiled path objects should not be shared across threads. It is substantially faster than pure-Perl solutions for deep access, and the recent 0.02 update fixed a keyword pathset void-context overhead issue and improved validation, documentation, and tests.

EAI::Wrap is a Perl framework for building enterprise integration and ETL jobs without writing low level plumbing code. It lets you declare site, common and per-load settings in simple hashes and then run a standard extract, transform and load loop that handles FTP/SFTP transfers, file parsing (CSV, Excel, XML), database reads and writes, logging, retries, history and error notifications. The module wires together Log4perl, DBI/ODBC, Net::SFTP::Foreign and common file parsers and writers so you can concentrate on mapping and business rules rather than connection and file handling. It supports environment-aware configuration, command line overrides, redo/archive handling and hooks for custom field or line processing, making it useful for ops teams and developers who need reliable, repeatable automated data exchanges between systems.

IO::Compress is the umbrella module in the IO-Compress distribution that exposes Perl-friendly facilities for compressing and decompressing streams and files across many formats such as gzip, zip (including Zip64), bzip2, xz, lzma and zstd. This file is a stub and contains no implementation code, so in practice you use the format-specific modules like IO::Compress::Gzip, IO::Compress::Zip or the IO::Uncompress::* family and IO::Uncompress::AnyUncompress for automatic format detection. The distribution emphasizes robust, interoperable handling of compressed data in both one‑shot and streaming scenarios and is actively maintained by Paul Marquess with regular fixes, new format support and tooling updates. Recent changes include adding this stub module, refreshing bundled utilities such as zipdetails and a number of small fixes and consistency updates through the 2026 releases.

MIDI::RtController::Filter::Tonal is a collection of ready-made tonal filters you can plug into MIDI::RtController to turn incoming note events into musical material like pedal tones, diatonic chords, delayed echoes, offset notes, arpeggios and walking melodies. Each filter is configurable with musical parameters such as pedal note, delay time, feedback, velocity, key, scale, intervals and arpeggiation type so you can shape behavior for live performance or generative accompaniment without writing low-level MIDI handling. Filters are used as callbacks on a controller instance and return a boolean to control further processing, and a helper function lets you declaratively add lists of filters to controllers. The recent 0.0500 release adds a simple single_tone filter for triggering individual notes. This module is handy if you want quick, musically informed MIDI processing for performance, composition experiments or automated backing parts.

Alien::libwebsockets helps Perl distributions find or build the libwebsockets C library so you can link it into XS or other compiled code. The module will use a system installation if one is available or download and compile libwebsockets from source with libev, SSL, zlib, and permessage-deflate extension support, and it exposes compiler flags and linker flags for use with ExtUtils::MakeMaker. It also provides a has_extensions method to detect permessage-deflate support, though that detection uses symbol inspection and is reliable only for the module's own shared installs and may return false for untracked system libraries. The initial release bundles libwebsockets 4.3.3 and is intended to make it easier to consume libwebsockets from Perl distributions.

NBI::Slurm is a Perl toolkit for preparing and submitting jobs to SLURM-based HPC clusters. It gives you NBI::Job to model a job and NBI::Opts to build SLURM options such as queue, threads, memory, runtime and output file paths, and to generate the job script header. You can submit jobs programmatically, inspect queues and squeue availability, run system commands while capturing stdout and stderr, and use the accompanying command-line utilities for common workflows. Recent releases added an energy-aware scheduler module NBI::EcoScheduler, support for SLURM --begin via start_time and start_date, and --eco/--no-eco flags with configurable eco windows, making it easy to defer work to low-energy slots by default. The package is actively maintained and distributed under the MIT license.