CPANscan

Net::DHCP (via Net::DHCP::Packet) provides a simple object representation of a DHCP message following the RFC 1533/2132 formats so you can build, inspect and emit DHCP packets from Perl code. It gives you high‑level methods to set common header fields, add or remove DHCP options in either human‑readable or raw binary form, pack and unpack packets for wire I/O, and work with suboptions and IPv4 address fields when you need finer control. The module is useful for writing DHCP clients, servers, testers or protocol analyzers and includes helpers and tests for working with real packets. The recent 0.8 release modernizes the constructor, tightens option handling and comparisons, adds suboption helpers and safer length checks, and cleans up tests and exports for more robust and maintainable use.

Conf::Libconfig is a Perl wrapper around the libconfig C library that lets Perl programs read, write and manipulate structured configuration files using familiar scalar, array and hash types. It supports loading configs from files or strings, fetching values or whole arrays and hashes, adding and modifying nodes, deleting entries, and writing back to disk, plus error reporting and source location info. Newer libconfig features are exposed too, including include directories, option flags, automatic type conversion, float precision and numeric output formats, as well as custom hooks and destructor callbacks. This module is a good fit if you want a compact, C style configuration format that is easy to share with C or C++ code or if you need typed config values rather than plain text only. You will need the libconfig library installed on your system and the module is BSD licensed.

Net::Statsd::Lite is a compact, easy-to-use StatsD client for Perl that implements the StatsD Metrics Export Specification v0.1 and can pack multiple metrics into a single UDP packet to reduce network overhead. It provides the usual metric types you expect from StatsD such as counters, gauges, meters, timings and histograms, plus a set operation for tracking uniques, and it supports sampling rates and client-side buffering with configurable autoflush and maximum buffer size. You can prefix metric names and configure host, port and protocol, and the design makes it simple to extend by subclassing if you need tagging or other vendor-specific extensions. The module expects integer values in most cases and offers an optional strict mode for type checks, but it does not enforce bit-size limits and some metric types or sampling features may not be supported by all StatsD servers. Development is on GitHub and the module requires Perl 5.20 or later.

JQ::Lite is a pure-Perl implementation of a jq-like JSON query engine that you can use as a library or via the bundled jq-lite command line, letting you run familiar dot-notation filters and pipe-style queries without installing the jq binary or any XS modules. It supports array and object traversal, optional key access, boolean selection, mapping and grouping, many of jq's built-in functions and helpers such as map, walk, group_by, sort_by, unique_by and statistical operations, and offers a REPL for interactive exploration plus decoder selection between JSON::PP and compatible backends. It is aimed at environments where external binaries cannot be installed, including minimal containers, restricted servers, CI systems and air-gapped or legacy machines, and returns native Perl scalars, arrayrefs and hashrefs so results are easy to consume in scripts.

Crypt::DSA is a Perl module that implements the Digital Signature Algorithm for generating keys, creating signatures, and verifying signatures, and it is primarily intended for working with legacy DSA data rather than new deployments. It provides a simple object interface similar to Crypt::RSA and can generate p, q, and g parameters, create DSA keypairs, sign messages or digests, and verify signatures, returning dedicated objects for keys and signatures. The heavy mathematical work is handled by the Math::Pari library while the module code itself is pure Perl. Message signing uses a SHA1 digest when you pass a plaintext message and accepts an explicit digest up to 20 bytes if you prefer. Note that q and g are 160 bits by design and you must supply the desired p size when generating keys. Because DSA and SHA1 are considered outdated for new cryptographic work, this module is best used for validating existing signatures and for interoperability with systems that still require DSA.

Crypt::Passphrase is a Perl library for managing password hashing and verification in a cryptographically flexible way. You configure one encoder to create new hashes and can register multiple validators to accept legacy or alternative hash formats so you can migrate users smoothly. The module can tell you when a stored hash should be rehashed because the algorithm or parameters are out of date and it provides tools to recode hashes when peppers change and to wrap a hash for use in frameworks or ORMs. It supports modern backends such as Argon2, bcrypt, yescrypt, scrypt and PBKDF2 as well as peppering and HSM options, but those backends are separate modules you must install. Crypt::Passphrase also handles Unicode normalization and encourages configurable, deployment-specific settings to balance security and resource use.

Dist::Zilla::PluginBundle::Author::GETTY is an opinionated, ready-made bundle that wires together the Dist::Zilla plugins Getty uses to build, version, document and release Perl distributions. It saves you from handcrafting common setup by providing sensible defaults for metadata, Git-based versioning and branch checks, PodWeaver, CPAN upload and install-after-release steps, plus conveniences for XS or Alien-backed C libraries, custom run hooks and metadata like IRC or an "adopt me" flag. The bundle is highly configurable so you can toggle CPAN uploads, include or exclude README.md, control changelog generation and tweak XS/Alien behavior without composing each plugin yourself. Recent releases add Docker build and release attributes so you can produce container images as part of your release workflow and remove some older deprecated release options.

MooX::Role::Parameterized is an experimental port of MooseX::Role::Parameterized that brings parameterized roles to Moo, letting you define reusable role templates that accept parameters and inject attributes and methods into target classes at composition time. You declare role parameters with parameter and provide a role block that receives the parameters and a simple "mop" proxy to install has, method and other role behaviors, and you can apply those roles directly with apply_roles_to_target or via the MooX::Role::Parameterized::With helper that overrides with to support applying roles (including applying the same role multiple times by passing an arrayref). The module is handy when you want to generate patterned attributes and accessors from a single role definition rather than writing repetitive code, and it interoperates with existing Moo and Role::Tiny setups while keeping the API lightweight. Recent updates added robust support for passing arrayrefs to apply a role multiple times, fixed several parameter-handling bugs, and cleaned up packaging and CI/release tooling.

Trog::TOTP is a fork of Authen::TOTP that provides a simple, RFC6238-compatible TOTP (time‑based one‑time password) implementation for Perl to add two‑factor authentication to your apps. It can generate and return binary secrets or base32 secrets for user setup, produce TOTP URIs suitable for QR codes, compute the expected code for any given timestamp, and validate user-supplied OTPs with configurable digits, period, algorithm (SHA1, SHA256, SHA512) and tolerance for clock drift. It includes debugging helpers such as a totp_debugger script and a time_for_code method to help diagnose clock or client issues, and accepts a logger callback for integration with your logging system. Note that many authenticator apps ignore custom periods and assume 30 seconds, so changing period can be problematic. Recent releases added the time_for_code and totp_debugger utilities, a return_when option for validate_otp, and in the latest update the module switched to Crypt::PRNG::rand for improved randomness.

OcToolkit is a Perl-based, Helm-like toolkit for generating, applying, validating, backing up, upgrading, and deleting OpenShift and Kubernetes resources using Template Toolkit driven YAML templates and the oc or kubectl CLI. It wraps template rendering, YAML/JSON handling and secret encoding into a configurable object that supports multi-cluster workflows, per-instance settings, and user-supplied hooks for things like URL generation, component filtering and clutter removal so you can adapt it to different environments and pipelines. The module is aimed at users who want a Perl-centric, highly customizable alternative to Helm that keeps templates under source control and can produce diffs against live clusters as part of a validate or upgrade flow. Built-in features include secret management from a directory, ordered template processing, and backup/export of live resources, and it is intended to be used via the provided ocToolkit command line wrapper. The latest 1.10 release consolidates earlier fixes and documentation improvements and adds example files, CONTRIBUTING and SECURITY guides and basic test quality tooling.

Log::Abstraction is a lightweight, flexible logging layer that lets Perl programs send messages to many kinds of back ends with a single API. It supports code references, array refs, file names or descriptors, objects, and syslog, and it can be driven from a config file or environment variables so you can change logging behavior at runtime. You control the minimum level, message format (with tokens like %level% and %timestamp%), and it provides the usual convenience methods such as debug, info, notice, trace, warn, error and fatal, plus the ability to forward high priority messages by email when mail modules are installed. If no logger is supplied it can fall back to Carp or croak depending on options, and only warnings and above are sent to syslog at the moment. The module is ideal when you need a consistent, configurable logging interface across different logging implementations.

App::DBBrowser is a terminal-based interactive database browser that lets you explore and manipulate SQLite, MySQL, PostgreSQL and many other databases via plugins without leaving the console. It provides guided menus and forms to view table schemas and rows, build SELECT/INSERT/UPDATE/DELETE statements, run joins, unions, CTEs and window functions, import and export CSV or spreadsheet data, apply filters and search-and-replace transformations, and save reusable subqueries and configuration. The tool is designed for quick, hands-on inspection and light editing of databases from the command line and integrates with Term::TablePrint, Term::Choose and Term::Form to present readable table output and interactive prompts. Recent releases made a backwards incompatible change by turning off automatic quoting of table and column names by default and moved saved subqueries to the plugin level, and also added SQL dialect support for MSSQL and DuckDB with ODBC dialect detection.

Term::TablePrint is a small Perl utility for displaying an array-of-arrays as an interactive, scrollable table in a terminal so you can browse, search and inspect rows without leaving your script. It highlights a cursored row and supports familiar navigation keys, incremental regex searching, optional per-row expansion that prints each column on its own line, and a configurable column-selection mode for narrow terminals. The module offers many display and formatting options such as trimming or truncating wide columns, handling undefined or binary fields, ANSI color support, and Windows codepage handling, and it works as a simple subroutine or as an object with overridable settings. You need Perl 5.16 or newer, decoded strings and a properly configured terminal encoding and monospaced font for correct output, making it a handy tool for quick data exploration and CLI front ends.

Sub::Middler is a lightweight Perl helper for composing middleware-style subroutine chains that lets you pre-link small stages into a single callable head with very low runtime overhead. You register maker routines that produce the actual work subroutines and then link them so each stage decides if and when to call the next stage, which makes it easy to build synchronous, asynchronous, or one-way filters and pipelines. The module avoids runtime iteration over a list of subs by weaving the chain at link time, and it exports a convenient linker helper for inline use. Recent releases added practical short cuts that let you use scalar, array, hash or simple code references to capture intermediate results and added callback-aware behaviour for easier asynchronous flows. Sub::Middler is a good fit when you want a fast, minimal, flexible middleware mechanism with custom argument semantics, and you may prefer Sub::Chain or Sub::Pipeline if you need named stages or richer runtime features.

Nobody::Util is a compact convenience toolkit of assorted helper functions from Rich Paul that gathers common conveniences and re-exports frequently used utilities so you can get a useful working environment with a single use statement. It bundles file descriptor helpers like open_fds, getcwd and nonblock, object and reference helpers such as class and safe_isa, string and list utilities like pad and lsort, version comparison with vcmp/vsort, a sortable timestamp generator serdate, file helpers including file_id and serial_maker, and simple introspection tools such as deparse and methods. Most functions are exported by default and the module also re-exports common symbols from Carp, List::Util, Scalar::Util, Sub::Util, POSIX, Fcntl, Path::Tiny and FindBin so it is convenient for quick scripts and small utilities. This is the initial 0.01 release.

Nobody::PP is a lightweight pretty-printer for Perl data structures that produces compact, readable output ideal for debugging and simple logging. It exports handy functions like pp to return a formatted string, dd and ee to print that output to STDOUT or STDERR, and ppx, ddx and eex to include the caller file and line number with the output. The loc helper builds a file:line prefix and quote and qquote produce single and double quoted Perl string literals. Derived from Data::Dump, this module is meant as an easy drop in for inspecting variables during development and is distributed under the same license as Perl.

Graphics::Framebuffer is a Perl library for drawing directly to a Linux console framebuffer, providing simple, immediate graphics without X or heavyweight toolkits. It exposes easy-to-use methods for pixels, lines, shapes, gradients, filled polygons, TrueType text, image loading, blitting and basic animation so you can build console UIs, media viewers or lightweight embedded displays. The module can run in emulation mode for offscreen testing, uses the Imager library and optional Inline::C acceleration for heavier tasks, and prefers 24/32 bit modes for best speed and compatibility. It is console only and requires a framebuffer driver and appropriate device permissions, it will not work under X/Wayland or with proprietary DRM drivers. Performance depends on CPU and whether acceleration is enabled, and the author warns that some accelerated routines and 16 bit mode conversions can behave differently so toggling acceleration may be necessary. If you need compact, software-driven graphics on headless or embedded Linux systems, this module gives a practical, well documented toolkit.

Debug::Easy is a lightweight Perl logging helper that makes it easy to add colorized, nicely formatted debug and log output to your scripts, offering multiple severity levels from ERR and WARN through INFO and VERBOSE to DEBUG and DEBUGMAX, automatic timestamps and simple benchmarking between messages, and highly customizable prefixes that can include date, time, PID, calling module, subroutine and line numbers. Messages can be single strings or arrays and the module will pretty print data structures using Data::Dumper or Data::Dumper::Simple when available, and you can direct output to STDERR or STDOUT or set per-level prefixes and a custom filehandle. It works with sensible defaults so you can get started quickly but also supports multiple independent Debug::Easy objects for different outputs. Be aware that if you fork or thread and inherit the same object you may see misaligned padding between processes so creating separate objects per child or logging to separate files is recommended. Recent updates focused on execution-speed optimizations and fixed timestamp and token formatting so the module now aims to add minimal overhead to your running code.

Imager::File::GIF is the Imager plugin that lets Perl programs read and write GIF images through the Imager framework. It provides GIF input and output support including proper handling of paletted images and transparency and works with a range of giflib versions so Imager can probe and use the system GIF library at build and runtime. Use it whenever you need GIF read/write capabilities integrated into Imager for image processing tasks. Recent releases address compatibility with newer giflib versions and include a security fix in 1.003 that closes a buffer overflow when reading images (CVE-2026-8454).

Imager is a mature Perl module for creating and manipulating full color images that makes common graphics tasks simple from scripts and web apps. It can read and write many popular formats, draw shapes and text, apply filters and blends, scale, crop and rotate, work with palettes and alpha channels, compose images together and access low level pixel samples when you need them. The functionality is split into focused Imager:: modules for files, drawing, fonts, transformations, filters and more so you can pick the parts you need while retaining a consistent API and error reporting via errstr. Imager is suitable for automating thumbnails, on-the-fly image edits, batch processing and lightweight graphics work where you want a Perl-native solution rather than calling out to external tools. The project is actively maintained and recent releases include security fixes and format updates, most recently a fix for a GIF heap buffer overflow addressed in Imager 1.031 (CVE-2026-8454).

This module is part of the AsposeCellsCloud Perl client and provides a simple Perl-facing interface to the Aspose.Cells Cloud REST API. It centralizes configuration for credentials and endpoints, offers an API factory to create service clients, and includes role-related helpers for managing access, so you can create, modify and process spreadsheets in the cloud without writing raw HTTP calls. It is useful for Perl developers who need programmatic, cloud-based spreadsheet manipulation and requires a valid Aspose Cloud account and network access to the service. Using the module lets you focus on spreadsheet logic while the SDK handles authentication, request construction and response parsing.

Data::JPack is a Perl module for packaging web application assets into standalone bundles that browsers can load without a server, letting you embed JavaScript, text, and binary resources directly into HTML or serve them as external files to avoid same-origin restrictions. It provides a simple server-side API to encode and decode packed data, with single-shot helpers and a streaming mode that writes a header, one or more data chunks, and a footer for large or incremental content. The packer is configurable with options such as an html_container path, an embedded flag to choose inline versus external output, and optional deflate compression. It integrates with Template::Plexsite and includes client-side JavaScript support via Data::JPack::App, making it useful when you need offline-capable bundles or a foundation for browser worker pools for CPU-intensive tasks.

Langertha is a unified Perl toolkit for working with large language models that hides provider differences so your code can talk to cloud and local LLMs through a single, consistent API. It supports chat, streaming, embeddings, transcription and image generation, normalizes tool and function calling across vendors, and includes an autonomous agent called Raider plus a plugin system for custom behavior. Responses are rich objects carrying text, token usage, model and timing metadata, and streaming can be consumed via callbacks, iterators or async/await; the library also includes Langfuse observability hooks and dynamic model discovery. The project covers many engines, from OpenAI and Anthropic to local hosts like Ollama and vLLM, and is intended for both production use and experimentation while still being a work in progress. The recent 0.501 update adds support for OpenAI's new Responses API to handle reasoning-only models and improves extraction and serialization of tool calls for that format.

Geo::GDAL::FFI is a Perl foreign-function interface to the GDAL geospatial library that lets Perl code read, write and manipulate raster and vector geospatial data with native GDAL drivers. It exposes high-level objects for drivers, datasets, layers, bands, features, geometries and spatial references so you can create shapefiles and GeoTIFFs, open existing files, iterate features, read raster blocks and write arrays back to disk. The module provides convenient importable entry points such as GetDriver and Open, configurable error handling hooks, and many helpers for geometry and field types so common GIS tasks are straightforward from Perl. Recent releases improved thread safety, sped up conversion to PDL ndarrays for faster raster processing and added extra geometry utilities including concave hulls and new extent helpers like GetExtent and GetExtent3D. If you need direct, up-to-date access to GDAL from Perl and want to avoid XS plumbing, this module is highly relevant.

RTIR-Extension-MISP connects your RTIR incident tracker to a MISP threat-intelligence instance so teams can pull events into RTIR, create or update MISP events from incident tickets, and see MISP event details directly on incident pages. It adds an External Feeds source to ingest recent MISP events, a MISPEventDetails widget to show threat level, analysis status, creator, and attribute counts, and Actions to create or push an RTIR object back to MISP. The extension includes Mason callbacks to let you customize what gets sent to and received from MISP without editing the plugin. Setup requires enabling the plugin in RT_SiteConfig, adding the MISP feed configuration and MISP custom field grouping, and adjusting page layouts, and you should run the database init step only once to avoid duplicate data. The recent 1.00 release updated the code for RT 6, added the new MISPEventDetails widget and improved callback handling, and makes the widget fail gracefully when MISP is unreachable.

App::SortCopies is a small command-line utility that helps you tidy a single directory by finding duplicate files and moving the extras into a newly created ./copies subfolder. It operates non-recursively so it only looks at files directly in the target directory and leaves any nested folders alone. You invoke it as sortcopies /path/to/dir and it will relocate copies for easy review or removal, making it a simple, focused tool for cleaning up duplicated files in one folder rather than a full-featured deduplication system.

Devel::Bug is a lightweight, pure-Perl inline probe you drop into assignments to print the value(s) passing through without changing program behavior, making it easy to inspect intermediate results without refactoring or adding logging calls. You call bug() in place of a value and it forwards the original value while emitting a nicely formatted representation to a filehandle (STDERR by default); it understands scalar and list contexts, supports labels and per-call or import-time options to show caller info such as package, filename and line number, and can colorize and pretty-print complex data structures with configurable delimiters and multiline layout. The probe can be renamed or suppressed on import, supports chaining to capture stages of a pipeline, and uses Term::ANSIColor and Data::Dumper by default while optionally detecting terminal width to choose a readable layout, with a toggle to disable that detection if needed.

Genealogy::Relationship::Name is a compact Perl utility that turns two generational step counts plus the sex of the second person into a human readable kinship name, so you can ask for steps_to_ancestor and steps_from_ancestor and get answers like "first cousin once-removed" in English, French or German. You create a namer object and can set a default language at construction or override it per call, and there are helper methods to list supported_languages and known_sexes so calling code can validate input. The module uses lookup tables extracted from the gedcom/ged2site codebase and currently covers relationships up to six generations in each direction, returning undef for combinations beyond that range. This initial 0.01 release packages the tables, exposes name(), supported_languages(), and known_sexes(), and includes a test suite and standard configuration and validation support.

WWW::Mechanize::Cached is a drop‑in wrapper around WWW::Mechanize that transparently caches HTTP responses so scripts can re-use pages without repeatedly hitting remote servers. You construct it like a normal WWW::Mechanize object but can pass your own cache object (CHI is recommended) or rely on the built‑in disk cache. It exposes helpers such as is_cached to tell if a page came from cache and invalidate_last_request to remove the last response, and it provides configuration for caching policy including positive/negative caching and how to handle missing, zero or mismatched Content-Length headers. Note that the module historically used Cache::Cache but supports CHI and that version 2.00 changed the default cache location to your XDG cache home (typically ~/.cache/WWW-Mechanize-Cached) and tightens cache directory permissions, so old /tmp/FileCache caches are no longer used. If you need polite, repeatable web scraping without reimplementing caching logic, this module is a convenient choice.

UUID is a Perl module for generating and manipulating universally unique identifiers in both string and 16-byte binary form. It provides RFC4122-compatible variant 1 UUIDs and supports versions 1, 3, 4, 5, and the proposed 6 and 7 formats, with convenient routines to generate, parse, stringify, compare, extract version/variant/time, and create deterministic namespace-based IDs. Random-based UUIDs use an onboard ChaCha20 generator mixed with Xoshiro and seeded from the best platform sources for strong randomness, and time-based UUIDs use high-resolution timestamps with optional persistent state so sequences survive reboots and clock resets. This makes the module a good fit when you need unique identifiers across systems or reproducible IDs for merging datasets, but note that versions 6 and 7 are not yet standardized and enabling persistence can incur a large performance hit and requires care to avoid security issues such as symlink attacks. By default nothing is exported so you only pull in the functions you need and avoid accidental clobbering of core subs.