CPANscan

DBIx::Class::MockData generates realistic test rows for DBIx::Class schemas by introspecting your connected Schema object, resolving foreign key insertion order, and inserting values that match column data types while honoring nullability and uniqueness. You supply a connected schema and a schema directory and then call deploy, generate, wipe, or dry_run to create tables, populate them, drop and redeploy, or preview the inserts without touching the database. It provides sensible defaults for counts and value shapes, supports per-table row counts, custom per-column generator callbacks, reproducible output via a seed, and allow-list / deny-list filters to target specific tables. The distribution also includes a dbic-mockdata CLI for quick use in test workflows and all public methods return $self for chaining. The recent 0.04 release adds rows_per_table and generators, improves unique-salt handling, and switches to bulk inserts using populate for up to 10x faster population of large datasets. Note that your code must supply the database connection and that wipe is destructive and intended for test environments only.

OpenAPI::Modern lets you validate HTTP requests and responses against an OpenAPI v3.0, v3.1 or v3.2 description and returns rich, machine-readable validation results from the JSON Schema evaluator. It works with Mojolicious request and response objects and will convert common types from Plack, Catalyst, Dancer2 and HTTP::Request/Response so you can check incoming or outgoing messages against the API contract and get precise error locations and messages. The distribution bundles up-to-date OpenAPI metaschemas, supports embedded JSON Schema dialects, and includes features to cache and preload parsed documents for better runtime performance. It also handles parameter deserialization and many media-type cases, but some parts of the spec are not yet implemented, for example full query styles beyond form exploded true, cookie parameters, multipart and application/x-www-form-urlencoded encodings, and it does not validate Authorization headers against security schemes. Recent releases added full OpenAPI 3.2 support, much improved path-parameter parsing and faster type-inference caching to speed validation in production.

Async::Microservice is a Moose role that helps you quickly bootstrap an asynchronous HTTP microservice with built-in OpenAPI documentation and a simple PSGI entry point. You implement a small class that composes the role, supply a service_name and a get_routes mapping, place an OpenAPI YAML next to the service name and run the generated PSGI app with plackup and an async server such as Twiggy, then view interactive docs at /v1/ and /v1/edit. The role supports async request handlers that return Futures, array-refs or scalars, can emit JSONP callbacks, and now logs internal server errors; the latest release also fixes a memory leak affecting Perl 5.40 and newer. It is focused on fast bootstrapping rather than advanced operational features so graceful shutdown handling is noted as a future improvement.

Shell::Cmd is a Perl helper for building and running sequences of shell commands with practical, script-level controls that make wrapper scripts more robust and easier to manage. It automatically emits a temporary shell script so you can control STDOUT and STDERR, echo commands, perform dry runs that return the generated script, trap and report which command failed, retry transient failures, provide alternate commands when some tools are missing, set per-command directories and environment variables, and run commands remotely over SSH with optional parallelism. The module also captures output in a script mode for post-run analysis and handles quoting and redirection for you. It is ideal when your Perl program needs to orchestrate multiple shell steps or run the same steps on many hosts, but it works best for simple commands and basic flow constructs and does not support shell functions or arbitrarily complex scripts, and accurate per-command error numbering is limited to the first 200 commands.

lexically is a tiny pragma that makes ordinary package-based exporters act like lexical importers so that symbols you import only exist for the current scope and vanish at scope end. It lets you use modules that export functions or constants without permanently polluting your package namespace and can eliminate the need for cleanup helpers like namespace::clean. The module is lightweight and designed to be a drop-in way to keep imports local and tidy while working with existing exporter-style modules.

Mojo::Pg is a compact Perl wrapper around DBD::Pg that makes PostgreSQL easy to use from the Mojolicious real‑time web framework, providing a simple API for blocking and non‑blocking queries, automatic connection and statement handle caching, fork safety and sensible DBI defaults. It includes helpers for transactions, JSON encoding/decoding, promise‑friendly async query methods, integration with SQL::Abstract::Pg to generate CRUD statements, built‑in schema migrations and an efficient PubSub helper for PostgreSQL notifications so you can build scalable real‑time web apps without wrestling with low‑level DBI details. Configuration options let you tune pool size, search_path and other connection settings, and the project is actively maintained with fixes and improvements; the recent 4.28 release ships a workaround for a DBD::Pg bug.

Getopt::EX::Hashed makes it simple to declare and manage command line options by building a hash-backed object for Getopt::Long-style parsing and generating convenient accessor methods so you can read and write options as $obj->name. You define each option once with its spec, aliases, default value, validation rules or action code, and the module produces the GetOptions specification and optional lvalue accessors while offering helpers for locked keys, underscore/dash aliasing, lazy defaults, and common validators like min, max or membership checks. It includes a getopt wrapper that calls GetOptions or GetOptionsFromArray and a configure interface to tune behavior such as accessor prefixes, whether accessors are lvalue, key locking, and whether generated accessors are removed when the object is destroyed. Recent updates made accessor removal clone-safe and changed the default to remove accessors on destruction so the same class can be used multiple times in one process, and fixed handling of ARRAY/HASH references so default container values are preserved when options are added.

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.

Net::Ident is a compact Perl library for performing ident lookups defined by RFC1413 so you can ask the remote end of a TCP/IP connection which user or ID owns that connection. It offers a simple synchronous API that accepts a connected socket or packed sockaddr pair and returns the remote ID, plus a nonblocking asynchronous object interface you can integrate with select, and optional convenience methods that add ident_lookup to FileHandle or Apache connection objects. Because it uses the ident protocol it requires the remote host to run an ident daemon and that daemon may return opaque IDs for privacy, so results are useful for logging or supplemental access checks but are not guaranteed for every connection. The module is actively maintained and the recent 1.26 release fixes a number of bugs in the async path including a sysread EOF issue that could cause an infinite loop and improves RFC1413 parsing and async reliability.

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.

Regexp::Parser parses Perl regular expressions into an object tree so you can inspect, walk, transform, or reserialize them programmatically. It yields node objects as it parses, provides a walker/iterator to traverse the tree, and can produce a visual string or a real qr// Regexp from the parsed structure while reporting detailed errors and warnings. The module includes support for named character escapes and a handler system for subclassing so you can add analyses or transformations such as min-length checks, character-class operations, or custom rendering. Be aware it parses regex syntax rather than full Perl so variable interpolation in literal strings can be misinterpreted, and early documentation was incomplete though the project has been actively maintained. Recent versions add modern Perl regex features including \K, \R, \h/\H, \v/\V, named captures and backreferences, possessive quantifiers, newer charset flags and caret-reset syntax, and raise the minimum Perl requirement to 5.16.

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.

YAML::Syck is a thin, fast Perl binding to the libsyck serializer that converts Perl data structures to and from YAML text using simple functions like Load, Dump, LoadFile and DumpFile and supports streaming multiple YAML documents and dumping into existing scalars with DumpInto. It gives you control over common emitter and parser behaviors via global flags such as $YAML::Syck::ImplicitTyping to recognize unquoted booleans and numbers, $YAML::Syck::ImplicitUnicode and $YAML::Syck::ImplicitBinary for Unicode and binary handling, and options to control quoting, sorting keys and whether loaded nodes are blessed into objects. The module implements YAML 1.0 and bundles its own copy of libsyck, so it can be useful when you need interoperability with other Syck wrappers or want a lightweight, speedy YAML layer, but it has some limitations such as incomplete support for dumping glob/IO values and tied variables and a history of known issues and only semi-active maintenance. Recent releases include important stability fixes, notably patches in 2025 that address memory corruption and improve handling of empty strings and keys, but if you need full YAML 1.1 compliance or a more actively maintained YAML stack you may prefer YAML::XS.

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.