CPANscan

Search::Xapian is a Perl XS binding that brings the full-text search power of the Xapian C++ library into Perl, letting you create and open Xapian databases, index documents, build complex queries with the QueryParser, apply stemming and stopword processing, and tune weighting, sorting and value‑range filters in a familiar Perl style. It exposes most Xapian classes and constants so you can run relevance-ranked searches, phrase and proximity queries, wildcard and boolean queries, use match spies and multi-value sorters, and serialize numeric keys for stable sorting. The module maps Xapian C++ exceptions to Perl exception classes and includes measures for safe use with Perl threads, and the documentation points you at the Xapian C++ API for any wrapper gaps. Recent releases improved exception handling and extended compatibility with newer xapian-core versions by generating exception glue at build time so the bindings work cleanly across Xapian 1.4.x and older supported releases.

Net::Ident is a small Perl module that performs RFC1413 ident lookups to ask a remote host which user or identifier is associated with a particular TCP connection. It works synchronously via convenience functions or as a method on FileHandle or Apache connection objects when you opt in, and it also offers an asynchronous object interface for non-blocking or multi-lookup workflows with methods like new, query, ready, and username. Lookups require an ident daemon running on the remote side so results are not guaranteed, and calls support timeouts and return either a simple username or a trio of username, reported OS, and an error message depending on context. The module is useful for logging, access control, or diagnostics when ident information is available, and it intentionally only augments other classes when explicitly requested. Recent maintenance modernized the test suite, improved portability and error handling across platforms, added comprehensive tests for timeout and lookup behaviors, and removed legacy Apache/mod_perl infrastructure for a leaner, more robust release.

IO::Stty is a Perl wrapper around the POSIX stty utility that lets your scripts query and change terminal line settings for a given filehandle. You call IO::Stty::stty on a handle to toggle modes like echo, raw versus cooked input, parity and character size, flow control, special control characters, and baud rates, or to print settings in human or machine-restorable form. It works with standard filehandles and IO::File objects and is handy for tasks such as turning off echo for password prompts, configuring serial ports, or temporarily changing canonical input behavior. The module aims to follow POSIX behavior but is not optimized for speed and will return undef if the handle is not a terminal.

PDF::Sign is a Perl utility for adding standards-compliant digital signatures and RFC3161 timestamps to PDF files so you can produce PAdES-ready signed documents. It provides a small, high-level API to configure credentials, prepare and apply CMS/CAdES signatures and DocTimeStamp timestamps, and to verify signatures found in a PDF, while relying on PDF::API2 or PDF::Builder for PDF manipulation. Cryptographic operations require an external openssl binary and TSA requests use curl if available with a fallback to LWP::UserAgent, and the module uses common Perl components like File::Slurp and MIME::Base64. The initial CPAN release implements CMS/CAdES and RFC3161 support, OpenSSL 1.x and 3.x compatibility, signature verification, process-safe temporary files, and a PDF32000-2008 compliant ByteRange implementation, making it a practical choice if you need programmatic PDF signing and timestamping from Perl and can provide an openssl-capable environment.

Devel::NYTProf is a fast, production‑quality profiler for Perl that gives very detailed, actionable performance data by recording per-line, per-subroutine, per-opcode and per-block timings with sub-microsecond resolution and producing richly annotated, cross-linked HTML reports via the bundled nytprofhtml tool. It is written mainly in C for speed, handles forked processes without extra overhead, can profile compile-time or END-phase activity, captures string eval source so reports remain self-contained, and lets you control profiling at runtime with environment options or DB::enable_profile and DB::disable_profile. The profiler also attributes subroutine times to the specific calling location, supports slow-op and opcode profiling, can emit call event streams for flame graphs and callgrind/KCachegrind, and includes utilities to merge multiple profile files. Known limitations are that it is not thread or multiplicity safe and the subroutine profiler gets confused by Coro so you should disable subs in that case, and older Perl releases expose some accuracy limits. The recent 6.15 release focused on maintenance and infrastructure improvements including an updated flame graph link and CI/test fixes, so users can expect stable behavior and up-to-date tooling. If you need precise, low-overhead profiling to locate hotspots or understand call-site behavior in Perl applications, NYTProf is one of the most capable options available.

Crypt::RIPEMD160 is a simple Perl extension that implements the RIPEMD-160 message digest so you can produce 20-byte binary digests or human readable hex strings from scalars or filehandles. It exposes an easy object-oriented API with new, reset, add, addfile, digest and hexdigest, plus convenience class methods hash and hexhash for one-shot hashing, and a clone method to snapshot mid-computation state when you need to compute multiple digests that share a common prefix. The module is based on the reference C implementation by Antoon Bosselaers and is distributed under the same free license as Perl, making it a good fit for checksums, legacy protocols, or any Perl code that specifically requires the RIPEMD-160 hash. Recent maintenance strengthened portability and safety by fixing 64-bit issues, improving file read error handling, adding the clone method, and zeroing sensitive state on reset and destroy.

Task::Kensho::All is a meta-package that installs every sub-task of Task::Kensho, letting you pull in the full collection of Perl modules recommended by the Enlightened Perl Organisation with a single command such as cpanm Task::Kensho::All. It is useful when you want to provision a development environment or system with the complete Kensho recommendations rather than picking modules one by one. Expect a large set of dependencies and a heavier install than typical individual modules, so only use it if you really want everything. The distribution follows the upstream Task::Kensho releases and was updated to track Task::Kensho 0.41 in 2021.

Pod::Usage extracts a script's embedded POD documentation and prints a standard usage or manpage-style help message from it. Its main entry pod2usage can be called simply or with options to control verbosity: level 0 prints only the SYNOPSIS, level 1 prints SYNOPSIS plus OPTIONS and ARGUMENTS, and level 2 prints the full manual page and will invoke perldoc unless you request the built-in Pod::Text formatter. You can prepend a custom message, choose the output handle or file, set the exit status or request no exit, and select particular sections to show. Sensible defaults for exit status and routing to STDOUT or STDERR follow common Unix conventions so most scripts need only minimal code, and advanced features include custom formatters, supplying the input POD path or a search path, and a small pod2usage command line wrapper. Be aware that on some systems $0 may not reliably point to the script file and calling pod2usage after changing directories can fail unless you provide an explicit input path or use FindBin.

Module::CoreList is a reference library that tells you which modules and which module versions were bundled with each release of Perl, making it easy to check if a feature or library is part of core for a given Perl. You can use the included corelist command line tool or call the API from Perl to ask when a module first appeared, when it was deprecated or removed, whether a specific module version is core, or to search core modules with a regex and compare differences between two releases. The distribution also exposes hashes such as %Module::CoreList::version, ::delta, ::released, ::families, ::deprecated, ::upstream and ::bug_tracker so tools and packagers can inspect versions, release dates, deprecation notes and where to send patches or bug reports. Coverage includes all stable Perl releases since 5.6.0 and development releases since 5.9.0 with earlier legacy data, and the module is maintained by the Perl 5 Porters and distributed under the same license as Perl.

HTTP::Tiny::Mech is a small adapter that makes a WWW::Mechanize instance behave like an HTTP::Tiny user agent so you can plug a mechanize-based backend into code that expects HTTP::Tiny. It is mainly useful when you want mechanize features such as form handling or persistent caching via WWW::Mechanize::Cached while preserving an HTTP::Tiny API, and you can provide a custom mechanize object via the mechua attribute. The module currently implements only get and request and delegates other calls to a native HTTP::Tiny, so it is concise and practical for basic GET/request use cases. It was written as an experimental, lightly documented hack to speed MetaCPAN::API access and works for that purpose, but you should be aware of its limited surface and experimental status.

WWW::Mechanize is a Perl module that gives you a programmable, stateful web browser for automating interactions with websites. It builds on LWP::UserAgent to fetch pages and exposes high level helpers to follow links, fill and submit forms, manage cookies, handle redirects, SSL, proxies and HTTP authentication, and it keeps a navigable history which makes it handy for testing and scraping workflows. The API includes convenience methods like follow_link and submit_form plus options such as autocheck and strict_forms, and it is easy to extend or subclass for custom behavior, but it does not execute JavaScript so pages that rely on client side scripting will need additional tools.

WWW::Mechanize::Cached is a thin wrapper around WWW::Mechanize that transparently caches HTTP responses so you can repeat browselike requests without hammering remote servers. It creates a disk cache by default using the old Cache::Cache family with a one day expiry but lets you supply any cache object that implements get and set, and using CHI is recommended. The module preserves the same Mech API so you call new and get just as usual and then can check is_cached to tell whether a response came from cache, call invalidate_last_request to remove the last entry, and tweak caching policy with options that control whether error responses are cached, whether the Referer is part of the cache key, and how to treat missing, zero or mismatched Content-Length headers. Note that since v1.36 caching is positive by default rather than caching errors, and recent releases added invalidate_last_request and bumped LWP::UserAgent requirements; the author also encourages providing your own CHI cache object for better long term compatibility.

HTTP::Tiny is a compact, dependency-light HTTP/1.1 client for Perl that lets you make straightforward web requests without the overhead of a full user-agent framework. It implements common HTTP methods and handy helpers like post_form and mirror, supports proxies and basic proxy auth, offers single-host keep-alive connections with a newly added keep_alive_timeout to control reuse, and provides streaming callbacks for sending or consuming large bodies. HTTPS works when IO::Socket::SSL and Net::SSLeay are installed and certificate verification is enabled by default for better security, with options to supply custom CA bundles or other SSL parameters. It will use IO::Socket::IP when available for IPv6 and can integrate with HTTP::CookieJar for cookie handling. Calls return a simple hashref containing status, headers, content, and redirect history, and network or internal errors are surfaced as a 599 status with the error text. HTTP::Tiny focuses on correct transport rather than implementing every RFC recommendation so you must ensure URLs are properly escaped and manage advanced header behavior yourself, but it is an excellent lightweight choice when you need a simple, robust HTTP client.

JSON::MaybeXS is a lightweight compatibility wrapper that picks the best available JSON implementation on your system, preferring Cpanel::JSON::XS, then JSON::XS, and falling back to the pure‑Perl JSON::PP when no XS backend is available. It exports familiar helpers like encode_json and decode_json and provides a JSON constant that returns the underlying class so you can construct encoder/decoder objects with a simple new(utf8 => 1, pretty => 1) call. The module also exposes JSON true and false values and an is_bool helper for testing them, and it offers a :legacy import tag to support older to_json/from_json code while warning about UTF‑8 pitfalls. Installation tries to add an XS backend when a compiler is available but leaves JSON::PP as a safe fallback, so the module is suitable for fatpacked or restricted environments. Recent updates have improved boolean handling and made is_bool aware of core booleans on modern Perls.

Cpanel::JSON::XS is a high-performance, C-backed Perl module for encoding Perl data structures to JSON and decoding JSON back to Perl with strict, correct Unicode handling and a focus on round-trip integrity. It provides both simple functional helpers and a configurable object-oriented API so you can choose UTF-8, ASCII or latin1 output, pretty printing, canonical key sorting, relaxed parsing, incremental stream parsing, big-number handling and several strategies for dealing with blessed objects or nonstandard tagged values. The module is strict and secure by default so it rejects unsafe inputs such as top-level non-reference scalars and will not deserialize arbitrary objects unless you explicitly enable those extensions, and it also detects BOMs and supports ithreads. Cpanel::JSON::XS is one of the fastest Perl JSON implementations, is used transparently by JSON::MaybeXS when available, and is actively maintained on GitHub with a public issue tracker. The maintainer notes a planned migration to a JSON::Safe package that will keep the same API but establish safe defaults.

ExtUtils::MakeMaker is the standard tool for turning a Makefile.PL into a portable Makefile that builds, tests and installs Perl modules and XS extensions. Using WriteMakefile() you declare the module name, version source and many attributes to control compilation, linking, install locations, tests, prerequisites and distribution packaging, and the module generates a makefile tailored to your platform and make flavor (GNU make, nmake, dmake, etc.). It understands XS and C code, supports static or dynamic linking, auto-discovers tests in t/*.t, can produce META.yml and META.json for CPAN, and offers hooks and overridable methods so authors can customize or extend generated rules. It also provides utility helpers like prompt and WriteEmptyMakefile and integrates with the wider CPAN toolchain, so if you write or package Perl modules this is the primary way to automate building, testing and installation; pure-Perl alternatives such as Module::Build and Module::Build::Tiny exist if you prefer not to rely on make.

File::Temp provides a safe, portable way to create temporary files and directories in Perl, offering both simple functions like tempfile and tempdir and an object-oriented API whose objects act as filehandles and clean up by default. The module returns a filehandle together with the filename to avoid race conditions and supplies configurable safety levels that perform extra ownership and sticky-bit checks where supported. It also implements mkstemp/mkstemps/mkdtemp and POSIX-style tmpfile/tmpnam for compatibility while warning that name-only functions like mktemp/tmpnam cannot prevent races. Cleanup behavior and unlink semantics vary by platform so features such as unlinking open files, automatic deletion, and some safety tests may be limited on Windows or NFS.

Devel::Cover is a mature code-coverage tool for Perl that helps you see which parts of your code your tests exercise and which parts are untested so you can improve your test suite. It reports statement, branch, condition, subroutine and pod coverage and can produce a variety of reports including HTML, text and even editor-friendly formats, with optional syntax highlighting and annotations such as git blame. You run it by loading Devel::Cover when running your tests or programs and then running the cover tool to generate reports, and it can also import C or XS coverage via gcov2perl so your native extensions are included. It requires Perl 5.20 or newer and a working C toolchain to build its XS components, and it can use optional modules for nicer output and pod analysis. The author notes branch and condition details may not always match initial expectations and that code used by Devel::Cover itself cannot be measured, and there are known edge cases such as redefined subroutines, but overall it is a stable, feature-rich way to quantify and improve your Perl test coverage.

Perl::Tidy is a module that gives Perl programs the same source-parsing and beautifying capabilities as the perltidy command line tool so you can format, analyze, or transform Perl code from within your own scripts. It accepts input and output as filenames, string or array references, or IO-like objects and returns a status flag so your program can detect errors or warnings. You can supply a custom formatter object to receive tokenized lines for specialized processing, or plug in prefilter and postfilter callbacks to change the code before or after tidying. The module also exposes ways to programmatically read perltidy configuration files and option metadata, and it provides controls for how UTF-8 strings are returned. If you need reliable, scriptable Perl code formatting or want to build tools that inspect or rewrite Perl source, Perl::Tidy is directly applicable and installs alongside the perltidy command.

Test::Simple is a tiny, beginner-friendly Perl testing helper that gives you the absolute basics for writing TAP-style tests: declare how many tests you plan to run, call ok(EXPR, NAME) for each check, and the module prints "ok" or "not ok" lines with test numbers so harnesses can evaluate the results. It is intentionally minimal to make writing tests easy and fast, and it exits with predictable codes so scripts and CI can tell whether everything passed. If you need richer assertions, diagnostic helpers, subtests, or advanced reporting you can drop in Test::More, which is a compatible superset. Recent releases have modernized the internals and packaging by integrating the newer Test2/Test-Stream tooling and bundles, improving diagnostics, subtest behavior, and compatibility across Perl versions while keeping Test::Simple’s simple public interface.

App::cpanminus provides the cpanm command, a tiny, zero‑configuration tool for fetching, unpacking, building and installing Perl modules from CPAN and related sources. It is designed to be self‑bootstrapping and dependency‑free so you can install it with a single curl | perl command, it respects local::lib and will automatically set up a per‑user install path if you do not have root access, and it runs comfortably in very little memory. cpanm supports installing from CPAN, MetaCPAN, BackPAN, tarballs, git repositories and URLs, understands version specifications and cpanfile requirements, and offers conveniences like --installdeps and --self‑contained installs without the overhead of a full CPAN client. If you need full CPAN features such as tester reporting or RPM packaging you should use CPAN or CPANPLUS, but if you just want a fast, reliable way to get Perl modules installed cpanm is an excellent, battle‑tested choice. The project continues to be maintained and was recently updated to refresh embedded metadata tooling, including an updated Module::Metadata in March 2026.

Loo is a fast, XS-based Perl data introspector that produces Data::Dumper-compatible, human readable dumps with optional ANSI colour and built-in themes. It can serialize complex Perl structures or, when enabled, deparse code references back into Perl source by walking the op tree in C. You can use convenient functional helpers like Dump, cDump, ncDump and dDump or instantiate a Loo object to fine tune indentation, tabs, key sorting, max depth, quoting, purity, and a full palette of colour elements or themes such as monokai and light. Colour is auto-detected from the environment but can be forced on or off and there is a utility to strip ANSI escapes for plain text consumers. If you want a drop-in, feature-rich alternative to Data::Dumper that adds pretty printing, colouring and optional code deparsing, Loo is worth a look.

Consumer::NonBlock provides a lightweight way to pass text from a fast producer process to a slower consumer without making the producer block on a full pipe. You create a paired reader and writer, the writer sends lines or arbitrary text into rotating temporary files, and the reader consumes and deletes those files as it goes so processed data does not accumulate on disk. The module can store data in /var/shm for better performance, works across forks using an environment variable and a weaken mechanism to control which process deletes data or closes the stream, and is intended for cases where you cannot afford the producer to block rather than as a general replacement for pipes. This is an early release but it already fixes a buffering edge case that could split writes across file boundaries and corrupt lines.

Sieve::Generator is a compact Perl library for programmatically building RFC 5228 Sieve email filter scripts by composing a tree of objects and rendering them as correctly indented Sieve code. It is driven by the Sieve::Generator::Sugar layer, which exports short constructor functions such as sieve, ifelse, block, command and qstr so you can build, reuse and stitch together subtrees of filtering logic without dealing with class names. Each node implements as_sieve to produce final output, making this useful for mail server administrators and developers who want to generate or manipulate Sieve rules from code instead of hand editing. The current release tightens and simplifies the API by removing some lesser-used sugar, improves the command sugar for smarter argument typing and nicer formatting with tagged arguments, and adds convenience helpers var_eq and var_ne. Note that the author does not promise a fixed minimum Perl version, so verify compatibility with your environment.

SQL::Wizard is a Perl library for building SQL by composing immutable expression trees instead of concatenating strings. You create columns, functions, arithmetic expressions, joins, CTEs, window functions, CASEs and full SELECT/INSERT/UPDATE/DELETE statements as objects and nothing is rendered until you call ->to_sql, which returns a SQL string with "?" placeholders plus a flat list of bind values ready for DBI. Values are bound by default, identifiers are quoted and validated, and there are multiple injection guards while still providing a raw() escape hatch for cases the API does not cover. The API supports nested subqueries, compound queries, PostgreSQL and MySQL upsert patterns, RETURNING, and immutable modifiers so you can derive many variants from a base query. It has no non-core dependencies and currently emits standard ANSI SQL with a reserved dialect option for future database-specific rendering.

Math::GMPz is a Perl interface to the GMP C library that gives you fast, arbitrary‑precision integer arithmetic by wrapping the library's mpz (integer) functions. It lets you create and manipulate very large integers, perform high-performance arithmetic and bitwise operations, compute gcds, modular inverses and exponentiation, test for primality, produce random big integers, and import or export raw binary representations, and it overloads Perl operators so big integers behave much like native numbers. The module requires a compiled GMP library and provides both blessed objects that are auto‑cleared and unblessed variants that you must free manually. The author notes some practical caveats such as UTF8 handling in import/export, limits on certain formatted I/O calls, and that passing the wrong argument types at the C interface level can cause segfaults, but otherwise Math::GMPz is a direct, high‑performance bridge from Perl to GMP for anyone needing reliable big integer support.

Math::GMPq is a Perl interface to the GMP library for precise rational arithmetic, letting you create and manipulate arbitrarily large fractions with full support for parsing and formatting in many bases, canonicalizing (reducing) fractions, accessing numerator and denominator as big integers, and performing fast arithmetic and comparisons. The module wraps GMP's mpq routines and provides Perl-friendly constructors, conversions, operator overloading so native Perl operators work with big rationals, and RNG state helpers when you need random rationals. Blessed objects are cleaned up automatically but unblessed objects can be used if you prefer manual memory management. You do need the GMP C library installed and you should be careful to pass the correct argument types because incorrect types can crash the program. Use Math::GMPq when you need high-performance, exact rational math or tight interoperability with Math::GMP and Math::MPFR.

Math::GMPf is a Perl interface to the GMP library's mpf "bigfloat" routines that gives Perl programs access to arbitrary‑precision floating point arithmetic by wrapping the native GMP C API. It exposes initialization, conversion, I/O and formatted output, a full set of arithmetic and comparison operations, random number facilities, and operator overloading so you can use high‑precision numbers in Perl expressions much like built‑in scalars. Objects are blessed and cleaned up automatically though unblessed "nobless" variants are available if you prefer manual memory control. You must have the GMP C library installed to use it and recent releases improved comparison behavior so the overloaded <=> returns canonical values and added better quadmath support on Cygwin.

App::Test::Generator creates ready-to-run Test::Most fuzz and corpus-driven test harnesses from formal input/output schemas so you can automatically probe functions and methods for edge cases and regressions. You point it at a schema file, usually YAML, that describes the module, function, inputs, outputs, transforms and optional static corpora, and it emits a .t script that combines randomized fuzzing, deterministic boundary tests, type- and semantic-aware generators (email, uuid, timestamps and more), and optional property-based checks via Test::LectroTest. It supports both functional and OO targets, reproducible runs via a seed, configurable iteration counts, per-field and per-type edge-case injection, and can extract schemas from Perl source as a proof of concept for automated test generation and CI workflows such as GitHub Actions. Non-YAML input formats are less exercised and some configuration choices like seed and iterations live at top level rather than under config, and the distribution carries an unusual licensing restriction beyond a personal GPL2 allowance so review the licence if you plan wide or commercial use.

Mo::utils::Array provides a compact set of validation helpers for Mo-style Perl objects to ensure that attributes meant to be arrays are correct and consistent. The module supplies functions to check that a value is an array reference, to require at least one element, to enforce a maximum number of items, to verify that each element is an instance of a specified class, and to restrict elements to a defined list of strings. Failures are reported using Error::Pure and the routines themselves return undef, making them easy to plug into simple object validation workflows. Recent updates added item-count checks and string-list checks and moved a common object-checking helper into Mo::utils::common.