CPANscan

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.

Amazon::S3::Lite is a compact, easy-to-use S3 client aimed at lightweight scripts and AWS Lambda functions that need the common operations of listing buckets and objects, reading and streaming objects to disk, writing and copying objects, and deleting objects. It deliberately keeps dependencies small by using HTTP::Tiny and Amazon::Signature4::Lite and supports automatic credential discovery or pluggable credentials objects so IAM/Lambda role rotation works transparently. This module is not a full replacement for Amazon::S3 or Net::Amazon::S3 since it omits advanced features like multipart upload, ACLs, presigned URLs, and other full API surface areas, but it returns convenient parsed hashrefs and is optimized for minimal cold-start and small container images. Recent releases added create_bucket and bucket notification configuration APIs and fixed a signing edge case for list_buckets, making it more useful for common Lambda and lightweight S3 workflows.

Alien::gdal is an Alien module that builds and supplies GDAL, the Geographic Data Abstraction Library, so Perl modules can find and use GDAL without requiring a system-level install. It installs the GDAL binaries and libraries and exposes helper methods to get the binary directory, the distribution directory and the optional GDAL data directory, and it can adjust your PATH so tools like gdalwarp are usable from Perl. You can pass custom CMake options via the ALIEN_GDAL_CMAKE_ARGS environment variable and there is an experimental run_utility method for running bundled GDAL utilities. This module is aimed at Perl developers who need GDAL for Geo::GDAL or FFI-based bindings and handles many platform build quirks for shared builds and dependencies. Recent updates include support for user CMake flags and a Windows-specific change that disables PostgreSQL support on shared builds to avoid segfaults with Geo::GDAL::FFI.

Archive::Lha is a Perl module for reading and extracting LZH/LHA archives, the format once common on Amiga and MS-DOS and still used in Japan and Amiga collections. It supports header levels 0, 1 and 2 and the common compression methods lh0, lh5, lh6 and lh7 with decompression implemented in XS/C (based on LHa for UNIX), and returns filenames as UTF-8 while auto-detecting the original charset from the archive OS field (for example Amiga->ISO-8859-15, MS-DOS/Windows->CP1252, Unix->UTF-8, X68K->CP932) with an option to override encodings manually. The distribution is read-only so you can list and extract files but not create or modify archives, and header level 3 is not supported; decompression may be slower than native tools. It also provides command-line tools plha and plhasa for lhasa/LhA-compatible listing and extraction. Recent releases focused on improved Windows portability, more robust pathname handling and charset fixes, and modernized packaging and CI to make the module more reliable across platforms.

Developer::Dashboard is a Perl-based local "developer home" that collects bookmarks, notes, helper actions, path and file shortcuts, Docker Compose helpers, and small data-query tools behind a single CLI and a lightweight browser UI so your day-to-day workflows stay in one consistent runtime. It wires into your shell prompt and tmux, runs file-backed collectors to prepare cached health and status indicators for fast prompt and page rendering, and stages private helper scripts under ~/.developer-dashboard to avoid polluting the global PATH. The runtime supports layered project-local overrides, a skills system for isolated plugins, supervised background collectors with restart and crash handling, and a deliberate loopback-first access model with helper logins for non-local access. A web server listens by default on port 7890 and can use HTTPS with a generated cert, transient token execution is disabled by default for safety, and install bootstraps are provided for Linux, macOS, and Windows so it works across polyglot projects.

Apache::Session::Browseable extends Apache::Session with class-level browsing, indexing, search and cleanup methods so you can list, query and prune session records efficiently across many storage backends. It supports a wide range of databases and NoSQL stores including PostgreSQL (plain, hstore, json/jsonb and a Patroni-aware driver), MySQL/MariaDB, SQLite, Oracle, Informix, Redis and Cassandra, and lets you declare indexed fields to speed common lookups, which makes it particularly useful for session-heavy systems such as LemonLDAP::NG. The module exposes high-level operations like searchOn and deleteIfLowerThan and picks optimized implementations per backend while still letting you tune indexing for your workload. Recent releases include an important security fix that uses Crypt::URandom for stronger session id generation and improvements to Redis indexing and Patroni support, so if you need to inspect or manage large numbers of Apache::Session entries across diverse datastores this module is likely relevant.

Email::Abuse::Investigator is a tool for analysing the raw source of spam or phishing messages so you can quickly find where a message really originated, who runs the sites it links to, and which domains or addresses deserve abuse reports. You hand it the RFC‑2822 text and it walks the Received chain to pick an external originating IP, extracts HTTP/HTTPS links and mailto or bare addresses from text and HTML parts, and enriches hosts and domains with rDNS, DNS records and WHOIS/RDAP information so you can see registrars, hosting networks, abuse contacts and recently registered or suspicious domains. It also pulls server or application fingerprints from headers, computes a heuristic risk score with explicit red flags, and produces both a full analyst report and a concise abuse-report body ready to send. Optional CPAN modules such as Net::DNS, LWP::UserAgent, HTML::LinkExtor and CHI improve DNS, RDAP, HTML parsing and cross-message caching but the module works with safe defaults. The analyser can be reused for multiple messages in one process and supports IPv6 lookups, but it is not thread safe and some features depend on the optional dependencies. The code is GPL2 licensed and aimed at abuse handlers, incident responders and administrators who need a fast, automated way to turn an email into actionable hosting and contact intelligence.

Google::Ads::GoogleAds::Client is the main Perl entry point for working with the Google Ads API, providing a single object that manages credentials, OAuth handlers, and access to all service-specific client objects such as GoogleAdsService or AdGroupService. It reads configuration from a properties file or environment variables and lets you override settings like developer token, login or linked customer IDs, API version, proxy and HTTP options when you construct the client. The module exposes helpers to programmatically set OAuth2 application or service account parameters, captures the last request and response for debugging, and supports a die_on_faults mode that makes API errors raise exceptions instead of returning fault objects. You should load this client before other Google::Ads modules to avoid warnings. Use it when you need to run searches, mutations, or automate Google Ads tasks from Perl.

App::CriticDB is a tool for teams that need to run Perl::Critic across large codebases and avoid the cost of re-scanning every file each time. It collects and stores Perl::Critic violations on disk (currently using a Storable file backend), records each file's modification time so unchanged files are skipped on later runs, and can emit formatted violation reports to standard output similar to perlcritic for fast policy counts. It is aimed at incremental scanning and faster reporting across big repositories. Some features are still under development such as reliable file-deletion handling, additional storage backends and richer reporting formats, and the Data::Dumper storage option exists mainly for debugging and is much slower than Storable. There may also be edge cases around parsing perlcritic --format that the author notes.

Object::PadX::Enum is a small extension for Object::Pad that gives you familiar enum-style classes made of named singleton instances. You declare an enum with enum NAME { ... } and list item NAME(...) entries, and the module auto-creates per-item accessors plus class methods values, from_name and from_ordinal, injecting ordinal and name readers into each singleton and preventing direct new() on the enum class so the declared singletons are the only instances. It supports composing roles and simple inheritance for enum classes while keeping each enum's item sequence separate, and it works with Object::Pad fields and methods as usual, but fields you want to set from item arguments must be declared with :param. Note the singletons are constructed at runtime after UNITCHECK so they are not visible to earlier BEGIN or UNITCHECK code, and a few Object::Pad class attributes are intentionally unsupported. This initial release implements the enum and item keywords and adds :isa/:extends and :does support with optional VERSION checking.

Crypt::Argon2 is a Perl wrapper around the Argon2 key-derivation function that makes it straightforward to turn passwords into secure hashes or cryptographic keys. It supports the argon2id, argon2i and argon2d variants and provides functions to produce formatted password strings or raw binary tags, verify passwords, and detect when stored hashes should be rehashed because parameters have changed. You can tune time, memory, parallelism and output length and use the included calibration tool to find appropriate settings. The module bundles the reference implementation and can use optimized CPU variants at runtime, and recent releases fixed an out‑of‑bounds read in verification and added a function to report the active implementation. For secure results be sure to supply a unique, high-quality salt from a reliable randomness source.

Lingua::RO::Numbers is a Perl module that converts numbers to Romanian words and parses Romanian numeric text back into numeric values. It offers two handy functions, number_to_ro and ro_to_number, and can be used either as a simple functional interface or as an object with configurable options. The module handles integers, decimals, negative values and special values like infinity and NaN, and lets you customize formatting choices such as diacritics, the decimal point word, thousands separator and the negative sign so the output matches your style or locale. It is useful for producing human friendly Romanian amounts or for extracting numeric values from Romanian text. The code is open source on GitHub and is released under the Artistic License 2.0.

List::Util::MaybeXS is a drop‑in provider of List::Util functionality that automatically uses the fast XS implementations when they are available and reliable, and falls back to pure‑Perl versions when not, so you get the full set of list helpers like reduce, sum, uniq, shuffle, sample, pairs, zip and mesh across Perl versions without sacrificing performance. It chooses XS or PP on a per‑function basis to avoid introducing slowdowns, exposes a shared $RAND hook for controlling random behavior, and aims to match List::Util behavior closely. The pure‑Perl callbacks do have a minor difference in that @_ inside a callback will be empty compared with the XS variant seeing the outer @_. Recent updates fixed an issue that could leave sample and shuffle incompletely shuffled and made several numeric uniqueness checks more robust.

IO::Socket::IP provides a family-neutral socket class for Perl that transparently supports both IPv4 and IPv6 and is intended as a modern replacement for IO::Socket::INET. It uses getaddrinfo to resolve hostnames and service names and will try suitable address candidates, while offering a familiar constructor API plus extras like non-blocking connects, per-connect timeouts, custom socket options, and an IPV6_V6ONLY toggle for listening sockets. The module includes handy helpers for formatting and resolving local and peer addresses, a method to produce a legacy IO::Socket::INET wrapper when needed, and an optional -register import to make IO::Socket create IP sockets by default. Be aware that some platforms do not allow disabling IPV6_V6ONLY so you may need separate sockets to accept both v4 and v6 connections. Recent maintenance modernized the package to prefer using parent over base for inheritance.