CPANscan

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.

DB::Object is an object oriented wrapper around DBI that makes writing SQL in Perl more fluent and less error prone by letting you build queries with chainable table and field objects instead of hand-assembling SQL strings. You get table objects that expose fields, overloaded operators for readable WHERE and JOIN expressions, typed placeholders, prepared statements, transaction support and helpers for JSON and datetime columns, plus convenience methods for table discovery, creation and quoting across drivers such as Pg, MySQL and SQLite. It also supports caching of table metadata and prepared statement objects, optional connection configuration via JSON files or URIs, and an asynchronous execute path that returns a Promise::Me promise. Recent v1.9.0 improvements add object freeze/thaw for cached queries, better statement caching and serialization safeguards, and a dedicated DB::Object::Exception class. Keep in mind that preparing queries has a runtime cost so you should reuse or cache statement objects where possible and that using DBI connection caching can interfere with transaction AutoCommit behavior if you are not careful.

NetAddr::MAC is a Perl utility for parsing, validating, formatting and manipulating hardware MAC addresses in both EUI‑48 and EUI‑64 forms. It provides an object oriented API plus procedural helper functions to detect address properties like unicast, multicast, broadcast, locally or universally administered and special service addresses such as VRRP, HSRP and Microsoft NLB, to convert between EUI48 and EUI64 and to produce standardized output formats used by vendors and systems including Cisco, IEEE, Microsoft, PostgreSQL, Sun, token ring and the IPv6 autoconf suffix. You can also generate random MACs from a supplied OUI or locally administered prefix and include bridge priority values for Cisco-style strings. The module intentionally omits vendor OUI lookup and templating and uses a non‑fatal error model by default that returns undef and an errstr while offering an option to croak on errors. If you need reliable, flexible MAC address handling and formatting in Perl this module covers the common tasks cleanly.

JSON is a lightweight, user-friendly Perl interface for encoding and decoding JSON that picks the best available backend for you, using JSON::XS (or Cpanel::JSON::XS) for speed and falling back to JSON::PP or the bundled JSON::backportPP when an XS backend is not available. It exports convenient functions like encode_json and decode_json and also offers a configurable object interface (JSON->new) with flags for UTF-8/ASCII/latin1 output, pretty printing, canonical key ordering, relaxed parsing, depth and size limits, and options for handling blessed objects or nonstandard tagged values. The module supports incremental parsing for streaming input, callbacks to transform decoded objects, custom boolean handling, and hooks for object serialization via TO_JSON/FREEZE/THAW, so it fits both simple scripts and more complex serialization needs. You can force a particular backend with the PERL_JSON_BACKEND environment variable to avoid cross-backend surprises. The project is actively maintained and the most recent release updated the bundled pure-Perl fallback to JSON::PP 4.18, ensuring improved compatibility when an XS backend is not used.

Business::UPS is a small Perl library that lets web apps and scripts fetch UPS shipping rates and track packages without dealing with UPS web pages directly. It provides getUPS, a simple call that accepts a UPS product code, origin and destination ZIPs, weight and optional package details and returns zone and cost figures, and UPStrack, which returns a hash of tracking information including current status, service type, weight and a Scanning sub‑hash of scan events. The module relies on LWP::UserAgent and JSON::PP and requires Perl 5.014 or newer. Recent maintenance replaced fragile HTML scraping with the UPS JSON tracking API and fixed error handling so callers can catch exceptions. Be aware that UPS is a registered trademark and use of this module may not be endorsed by UPS, so check licensing and API terms before using it in production.

Math::MPC is a Perl wrapper around the MPC C library that brings arbitrary precision complex arithmetic into Perl programs, letting you create complex numbers with independently controlled bit precision for real and imaginary parts and perform correctly rounded operations such as addition, multiplication, division, powers, roots, exponentials, logarithms and trigonometric functions. It integrates with the GMP and MPFR ecosystem so you can mix MPC values with MPFR and GMP types, offers operator overloading for convenient syntax, and provides fine control over rounding modes, string conversion, I/O and special functions like dot products, sums and modular routines. Blessed Math::MPC objects are cleaned up automatically while unblessed initializations must be cleared manually, and some features require the underlying libraries to be built with specific options. The module is ideal when you need high precision complex math in Perl, but be aware that passing incorrect argument types can cause segfaults and the overloaded operators are not guaranteed to preserve the sign of zero in every case.

Crypt::Passphrase::Scrypt is a small plugin for the Crypt::Passphrase framework that lets you hash and verify passwords using the scrypt algorithm. It integrates with Crypt::Passphrase and supports the passlib "$scrypt$" format by default and, as of the latest release, the libcrypt "$7$" format as well. You can tune the hashing parameters such as cost, block size, parallelism, output size and salt size to balance CPU and memory hardness, and you should be aware that increasing the cost raises both time and memory requirements. The module is useful when you need scrypt-compatible password storage in Perl, but the author notes Argon2 is the recommended choice for modern memory-hard password schemes.

Crypt::Passphrase is a lightweight, backend-agnostic helper for hashing, verifying and migrating user passwords that lets you pick a modern encoder for new passwords while accepting multiple legacy formats for verification. You configure a single encoder for creating hashes and an optional list of validators for older schemes, and the module handles Unicode normalization, salting and peppering via encoder plugins, reports when a stored hash should be rehashed, and can recode hashes when peppering or encoding formats change. It does not implement hashing algorithms itself so you plug in CPAN encoders such as Argon2, Bcrypt, Yescrypt, PBKDF2 or system crypt, and it provides convenience helpers to integrate with ORMs and web frameworks. Recent updates improved the randomness source by switching to Crypt::SysRandom and added support for recoding hashes and broader system-crypt compatibility, making it a practical choice for applications that need a simple, future-proof password strategy.

SIRTX::VM is a Perl toolkit for working with SIRTX virtual machine code, offering assembly and disassembly support, opcode and directive handling, label and register management, and facilities for embedding and extracting chunks, resources and metadata. It is aimed at developers building or manipulating SIRTX VM binaries and assembler/disassembler tools and integrates with Data::Identifier::Interface::Userdata so identifiers and user metadata can be attached to VM objects. Recent updates add multi-input support to the assembler, many new logical registers and directives, and improved register allocation that reduces output size and speeds execution.

Pod::CopyrightYears is a small utility for updating copyright years inside POD or Perl module files. You construct it with the path to the POD or module file and optional settings such as which "=head1" sections to target, then call change_years with the current year and it will locate four digit years or year ranges in those sections and update them to include the new last year, turning a single year into a range when appropriate. The module can return the matching Pod::Abstract nodes via license_sections and serialize the updated POD or module text with pod so you can save or display the result. It is useful for maintainers who want an automated, scriptable way to bump copyright years in documentation.

Config::Model is a Perl framework for defining, validating, migrating and interactively editing application configuration through declarative models. You describe your configuration as Perl data structures that specify tree structure, element types, constraints, defaults and help text, and the framework generates a validation engine plus editors and tools that operate on that tree. It supports multiple storage backends (INI, Perl data, plain files and integrations such as Augeas) and provides generated interfaces including a shell-like UI, curses, Tk and a FUSE view, together with a command-line helper (cme/App::Cme) and a programmatic API to load, modify and write back configurations. The model-driven approach keeps validation rules separate from processing code which makes upgrades, migrations, auditing and consistent user interfaces much easier to implement and maintain. Recent releases added Loader and value-model improvements, notably an update parameter to control how values are loaded from INI, YAML, JSON or TOML during bulk updates, plus optional parsers to reduce hard dependencies. If you need robust, model-based validation, automated migration and interactive editors for diverse configuration formats, Config::Model is a practical, well‑established choice.

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.

Test::HTTP::Scenario lets you capture real HTTP interactions once and replay them in tests so your API client behavior can be exercised offline, quickly, and deterministically. You wrap a test block with with_http_scenario to run in record mode, which performs real requests and writes normalized request/response pairs to a fixture file, or in replay mode, which intercepts requests and returns reconstructed responses from that fixture. The module plugs into HTTP client libraries via adapters (LWP is provided) and stores fixtures with serializers (YAML by default, JSON available). It includes helpful features for test hygiene such as strict mode to ensure all recorded interactions are consumed and diffing to show detailed mismatches. One limitation to note is that matching is currently based on HTTP method and URI only.

Crypt::Bear provides a Perl interface to the BearSSL cryptography library, giving Perl programs a usable SSL/TLS implementation plus direct access to cryptographic primitives such as symmetric and asymmetric encryption, hashes, a cryptographically secure random number generator, and basic certificate handling. It is useful when you want BearSSL functionality from Perl code or need a lightweight, embedded-friendly TLS option while still being able to access lower-level crypto operations. The module exposes its runtime configuration via a get_config method that returns a hash of settings. This is an early release (v0.004) by Leon Timmermans and is distributed under the same license terms as Perl 5.

greple is a powerful, extensible grep-like tool written in Perl that adds lexical-expression support and region/block handling to let you perform sophisticated text searches and post-process matches. It is aimed at developers and power users who want more than basic pattern matching, offering modular extensions, callbacks, capture-group and DEFINE pattern support, rich formatting and color controls, block/paragraph extraction, and options for selective indexing and result transformation. The project is mature and actively maintained; recent releases added a --filter (-F) mode to use greple as a streaming filter and a --version flag, and v10 raised the minimum Perl requirement to 5.24 to enable newer language features. If you need a highly configurable, scriptable search tool that integrates custom modules and advanced regex capabilities, greple is worth trying, while a plain grep may be simpler for basic one-off searches.

Git::Server is a drop‑in replacement for a standard Git server that gives you much finer control over repository access and automation by extending server-side hooks, ACLs and deployment/webhook capabilities. It runs as the SSH command handler and ships helper tools like a git-client wrapper and git-deploy so you can enforce per-user and per-branch rules, restrict pushes to particular files or email addresses, whitelist client IPs, and trigger instant deployments or HTTP webhook notifications with rich metadata about the push or pull. The module is aimed at administrators and small teams who want stronger, configurable server-side policy and automated workflows without adopting a full hosted service, and it favors compatibility and lower dependency than alternatives such as Git::Hooks. Recent releases focus on more consistent messaging and logging, improved webhook payloads (including server-side timing and version info), better handling of git-client options and chdir behavior, and fixes for security and compatibility around branch and ref handling.

File::Access::Driver is a convenience Perl class that bundles common file operations into a single, easy API so you can create, read, write, delete and inspect files with far less boilerplate. You can construct it with a full path, directory or filename and change those later with setters that automatically manage open handles and an in-memory cache. It aims to be "batteries included" for typical file access and testing workflows, and it reports problems via getErrorCode and getErrorString instead of throwing exceptions so callers should check those after operations. Use it when you want a simple, test-friendly helper for everyday file tasks rather than managing low-level filehandles yourself.

AWS::Lambda makes it easy to run Perl code on AWS Lambda by providing a custom runtime and ready-to-use artifacts so you can deploy handlers as zipped scripts, container images, or Lambda layers without rebuilding a runtime yourself. It offers pre-built public layer ARNs, downloadable zip archives, and Docker images for Amazon Linux 2023, plus helper functions to print or retrieve the correct layer ARNs for your region and Perl version. The module includes conveniences such as preinstalled JSON and TLS modules, optional prebuilt Paws layers for calling AWS APIs, AWS X-Ray tracing support, and response streaming support, and it documents how to build custom module layers and test locally with Docker. Supported Perl releases follow the official Perl policy and the author advises migrating off older legacy layers for Amazon Linux and Amazon Linux 2 because those legacy layers are no longer maintained.

IO::Trace is a small Perl utility and module for recording a spawned program's standard I/O activity so you can inspect reads, writes and closes on STDIN, STDOUT and STDERR without modifying the data streams. Its log format is modeled on Linux strace but is implemented with IPC::Open3 rather than ptrace, making it portable across Windows, macOS, Linux and other platforms. Use it when you need a cross‑platform way to capture and replay terminal I/O for debugging or auditing, but note it only records the three standard streams and will break commands that need a real TTY on STDIN. Recent updates added a -V version flag, improved compatibility with older Perl and Getopt::Long versions and with newer strace releases, and added options like redirecting output to a file.

Parse::PMFile reads a Perl .pm file and extracts the package names and version information using the same logic PAUSE uses to index CPAN, making it useful for tooling that needs reliable, PAUSE-compatible package and $VERSION discovery. It returns structured information about all packages found and can optionally report malformed versions, enforce PAUSE permission checks when given a USERID and PAUSE::Permissions object, and preserve developer underscore versions if requested. The parser uses Safe evaluation where possible and offers an UNSAFE mode to fall back to plain eval for older Perls, and it avoids forking by default for simpler operation. The code is largely derived from PAUSE so behavior is stable, and recent releases improved class and role detection, strip BOMs before scanning, and ensure versions stringify correctly for JSON output. This module does not extract distributions or parse meta files, so it is best when you only need accurate package/version parsing of .pm files.

EMDIS::ECS is a Perl implementation of the EMDIS Communication System that lets organizations exchange EMDIS messages securely using encrypted email and, optionally, AMQP messaging. It integrates with SMTP for outbound mail and IMAP, POP3, or a directory-based inbox for incoming mail, supports PGP and GnuPG encryption and signatures, and includes daemons and utilities for scanning mailboxes, processing messages, handling sequencing and automatic resend requests, and managing node configurations via a NODE_TBL. The distribution also provides tooling such as ecs_setup and ecstool, examples for Docker deployments, and support for document exchange and OAuth2 authentication for cloud mail providers. You will need Perl, an SMTP server, and PGP/GnuPG installed to use it, and GnuPG 2.2 may require a small configuration change to accept passphrases. This module is aimed at sites that need an EMDIS-compatible, scriptable messaging system and is generally compatible with the original specification while adding practical extensions and experimental features.

Lilith is a Perl utility for ingesting EVE JSON logs from Suricata, Sagan and CAPE into PostgreSQL and then letting you create, search and extend that data store from Perl. It provides helpers to create the required tables, a run method that reads named EVE files and inserts events, options to ignore specific SIDs or classes, and a search wrapper that accepts high level filters for IPs, ports, signatures and more so you can pull matching rows without hand‑writing SQL. There are convenience methods for mapping rule classes to short or SNMP‑friendly names and a backfill/extend mode to reprocess recent minutes of logs. In the 2.0.0 release the internals were moved to DBIx::Class::Schema and the search behavior was reworked to leverage that, making query handling more robust. If you operate Suricata/Sagan/CAPE and want a Perl‑centric path to store and query EVE alerts in Postgres, Lilith is designed for that workflow.

Simple::Accessor is a tiny, zero‑dependency Perl module that gives you a minimal object layer with automatic accessors and a constructor so you can declare attributes with a single use line and immediately get new and get/set methods. It merges attributes declared across multiple use statements and supports per-attribute default builders named _build_<attr> so you can supply lazy defaults without boilerplate. You can hook into object creation with build, _before_* and _after_* callbacks and use _validate_* hooks to veto bad values, with the _after_* hooks protected against re-entrant recursion. An optional strict constructor mode lets you catch typos in attribute names at construction time. The module is intentionally small and well suited for scripts or projects where heavier object systems feel like overkill.

TimeDate is a compact Perl toolkit for parsing, formatting and converting dates and times. It bundles Date::Parse to convert a wide range of human readable date strings into Unix timestamps or component values, Date::Format to render timestamps or localtime arrays with familiar strftime-style formats, Date::Language to format and parse dates in over 30 languages, and Time::Zone for named timezone offset lookup and conversion. Use it when you need reliable parsing of many input date forms, consistent formatted output, or simple internationalization and timezone handling in scripts and applications.

Safe::Hole provides a controlled way for code running in a Safe sandbox to invoke subs and object methods back in the original main namespace, effectively creating a deliberate escape hatch so sandboxed code can use trusted routines or objects without running them inside the Safe compartment itself. You can call a code reference through the hole or create wrapper objects so that method calls are dispatched outside the sandbox, and the module can optionally restore aspects of the calling environment such as the opcode mask, %INC and @INC. Use is simple: new constructs a hole, call invokes a code ref through it, and wrap produces callable wrappers for subs or objects. The module warns that you must not share the Safe::Hole object into the Safe compartment itself because that defeats the sandbox, and it includes fixes to catch and rethrow exceptions correctly and to preserve environment state. Safe::Hole is useful when you need sandboxed code to reach back to trusted code while keeping most sandbox restrictions in place, but it should be used with care because it deliberately bridges those restrictions.