CPANscan

App::sdif is a small toolkit of command line utilities for making diffs easier to read and track, centered on sdif which prints unified diffs in a clear side-by-side layout. The companion cdif adds visual highlighting to show changed words or characters so you can spot edits at a glance, and watchdiff repeatedly runs a command and refreshes the output while emphasizing only the modified parts. It is designed to be used as a pager for git or as a standalone viewer, supports optional tokenizers like mecab to improve word-level comparison, and can be installed from CPAN.

Acme::Matrix is a playful Perl module that renders a Matrix-style "digital rain" of characters in your terminal for demos or desktop fun. You use it by loading the module and calling Acme::Matrix->start() to begin an animated stream of characters, including Unicode glyphs, so it is good for visual effects and novelty scripts rather than production tasks. The distribution is small and permissively licensed under the Artistic License 2.0. Be aware the packaged documentation contains a POD encoding warning about non-ASCII characters so you may encounter UTF-8-related messages depending on your locale. Bugs and feature requests are tracked on CPAN's RT system.

Medusa is a lightweight Perl module that adds automatic auditing to subroutines by tagging them with the :Audit attribute. When a tagged routine runs, Medusa records the call with its arguments and the return values, which helps with debugging, compliance tracking, and understanding data flow without changing your business logic. You can control where and how messages are written by setting import options such as LOG_LEVEL and LOG_FILE or by supplying a custom logger class that provides a constructor and error/info/debug methods. This is the initial 0.01 release and provides a simple, non‑intrusive way to instrument your code.

PDL::Graphics::PLplot brings the mature PLplot graphics library into Perl's PDL ecosystem so you can make publication-quality 2D and surface plots directly from PDL ndarrays. It provides a perlish, object oriented front end with high-level routines like xyplot, shadeplot, histogram, bargraph, stripplots and colorkey plus access to the full low-level PLplot C API when you need it. You can target many output devices including PNG and PostScript, draw onto in-memory PDL images, control palettes, symbols, line styles, viewports and axis labeling, and supply custom coordinate transforms or label callbacks for maps and irregular grids. The module is aimed at PDL users who need versatile plotting from arrays without leaving Perl and it handles bad-value data in many plotting routines. Note that PLplot 5.15 or later is recommended for full support and recent releases include quality fixes and a perldl demo while requiring PDL 2.083 or newer.

PDL::LinearAlgebra is a Perl/PDL front end that brings a broad set of BLAS and LAPACK-powered matrix routines into PDL, making it easy to do SVD, eigenproblems, factorizations, inverses, condition numbers, least-squares and many other linear-algebra operations on PDL ndarrays. It dispatches to Real and Complex implementations under the hood and handles the column-major conventions of LAPACK by transposing where needed, so it is a convenient choice for Perl developers who need reliable, high-level matrix tools without reimplementing numerical algorithms. If you need the absolute lowest-level or tuned behavior you can call PDL::LinearAlgebra::Real or ::Complex directly, and note that recent releases moved the module to rely on PDL's native complex support rather than PDL::Complex and made some return-signature changes in 0.43 that may affect code expecting the old outputs.

Test::Most::Explain improves Perl test failure output by replacing Test::More's terse "got/expected" lines with a structured, human-readable diff and actionable hints. When loaded it wraps Test::Builder::diag so existing tests like is_deeply automatically yield richer explanations, and you can also call explain($got, $exp) yourself to get a descriptive string. The explain routine handles scalars, arrays, hashes, blessed references and mixed structures, highlights things like missing keys, differing array lengths, whitespace or case-only differences, and pinpoints the first differing character in scalars, while always returning a string and never dying. The module is designed to make deep-structure failures easier to understand without changing your tests or adding heavy dependencies, but it is provided as-is without warranty and its licence places restrictions on commercial use so check the terms before deploying in non-personal projects.

Tree::MultiNode provides a lightweight, ordered tree structure for Perl in which each node holds a key, a value, and an ordered list of children, making it handy for modeling hierarchical data such as parent/child relationships in databases or building nested structures by recursion. You create a Tree and one or more Handle objects that act like pointers into the tree so you can move up, down, and between siblings without copying data. Handles let you read and write node keys and values, add or remove children (including inserting at a given position), inspect child keys and positions, and recursively visit nodes with traverse or otraverse for object methods. The module preserves child order and supports cloning nodes and attaching existing Node or Tree objects via a recently added add_child_node helper that currently needs more documentation and tests. A debug flag is available for diagnostics and bug reports are managed through the project issue tracker.

PlackX::Framework is a lightweight, opinionated wrapper around Plack that provides a simple, minimal framework for PSGI web applications. It auto-loads or auto-creates app-specific subclasses such as Handler, Request, Response and Router, exports an app() function that returns a PSGI code reference, and offers a small router DSL plus conveniences like a per-request stash and a flash cookie for one-time messages. Optional components let you enable configuration, template toolkit integration, and an enhanced URI helper, while the router uses Router::Boom under the hood and can be swapped or extended. The emphasis is on small memory footprint and fast startup compared with larger frameworks, and it is designed to be easy to override by subclassing. The project is considered experimental or alpha, but it is suitable when you want a compact, flexible alternative to heavier Perl web frameworks.

Perl::Critic::PJCJ is a small set of Perl::Critic rules that help teams keep Perl code consistent by enforcing quoting conventions and manageable line lengths. The quoting policy encourages simpler, less punctuation-heavy forms, prefers interpolated strings when sensible, and standardizes delimiter choices so string usage is uniform across a codebase. The line-length policy flags lines longer than a configurable limit (default 80 characters) and can be tuned with exemptions for things like long package declarations or URLs, with support for per-file overrides via .gitattributes. Recent updates fixed a false positive for escaped backslashes in double-quoted strings and added the .gitattributes-based per-file override feature to make integration with existing projects and git workflows easier.

Net::Daemon is an abstract base class that makes it easy to build portable network server daemons in Perl by handling common boilerplate such as command line parsing, config files, socket binding, client acceptance and authorization, logging to syslog or the Windows event log, privilege dropping and optional chrooting, and per-connection lifecycle management via a Clone/Run pattern. It supports multiple concurrency modes so it works with ithreads, per-connection fork, preforked child processes or single-connection operation, and offers configurable features like client access masks, loop timeouts and pidfiles. The design lets you override only the methods you need, so you can quickly create robust servers without reimplementing standard daemon tasks. The author notes some historical issues with Sys::Syslog on Unix but otherwise the module is a practical starting point for portable Perl daemons.

PDL::Fit::Levmar brings the Levenberg‑Marquardt non‑linear least‑squares solver liblevmar into the Perl/PDL world so you can fit models or solve optimization problems from Perl with good performance and flexible options. It accepts model functions written as Perl subroutines for ease of use, or in a small lpp DSL that auto‑generates and compiles C for much faster execution, and it also accepts pure C functions. The interface is broadcast‑aware, supports analytic or numeric Jacobians, returns fitted parameters, covariance and diagnostics in a result hash, and offers box, linear equality and inequality constraints and parameter fixing when built with LAPACK/BLAS. The bundled C library is reentrant and intended to work in threaded programs though multithreading is not heavily tested. You should be aware that some constrained features require LAPACK at build time and there have been occasional quirks around broadcasting and inequality workspaces that the author notes. Recent updates focus on documentation and a build fix that avoids modern compiler problems with finite(), so this is a mature, actively maintained choice if you need robust non‑linear fitting inside Perl and PDL.

PDL::GSL provides a bridge between the Perl Data Language and the GNU Scientific Library so you can call robust, high performance numerical routines from Perl arrays. It exposes GSL functionality organized into modules for cumulative distribution functions, differentiation, numerical integration, interpolation, linear algebra, multidimensional root finding, random number generation, and special functions, plus a statistics distribution helper. If you work with PDL for data analysis or scientific computing and need tested algorithms from GSL without leaving Perl, this module makes those routines available on PDL vectors and matrices.

Sys::Mmap lets Perl programs map files or anonymous shared memory directly into Perl scalar variables by using the operating system mmap facility, so you can treat large files or shared regions like normal strings without copying the whole contents into process memory. It supports both a safer tied interface via Sys::Mmap->new, which will open and grow files as needed and makes substring assignments simple and predictable, and a lower-level mmap/hardwire interface for more control, with the usual cautions about avoiding implicit Perl copies and using substr for in-place writes. The module exports the usual mmap constants such as MAP_SHARED, MAP_PRIVATE and MAP_ANON and protection flags like PROT_READ and PROT_WRITE, and is most useful on POSIX systems where memory mappings can be shared between threads or forked children. Historically some misuse could cause crashes when regions were unmapped or variables reallocated, but recent updates (v0.21) fix a crash with nonzero offsets, correct length inference when len=0 with an offset, and repair tied DESTROY munmap failures while clarifying offset and page alignment behavior in the docs, making the interface more robust.

PDL::Slatec is a now-deprecated bridge between PDL and selected LINPACK/EISPACK/SLATEC numerical routines that provides handy tools for matrix algebra, eigenvalue problems, singular value decomposition, determinants and inverses, FFT and inverse FFT, and polynomial fitting and evaluation. It was useful when you needed direct access to those classic Fortran routines or wanted an example of how to hook external numerical libraries into PDL, but most users should prefer the newer PDL::LinearAlgebra module for current work. Using PDL::Slatec requires a Fortran compiler and the module includes the original sources for convenience. Note that some functions do not propagate PDL bad-value flags while key routines such as polyfit do handle bad values and support broadcasting across PDL arrays. PCHIP functionality has moved to PDL::Primitive.

PDL::Stats is a toolbox of statistics routines built on the Perl Data Language that makes common numeric and statistical operations fast and vectorized. It bundles modules for basic summary statistics, correlation and tests, generalized linear models and ANOVA, k‑means clustering, and time‑series helpers, and can pull in distribution and GSL CDF functions when those libraries are installed. You work with typed numeric arrays created by pdl and the library uses a clear signature system and optional broadcasting so you can run t‑tests, regressions, PCA, kmeans, ANOVA and many other analyses without writing elementwise loops. The distribution also includes quick‑start guidance for non‑PDL users and optional plotting integrations for visual diagnostics. If you write Perl and need efficient, ready‑made statistical routines that operate on arrays rather than scalars this is a good fit. Recent updates fixed a problematic in‑place operation to avoid accidental data corruption.

Razor2::Client::Agent is a mature Perl client library and command line toolkit for integrating with the Razor2 collaborative spam-detection service, letting mail systems and scripts compute robust message signatures, ask the network whether a message is known spam, submit spam reports, revoke signatures, and manage identities and discovery servers. It bundles the core preprocessing and signature engines used to extract meaningful features from email, provides convenient command-line tools such as razor-check, razor-report and razor-admin, and includes flexible configuration, logging and syslog support so you can drop it into mail filters or automated workflows. The project is actively maintained and cross platform, with modern features like IPv6 support and improved preprocessors, and the recent 2.87 release fixes UTF-8 logging warnings by encoding output, allows using "stdout" and "stderr" as logfile targets, replaces Digest::SHA1 with core Digest::SHA to simplify dependencies, and modernizes CI and minimum Perl requirements. If you need a Perl-friendly way to leverage a community-driven spam database for detection, reporting and revocation, Razor2::Client::Agent is a solid, production-ready choice.

Mojo::UserAgent::Cached is a drop-in enhancement of Mojolicious' Mojo::UserAgent that adds transparent, CHI-backed caching plus local-file and resilient fetching features while keeping non-blocking IO, WebSocket, TLS, IPv6 and gzip support. It lets you plug in any CHI-compliant cache engine or use sensible defaults and tune caching per-URL, override the cache key generator, and control behavior like returning expired cached content on failure, sorting query strings for stable keys, and logging requests. You can also serve relative URLs from a local directory or force all requests to return a specific local file which makes testing and offline work easy. The module exposes simple cache-management methods such as invalidate, expire, set and generate_key so you can manipulate cache entries directly. Environment variables allow easy configuration in deployed environments and the module respects common UA timeouts and options inherited from Mojo::UserAgent. A recent fix restricts cache key length by default to 140 characters to avoid filesystem limits like eCryptFS, making the module more robust in real deployments. If you need a non-blocking HTTP client with built-in, configurable caching and local-file support, this module is a practical choice.

IO::Tty is a low-level Perl helper for creating and manipulating pseudo-terminals, chiefly used behind the scenes by IO::Pty and the Expect ecosystem and normally only needed if you want to import pty-related constants directly. It targets modern POSIX systems and supports Windows only under Cygwin, but pty behavior is very platform dependent so the module documents a number of system quirks such as inconsistent EOF reporting on some BSDs and Solaris and a known hang on long non-raw writes under Cygwin. Recent maintenance fixed a slave file descriptor leak, corrected raw-mode flag handling on BSD and macOS, and improved portability and CI testing across FreeBSD, OpenBSD and NetBSD. In practice use IO::Pty for everyday pty allocation and rely on IO::Tty only when you need the low-level constants or are diagnosing platform-specific issues.

IPC::Run is a mature Perl toolkit for launching and interacting with external programs, offering a safe replacement for system() plus a scripted API to drive background processes and coprocesses. You can capture and feed stdin, stdout and stderr to scalars, callbacks or filehandles, connect multiple children with pipes, use pseudo‑ttys on Unix, apply filters, set timeouts or timers, send signals and cleanly terminate misbehaving processes, all via a simple run() call or a reusable harness started with start() and driven with pump() and finish(). It exposes many shell‑like redirection operators so you can do everything from simple captures to complex pipeline wiring without invoking a shell. Windows support has been steadily improved and recent releases fix numerous Win32 issues and make binary mode the default on Windows to avoid newline mangling, while pty usage still relies on IO::Pty on Unix. Use IPC::Run when you need robust, incremental or interactive control of subprocess I/O and lifecycle; for one‑off commands with no interaction the built in system() or simpler modules may be sufficient.

Modern::Perl::Prelude gives you a compact, opinionated bundle of pragmas, features, and compatibility shims so you can write in a Perl 5.40+ style while still running on Perl 5.30 and later. By default it turns on strict and warnings, exposes feature keywords like say, state and fc, brings try/catch via Feature::Compat::Try, and provides a handful of handy compatibility functions such as trim, ceil, floor, true, false and object helpers. You can opt in to source-level utf8, forward-compatible class syntax, defer blocks or Object::Pad-style classes using simple import flags or a hashref. An optional always_true mode makes the current file automatically return true so you can omit the trailing 1. The prelude applies changes lexically into the caller and loads optional compatibility layers lazily. Disabling the prelude reliably removes the native pragmata but import-only compatibility shims are not guaranteed to be symmetrically undone.

Matplotlib::Simple is a Perl helper that converts Perl data structures into editable Python3 scripts that use matplotlib to produce charts, letting you describe plots in Perl and either have the module run them or save the generated script under /tmp for manual tweaking. It supports single plots and multi-plot subplots and exposes most common matplotlib types such as bar, barh, boxplot, hexbin, hist, hist2d, imshow, pie, plot, scatter and violinplot, plus colored tables, colorbars, shared axes, figure sizing, grouped and stacked bars, error bars, and many layout and styling options through simple Perl hashes and arrays. You can feed hashes or arrays of arrays as data, assign per-key colors and labels, share colorbars across plots and tune performance by writing a single temporary Python file and deferring execution. The only prerequisites are a working python3 and matplotlib, and the module aims to make routine plotting tasks far easier than writing matplotlib code directly while still producing fully editable Python output.

Business::ISBN::Data is a companion data module for Business::ISBN that supplies up-to-date ISBN registration group and range information derived from the ISBN Agency's RangeMessage.xml. It is normally loaded automatically by Business::ISBN and requires Business::ISBN 3.005 or later because the internal data structure changed to handle ISBN-13 prefixes. You can point the module at an alternate RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable before loading Business::ISBN, and if no external file is available the module falls back to embedded data or looks for RangeMessage.xml in the current directory. The distribution includes a copy of RangeMessage.xml and a helper script for regenerating the default data, and the project is maintained on GitHub so you can fetch updates or contribute fixes.

Config::Model::Tester is a testing helper for authors of Config::Model-based modules that lets you declare and run file‑based test cases in a consistent way. It expects a simple directory layout with per-application test spec files and example fixtures, then automates creation of a writable test tree, copies or symlinks single or multi-file configurations into OS-specific locations, and can emulate user homes or backend arguments as needed. Tests are expressed as data structures that describe global settings and per-test steps such as loading data, checking for warnings via Test::Log::Log4Perl, running update or apply_fix actions, dumping and comparing configuration trees, verifying written file contents and modes, and reloading to confirm round‑trip correctness. The framework supports reusing fixtures across tests, skipping conditions, fine-grained content checks, and integration with prove or direct perl invocation using options like --log, --trace and --error. Recent maintenance releases fixed setup, symlink and logging edge cases and the 4.010 release applied a small bug fix to add missing no warnings declarations. If you write or maintain Config::Model models and need a reproducible way to exercise parsing, validation, update and write‑back behavior across varied fixture layouts and platforms, this module is likely relevant.

HTTP::Handy is a compact, single-file, zero-dependency HTTP/1.0 server for Perl 5.5.3 and later that implements a useful subset of the PSGI interface so you can run portable web apps, quick local tools, and demos with almost no setup. You give it a PSGI code reference and it handles routing, static files from a htdocs directory, POST body access via a lightweight psgi.input object, URL decoding and query parsing, MIME type detection, htmx request detection, and convenience response builders for HTML, text, JSON and redirects, while writing rotating LTSV access logs and timestamped error logs. The design favors simplicity and portability so it runs on any platform without extra modules, but it is single process and single threaded, implements only GET and POST over HTTP/1.0, buffers POST bodies in memory with a default 10 MB limit, and does not provide HTTPS, making it ideal for development, local tools, and rapid prototyping rather than internet-facing production use.

App::MARC::Filter is a lightweight base class for building command-line tools that read and filter MARC bibliographic records. It offers a minimal object interface (new and run) and common filtering features such as matching by datafield tag and subfield, control fields, leader content and material type, with options to invert matches, limit the number of output records and control output encoding. The module parses MARC XML and, since v0.08, also supports USMARC input, and relies on MARC::File::XML and Unicode::UTF8 for record handling. Use it if you need a simple, script-friendly foundation to extract or count specific records from library catalog data without implementing a full MARC parser.

LaTeX::Replicase is a lightweight Perl template engine that fills real LaTeX documents by interpreting simple in‑file tags so you can drive PDF or DVI output from Perl data structures. You embed intuitive tags like %%%V: and %%%VAR: in an ordinary .tex file and Replicase substitutes scalars, arrays, hashes and nested structures to create repeated table columns, rows and blocks while keeping presentation and logic separate. It supports UTF8 input and output, optional TeX escaping via tex_escape, output to a file or to STDOUT, and runtime options such as def, esc, ignore and debug which can also be set from inside the template. The module is conservative and fast, never overwrites the source template, and is suited for programmatic generation of consistent LaTeX documents. Note the practical limits: it requires Perl 5.10 or later, file and directory names cannot contain spaces, and tag names should stick to letters, digits and underscore because some symbols are reserved. Recent updates added an always‑present ADDA tag, a magic 0x01 trigger for left‑value insertion, improved handling of undefined values and escaping, and expanded support for multi dimensional array/hash indexing.

Math::GMP_OLOAD is a lightweight compatibility helper that lets Math::MPFR, Math::GMPq and Math::GMPz play nicely with Math::GMP by enabling arithmetic and comparison operator overloading between these big-number object types. It makes mixed expressions like comparing or multiplying a GMP integer with an MPFR floating point behave predictably and promotes results to the appropriate object class, so you can use normal operators instead of manual conversions. The module requires Math::GMP to be installed and the author recommends reasonably recent versions of the underlying libraries for full correctness, with Math::MPFR 4.47 and Math::GMP 2.11 cited as practical minima. Use is simple: load Math::GMP_OLOAD and then work with the different high-precision numeric objects as you would native scalars, which is handy when your code needs transparent interoperability across multiple precision libraries.

Math::GMPq is a Perl wrapper around the GNU MP library that gives you exact, arbitrary-size rational numbers and the standard mpq operations in Perl. It lets you create rationals from strings, integers, floats or other GMP objects, reduce them to canonical form, convert them to native Perl numbers or strings, and perform high-performance arithmetic, comparisons and formatted I/O with operator overloading so expressions feel natural. The module integrates with Math::GMPz and Math::MPFR types, provides random-state helpers and a variety of input/output routines, and manages GMP memory for blessed objects automatically. You must have the GMP C library installed and be mindful of one caveat if Perl was built with -Duse64bitint: assign integers larger than 52 bits inside a use integer block to avoid loss of precision. Also take care to pass the correct argument types or you can trigger a segfault. If you need reliable, fast rational arithmetic in Perl this module is a direct, low-level bridge to GMP.

Permute::Unnamed::Iter provides a tiny, easy-to-use iterator for producing the Cartesian product of several lists. You call permute_unnamed_iter with a series of arrayrefs and it returns a coderef which you invoke repeatedly to receive arrayrefs each containing one element from each input list, returning undef when the combinations are exhausted. Because it yields combinations on demand rather than building them all at once it is memory efficient and fits naturally into nested-loop style processing, combinatorial testing, configuration generation, and similar tasks. It is essentially Permute::Unnamed reworked as a lazy iterator and sits alongside modules like Set::CrossProduct for related needs.