CPANscan

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.

Log::Any is a tiny, dependency-light logging façade for Perl that lets CPAN modules produce log messages without forcing applications to pick a logging backend. Module authors use a simple logger object (for example via use Log::Any '$log') and call familiar methods like debug, info, warn, and error or their printf-style variants, and applications choose where those messages go by configuring Log::Any::Adapter to route logs to Log::Log4perl, Log::Dispatch, files, syslog, or other consumers. It supports structured and contextual logging, standard log levels and aliases, level checks for efficiency, and a null default so libraries can safely emit logs even when an application has not configured a consumer. The project is deliberately minimal to encourage wide adoption and avoid adding heavy dependencies, and recent maintenance releases fixed test issues on Windows and cleaned up documentation and a few adapter-related bugs. If you write libraries that should be polite about logging or build applications that want flexible control over where logs end up, Log::Any is a relevant, low-friction choice.

Syntax::Feature::With provides a lightweight way to emulate Pascal's with statement in Perl by temporarily aliasing hash entries to lexical variables inside a coderef, so you can read and write %hash entries simply by using lexicals declared in the outer scope. It uses PadWalker and requires no XS, parser hooks, or syntax changes, and supports nested with() calls and a small convenience wrapper with_hash for cleaner call sites. Built-in modes let you enforce correctness with -strict where every hash key must have a matching declared lexical, debug to print which keys were aliased or ignored, and trace to show entry and exit with nesting depth. Limitations include the need for outer-scope lexicals, only hashrefs are supported, and only keys matching /^[A-Za-z_]\w*$/ are eligible. The distribution is hosted on GitHub and this 0.01 release is the initial draft, and licensing is GPL2 for personal single-user use while other uses should contact the author for licensing.

Plack::App::DirectoryIndex is a small PSGI/Plack application that serves static files from a document root and provides Apache-style directory listings while automatically serving a default index file such as index.html. It is configured with a root directory and an optional dir_index filename, and can render directory listings with optional Font Awesome icons and an enhanced CSS theme for a prettier appearance. Use it when you need a simple standalone static file server for development or lightweight hosting that falls back to an index file before showing a listing. If you do not want automatic index files you can use Plack::App::Directory or Plack::App::File instead.

WebServer::DirIndex reads a filesystem directory and builds the data needed to render a web server directory listing, and it can also produce a ready-to-serve HTML index page. You create an object with the directory path and its URL and control presentation with the pretty and icons options, then inspect entries via files (each a WebServer::DirIndex::File) or call to_html to get a complete HTML page. The module can add MIME-aware Font Awesome icons and an enhanced CSS theme for a more attractive listing, or produce a plain listing if you disable icons. Note that as of 0.1.0 the pretty option is set when constructing the object rather than when calling to_html and enabling pretty now also turns on icons unless you explicitly pass icons => 0; the distribution targets modern Perls (Perl 5.26+). This is a lightweight, easy way to generate customizable directory indexes for static sites or simple web applications.

MetaCPAN::API is a now-deprecated Perl client that wraps the MetaCPAN REST API and gave Perl programs simple, DWIM-style methods to look up authors, releases, modules and other CPAN metadata while also exposing low-level fetch and post helpers. It uses HTTP::Tiny as its user agent by default, lets you point it at a custom base_url (defaulting to https://fastapi.metacpan.org/v1) and pass ua arguments, and can be used with cached user agents for offline or faster access. This module has been superseded and rewritten as MetaCPAN::Client, so you should not start new code with MetaCPAN::API; use MetaCPAN::Client instead. For historical users, the recent 2026 update fixed tests against the current MetaCPAN API, improved error messages by including response content, and updated author tooling.

DBD::Mock::Session::GenerateFixtures captures real DBI interactions and produces reusable fixtures so you can run your tests against a DBD::Mock::Session without touching the live database. You can generate fixtures from a real DBI handle, load them from a JSON file, or pass a data structure directly, then obtain a mocked DBI handle that overrides prepare, execute, fetch variants and transaction methods so application code and ORMs like Rose::DB can run unmodified. The module exposes helper methods to get the mocked dbh and the override object and to restore original DBI behavior when testing is finished. Recent updates added MySQL and Rose::DB support, improved cursor management, mocked bind_params_inout, and better handling of named parameters and fetch behavior to make the mocks more accurate and reliable.

Noise is a pure-Perl implementation of the Noise Protocol Framework that provides the building blocks for authenticated key exchange and encrypted transports, implementing core primitives like SymmetricState and CipherState and a default recipe of Noise_XX_25519_ChaChaPoly_SHA256. It handles transcript hashing, key mixing, ChaCha20-Poly1305 encryption and nonce management, and gives a simple API for performing handshake message writes and reads, encrypting/decrypting payloads as part of the handshake, and deriving transport keys with split_for_transport, so you can integrate Noise handshakes into custom network protocols. This module is aimed at developers who need a compact, readable implementation rather than a full application wrapper and it notes that higher-level modules are available for specific integrations. The recent 0.0.2 release added the ability to expose static and ephemeral key material, making it easier to inspect or reuse keys during testing and advanced flows.

App::CPAN::Dependents is a lightweight tool and library for finding which CPAN distributions depend on a given module or distribution. It provides the find_all_dependents function and a cpan-dependents command line wrapper that query the MetaCPAN API recursively to build a list of reverse dependencies, with options to include recommends, suggests, or develop-phase prerequisites and to supply a custom MetaCPAN::Client or HTTP::Tiny object for network control. Because it relies on live MetaCPAN queries it needs internet access and can take some time to complete, it will die on HTTP errors, and it only finds prerequisites explicitly listed in distribution metadata so dynamic or unindexed modules are not captured. A recent fix updates the MetaCPAN search filtering to work with newer Elasticsearch backends.

Async::Redis is an asynchronous Redis client for Perl built on Future::IO that gives you a modern non-blocking API with async/await support via Future::AsyncAwait. It works with multiple event loop backends, supports TLS, automatic reconnect with backoff, connection pooling, pipelining and auto-pipelining, transactions, PubSub with replay on reconnect, and efficient Lua scripting with automatic EVALSHA optimizations. The module is fork-safe and includes OpenTelemetry hooks for tracing and metrics, plus safe concurrent command handling on a single connection to avoid response-matching races. Note that Async::Redis no longer configures Future::IO itself so your application must choose and load the event loop implementation at startup. Recent updates fixed socket close ordering and concurrency issues to make disconnects and parallel command handling more robust. This module is a good fit if you need a fully asynchronous, production-ready Redis client that integrates with existing Perl event loops and high-throughput services.

SPVM is a statically typed language with Perl-like syntax that aims to give Perl developers a familiar feel together with compiled, high-performance execution. You can run SPVM scripts directly or compile them ahead-of-time or via JIT to produce standalone executables, and the runtime supports native threads and goroutine-style concurrency. The project offers C and C++ bindings and an exchange API so Perl programs can call SPVM methods and SPVM code can leverage Perl standard functions and modules. Tooling covers building, distribution and dependency analysis, and the project includes extensive tutorials and examples. SPVM is still pre-1.0 and does not yet guarantee backward compatibility, so expect the language and tooling to evolve.

Lilith is a lightweight Perl tool for ingesting and querying EVE JSON alerts from Suricata, Sagan, and CAPE into a PostgreSQL database using DBI. It can create the required tables, import multiple EVE files by instance, and run as a long‑running processor that feeds alerts into the database while letting you ignore selected SIDs or classes. The module also exposes a convenient search API with many filters for IPs, ports, signatures, hashes and other fields, plus helper routines for producing short SNMP class names, so you can build dashboards or forensic queries without writing raw SQL. Configuration is simple and scriptable via DSN, user/password and TOML files. In the 1.0.0 release the author cleaned up the codebase, removed changeable table names and some legacy "baphomet" features, and added a Lilith_color_enable environment flag to control colored output.

POSIX::RT::SharedMem gives Perl programs a straightforward way to use POSIX named shared memory by mapping a shared memory object into a Perl variable so you can read and write it with normal string operations as long as you do not change its length. You call shared_open to attach to or create a named object such as "/somename" using familiar open-style modes and optional parameters like size, permissions, offset and extra flags, and you get back a filehandle suitable for stat, chmod and chown while using File::Map to access the contents as a scalar. shared_unlink removes the name from the namespace but the data remains until all processes close the object. This module is a simple, portable choice for exchanging data between unrelated processes and is generally preferable to SysV shared memory unless you need SysV compatibility.

Dist::Build is a modern, extensible Build.PL framework for packaging and building Perl distributions that focuses on building and installation rather than authoring tools. It uses an internal build graph so you can combine customizations cleanly and add features by dropping small planner scripts and calling load_extension, for example to install sharedir data or to compile XS code with add_xs. A rich plugin set supports common needs such as compiling XS modules, linking to Alien libraries, importing/exporting headers and flags, reading pkg-config, writing constants, and evaluating dynamic prerequisites. The planner exposes useful delegates for metadata, install paths and platform checks so build scripts can make informed decisions without low-level plumbing. Recent updates continue to improve XS support, most notably adding support for try_find_standard_for in the XS::Conf component to better handle language standard detection during compilation.

ExtUtils::Builder::Compiler is a small compatibility layer that presents a uniform interface to different C and C++ compilers so Perl extensions and native helpers can be built consistently across platforms. It is normally consumed by higher-level portability code such as ExtUtils::Builder::Autodetect::C rather than invoked directly, and provides methods to add include directories and preprocessor defines and to compile source files into object or executable targets. The module hides platform and compiler differences (MSVC, GCC, etc.) and integrates with the ExtUtils::Builder toolchain so XS authors and build tools can drive compilation without hand-coding many platform-specific flags. Recent maintenance work improves C++ support and module loading order, and the author has marked the ParseXS helper functions as deprecated.

SQL::Wizard is a Perl library for building SQL programmatically by composing expression trees and rendering them only when you call to_sql, which returns a SQL string with "?" placeholders and the correct bind values for DBI. It treats everything as an expression so columns, functions, CASEs, subqueries, joins, window functions, CTEs, unions and more can be nested freely, and its modifier methods are immutable so you can build a base query and derive many variants without side effects. Plain Perl values become bound parameters by default to reduce injection risk while val, col and raw let you control binding or inject literal SQL when necessary. The API follows familiar SQL::Abstract-style WHERE syntax and adds conveniences like operator overloading for arithmetic, ON CONFLICT and ON DUPLICATE handling for upserts, RETURNING, and both inline and named window specifications. Output is currently standard ANSI SQL with a reserved dialect option for future tweaks. Use SQL::Wizard when you want readable, composable, and testable SQL generation in Perl with no non-core dependencies.

Term::TablePrint is a small utility for printing and interactively browsing tabular data in a terminal, taking a reference to an array of arrays where the first row holds column names and the rest are data rows. It displays a movable cursor for row selection, supports keyboard navigation like arrows, page up/down, home/end, and a regex search prompt with Ctrl-F, and can either jump to the header or "expand" a row so each column is shown on its own line. The module automatically paginates and adapts column widths to the terminal, offers options for color, column selection, whitespace squashing, binary-data handling, numeric formatting and truncation, and a progress indicator for large datasets. You can call it procedurally via print_table or instantiate an object for repeated use. It requires decoded strings, a matching STDOUT encoding layer and Perl 5.16.0 or newer. Recent releases focus on code refactoring and stability with the latest v0.177 fixing an undefined-value bug in single-row printing and updating dependency version requirements.