CPANscan

Tk::ListBrowser is a flexible Perl/Tk widget for displaying lists of items with text and images in multiple layouts, including single-column lists, two-dimensional rows or columns, horizontal bars, and hierarchical tree or hlist views. It gives you per-item data, side columns and configurable headers that can be resized, reordered and made sortable, plus built‑in sorting and case or numerical options, keyboard and mouse navigation, selection modes, and a quick filter entry (Ctrl+F) for live searching. You add items programmatically and call refresh to rebuild the view, or use the incremental refreshPurge for larger data sets, and there are many options to tune cell size, padding, wrapping and indicator icons for tree nodes. The widget follows familiar Tk list conventions and is useful whenever you need a rich, icon-capable list or tree in a Perl/Tk GUI. Note that using custom fonts can slow refresh performance.

Imager::File::TIFF adds TIFF read and write support to the Imager image toolkit, letting you load and save .tif/.tiff files through Imager objects with familiar read and write calls. It exposes class methods to inspect available compression codecs so you can choose a compression by name or numeric code, and it reports the libtiff build date and version used at compile time plus the runtime libtiff version so you can detect library differences at run or install time. Usage and details are documented under Imager::Files and the module relies on libtiff for the underlying TIFF handling, with buildversion information available when using libtiff 4.5.0 or newer.

Imager::File::JPEG is the Imager plugin that lets Perl programs read and write JPEG images and query which libjpeg implementation was used to build it. It integrates with Imager's read/write API while exposing helper methods to report the libjpeg variant and version and to detect features such as mozjpeg/turbojpeg and support for arithmetic coding. The module also exposes a range of JPEG tuning options exposed by the underlying library, including progressive output, optimization, restart markers, smoothing and subsampling, and mozjpeg-specific knobs when available. It auto-detects the system libjpeg at build time and falls back to bundled checks where needed. The latest release fixes a memory leak when reading JPEGs containing multiple IPTC/APP13 blocks, addressing CVE-2026-13708, so it is recommended for users who need robust JPEG handling in Imager.

Imager::File::GIF is the Imager extension that adds GIF input and output to the Imager image toolkit, letting Perl programs read and write GIF files through the familiar Imager API (for example $img->read(file => "foo.gif") and $img->write(file => "foo.gif")) and report failures via $img->errstr. It plugs into Imager::Files so you can handle GIFs alongside other image formats when loading, saving, or converting images in Perl scripts.

Imager is a mature, full‑featured Perl module for creating and manipulating raster images that can read and write many popular formats, draw shapes and text, apply filters, scale and crop, blend images, work with palettes and alpha channels, and access image metadata, all with a consistent, scriptable API and optional C-level extensions for performance. It is a good choice if you need programmatic image processing from Perl and want more control than simple libraries provide, while still having broad format support and font rendering built in; alternatives include GD and Image::Magick if you prefer different tradeoffs. The project is actively maintained and has a broad set of submodules for file I/O, transforms, filters and engines, and recent releases have focused on robustness and security, with the 1.032 update fixing several memory and buffer issues including CVE-2026-13708 and CVE-2026-13705. Support is available via a developer mailing list and a GitHub issue tracker, and the documentation and cookbook provide practical examples to get you started.

App::HTTPThis implements the logic behind the http_this command to provide a tiny local web server for serving static files and directory listings. It is essentially a thin wrapper around Plack::App::DirectoryIndex and uses Plack::Runner to start the server, so most of the heavy lifting is handled by Plack. You interact with it via the http_this command rather than calling the module directly, and it supports features like prettier directory listings, optional autoindexing, a configuration file with command-line options taking precedence, and optional Bonjour name advertisement. Recent updates added a --host option and made it clear the default is to bind to all network interfaces. This is a handy, low-friction tool for quickly sharing files or testing static sites during development.

Plack::App::DirectoryIndex is a PSGI app for serving static files with Apache-style directory indexing. It will serve a default index file like index.html when present and otherwise render a directory listing, with optional Font Awesome icons and a prettier CSS theme. You point it at a document root and can customize the index filename or disable index handling, making it a convenient drop-in for sites that need sensible default index behavior. If you only want raw directory listings use Plack::App::Directory and if you only want to serve files use Plack::App::File.

Ascii::Text builds decorative ASCII-art text from plain strings using multiple fonts and styling options. You create an Ascii::Text object, set properties like font, alignment, left padding and ANSI color and then call render to print to the terminal or to a filehandle, or use stringify or an array reference to capture output instead of printing. The module respects terminal width by default, lets you override line width and inter-word spacing, and allows custom color maps and font listing. It is handy for generating CLI banners, section headers and other stylized console output with minimal code.

VAPID is a Perl implementation of Voluntary Application Server Identification that makes it easy to send Web Push notifications directly from your server without routing through services like Firebase. The module helps you generate and validate VAPID key pairs, encrypt message payloads using ECDH and AES-GCM, validate browser subscription objects, and either build a ready-to-send HTTP::Request or perform the send for you with a single call. It also exposes a legacy header generator for custom or backward-compatible flows but that helper does not handle payload encryption. Recent releases include small packaging fixes to archive headers.

POD::Generate is a small, practical Perl utility for programmatically building Plain Old Documentation (POD) so you can generate standard NAME, SYNOPSIS, DESCRIPTION, METHODS and other sections from code or tooling instead of hand writing POD. It provides a fluent API to add headings, paragraphs, verbatim blocks and list items, offers callbacks for customizing how each POD element is rendered, and can output the result as a string, append it to a module file that contains an __END__ marker, or write a separate .pod file. It is aimed at module authors, code generators and build scripts that need to emit conventional Perl documentation automatically, and the recent 0.03 release removed PAX headers to improve packaging.

Backblaze::B2V4 is a Perl client for Backblaze B2 Cloud Storage that implements the B2 V4 API and makes common tasks like creating and deleting buckets, uploading normal and large files, listing files and metadata, and downloading by name or file ID straightforward. The module handles authentication with your application key and key id, retrieves bucket-specific upload URLs and tokens for uploads, and defaults to Backblaze server side encryption for new buckets. It also includes a simple b2_client command line tool for quick get and put operations and a generic send_request method so you can call any B2 API endpoint the module does not wrap. If you already use Backblaze’s S3-compatible interface you may choose an S3 client instead, but this module focuses on the native B2 API and depends on standard Perl HTTP and JSON libraries while exposing methods for status and error reporting.

Git::Database is a lightweight Perl interface for working with the low level object database inside a Git repository, letting Perl code read, write and inspect blobs, trees, commits and tags without tying you to a single Git library. It acts as a factory so calling new returns a backend object that actually talks to Git; you can supply an existing store object or tell it a backend name and a work tree or git directory, or let it auto-select the best available backend for your environment. Backends implement roles for hashing objects, reading and writing objects, and reading and writing refs, so the exact feature set depends on the chosen backend but covers all the common repository operations. This module is useful for Perl developers who need programmatic, backend-agnostic access to Git internals and includes a tutorial and several backend implementations on CPAN.

JSON::Any is a lightweight compatibility wrapper that lets Perl code talk to whatever JSON backend is installed by exposing a single, familiar API for encoding and decoding data. It provides methods like objToJson/jsonToObj and interchangeable aliases such as encode/decode, Dump/Load and to_json/from_json so your code will work whether Cpanel::JSON::XS, JSON::XS, JSON::PP, JSON or JSON::DWIW is present. You can control which backends are preferred by passing an order on import or via the JSON_ANY_ORDER environment variable and the module will fall back to a reasonable implementation and even try to ensure JSON::PP is available at install time. The module handles differences in boolean and utf8 handling across implementations and exposes the underlying handler when you need it. JSON::Any is now deprecated in favor of JSON::MaybeXS for new code but is still maintained for compatibility and for rare cases where older backends are desired. Note there are known interoperability caveats, for example older JSON.pm versions can conflict with newer JSON::XS releases, and recent maintenance has added support for JSON/XS v3 and v4 and fixed test issues with JSON::XS >= 4.0.

Data::Pool::Shared is a Linux-only, 64-bit-Perl module that implements a fixed-size, cross-process object pool in shared memory so multiple processes can allocate, use, and free slots much like a heap allocator. It ships a raw-byte pool plus typed variants for int64, int32, double, and fixed-length strings, with atomic operations on the integer variants and zero-copy reads via an SV backed directly by the slot memory. Allocation is lock-free via a CAS bitmap with futex-based blocking when the pool is full, and it supports batch alloc/free, memfd or file-backed and anonymous modes, exposure of raw pointers for FFI, guard objects for auto-free, and eventfd integration for event-loop wakeups. The pool records allocator PIDs and offers recover_stale to reclaim slots from dead processes for crash recovery. Be aware the shared mmap is writable by any process that can open the backing file, so do not share it with untrusted processes. A recent addition, scan_from($slot), lets a handle pin its scan start to produce deterministic, low-to-high allocation order instead of the default getpid-derived spread.

Algorithm::Classifier::IsolationForest is a Perl module for unsupervised anomaly detection that implements the original Isolation Forest and the Extended Isolation Forest variants to find outliers in multivariate numeric data. You train it with an array of numeric vectors and it builds an ensemble of random trees where points that are isolated quickly get high anomaly scores between 0 and 1, while typical points score below about 0.5. The module offers configurable parameters such as number of trees, sample size, random seed for reproducibility, mode (axis-aligned or oblique hyperplane splits), and an optional contamination setting that learns a score threshold for flagging anomalies. Common methods include fit to train the model, score_samples to get per-point anomaly scores, predict to return 0/1 labels, path_lengths for inspection, and JSON save/load for persisting models. Extended mode removes the axis-aligned bias of classic Isolation Forest and often performs better on elongated or multi-modal data, making this a practical choice for detecting anomalies in many real world datasets.

HTML::Gumbo is a Perl wrapper around Google's Gumbo C library that brings a fast, robust, and HTML5‑conformant parser to Perl programs. It can parse HTML into a rebuilt string, drive a callback-based event stream similar to HTML::Parser, or produce an HTML::Element-based tree though the tree output is still experimental. The module accepts different input types and encoding hints so you can feed it decoded Perl strings, raw octets, or trusted UTF-8, and it supports fragment or full-document parsing. Some advanced features of the underlying C library are not exposed or fully implemented here, including source location pointers, full encoding sniffing and nested browsing context handling, and SVG/MATHML fragment testing, and the tree formatter and fragment enclosing tag handling are noted as alpha, but for most uses this module provides a simple way to use a production-tested HTML5 parser from Perl.

Alien::SNMP is an Alien::Base style Perl distribution that downloads, builds and installs the Net-SNMP C library and its Perl bindings so your Perl SNMP code can run on systems that lack libnetsnmp. It exposes simple methods like bin_dir to locate Net-SNMP command line tools and cflags and libs to provide the compiler and linker flags you need, and it is intended to satisfy the dependency for the SNMP.pm extension. The packaged build is tailored for use as a lightweight library and developer kit by enabling IPv6, Perl modules and Blumenthal AES while intentionally disabling the SNMP agent, manuals, scripts, MIBs and embedded Perl.

Alien::LibGumbo is a helper module that installs the libgumbo C HTML parsing library on your system so Perl bindings like HTML::Gumbo can find and use it. It does not itself parse HTML or provide parsing APIs but instead builds and provides the native library at install time. This distribution uses the actively maintained fork of libgumbo by Grigory Kirillov rather than the now-archived Google original, so you get a recent upstream release. If your goal is to parse HTML in Perl, reach for HTML::Gumbo; use Alien::LibGumbo when you need the underlying native library made available to Perl modules.

Data::Intern::Shared is a Linux-only, 64-bit Perl module that provides a shared-memory string interning table so multiple processes can agree on compact uint32 ids for arbitrary byte strings and map those ids back to the original bytes. It stores each distinct string once in an append-only arena and returns a dense id for lookups, which makes it efficient to store string keys as small integers in other shared structures such as Data::SortedSet::Shared. Lookups are O(1) via an open-addressed hash and mutation is protected by a futex-based write-preferring rwlock with dead-process recovery, so many processes can intern and query concurrently; the table supports anonymous mappings, file-backed maps, and transferable memfds. Interning is permanent and ids never change, capacities for number of strings and total string bytes are fixed at construction, keys are compared by raw bytes so wide strings must be encoded beforehand, and the empty string and embedded NULs are supported. The module is designed to be crash-consistent up to the last completed intern operation but does not detect PID reuse, and the author warns not to share writable mappings with untrusted processes. Initial release 0.01 published 2026-06-23.

Params::Get provides a single helper, get_params, that normalises a Perl subroutine's arguments into a single hash reference so your public methods can accept and handle any common calling style without repeating parsing code. You can pass it @_ or a reference to @_ and it will accept a lone hashref, named key/value pairs, a single scalar that becomes the value for a default key, an arrayref shorthand, a mandatory positional value followed by an options hashref, scalarrefs, blessed objects or coderefs, and it returns a consistent hashref for validation or further processing. The $default argument may be a string, undef, or, as of the recent 0.15 release, an arrayref of positional key names to map positional arguments into named fields. The module reports errors clearly when the caller uses an unsupported convention and documents a few corner cases such as the ambiguity of a single empty arrayref and the fast-path where a lone hashref bypasses default-key wrapping. The 0.15 update also fixed caller-variable mutation bugs and removed a problematic Devel::Confess dependency in favor of Carp::confess.

Aion::Format is a compact toolbox of text and number formatting helpers for Perl that makes command line output, logging and light text processing easier. It provides color-aware printing and logging helpers, human-friendly size, interval and rounding formats, number formatting and radix conversion utilities, Roman numeral conversion, Russian transliteration, and small wrappers for Data::Printer plus safe STDOUT/STDERR capture helpers. It also includes a simple template-to-regex helper aimed at extracting fields from HTML and convenience routines to convert Perl string literals. If you write scripts that need prettier terminal output, readable numeric units, quick data extraction from HTML, or simple transliteration and formatting utilities this module is a practical, lightweight choice. Recent tweaks include safer handling of STDOUT/STDERR in the capture helpers to avoid leaks on exceptions and a small configuration change to use Aion::Env::Etc.

Aion::Emitter is a lightweight, annotation-driven event dispatcher that calls listener methods based on the class of an event object. You create a plain event object, register listener methods by annotating them with #@listen, and then call emit with the event and an optional qualifier key to invoke matching listeners. Listeners are represented by single long-lived objects, and handler methods typically mutate the event object so the emitter can inspect results after dispatch. The optional key lets you scope delivery to a subset of handlers when you need targeted notifications, for example per controller, and may contain letters, numbers, underscores, dashes, colons and periods. Use Aion::Emitter when you want a simple publish/subscribe pattern integrated with Aion that relies on source annotations rather than manual wiring.

CGI::Session is a mature Perl module that gives CGI programs a simple way to persist user-specific data across HTTP requests by creating, loading and storing session objects tied to cookies or query parameters. It uses a modular backend system so you can store sessions in plain files, BerkeleyDB, MySQL, SQLite or other drivers and choose different serializers and ID generators to match your needs. You interact with a session by getting and setting named parameters, expiring whole sessions or individual keys, deleting sessions, and emitting the correct cookie header with header(). There are helpers to copy query parameters into a session and to load them back into a CGI object and a find callback useful for batch housekeeping such as purging old sessions. The module recommends calling flush() explicitly because automatic flushing can be unreliable and also documents UTF8 considerations for handling non-ASCII data. Overall CGI::Session is a practical, configurable solution for adding server-side session state to classic CGI applications.

Term::CLI is a compact framework for building interactive command‑line programs in Perl that wraps Term::ReadLine to provide a ready REPL with command dispatch, argument parsing, tab completion, history, paging and signal-safe cleanup. You describe commands as Term::CLI::Command objects and supply callbacks to handle parsed options and arguments while the library handles prompts, word splitting, quoting and escaping for completion, reading and writing a history file, and optional external pagers. It works with Term::ReadLine::Gnu or Term::ReadLine::Perl and exposes hooks to customize the split function, quote characters, word delimiters, pager, prompt and history behavior, plus a cleanup callback for graceful exit. Note that its default I/O handle behavior differs from some readline implementations so you may want to set filehandles explicitly to ensure UTF-8 I/O behaves as expected. If you need a small, extensible foundation for building interactive shells with tab completion and history support, Term::CLI provides a well-documented, example-driven starting point.

Config::INI::RefVars is a Perl INI file reader that adds powerful variable interpolation and Make-like assignment operators so you can reference other INI variables, environment values, or Perl Config entries inside your config files. It supports lazy and immediate expansion via operators like = and :=, conditional defaults ?= and ??=, appending and prepending (.=, +=, .>=, +>=), includes, line continuation, and user-defined functions with a built-in function dispatcher, and it can copy a special tocopy section into every section or treat those values as globals. You feed it a filename, string, or array and it returns a hashref of sections to key/value pairs, and you can customize behavior with options for custom builtins, a section separator, comment handling, and variable name validation. The parser reports syntax errors, recursive references, unknown functions and similar problems by throwing exceptions, and a failed parse may leave the object unusable so callers should recreate the object after errors.

File::FStore is a toolkit for managing a hash-based, final-state file repository in the Fellig format where files are treated as immutable and tracked by cryptographic digests and a small set of integrity-focused metadata. It lets you create and open stores, query files by digests, properties or identifiers, run transactions, and perform maintenance tasks like scanning, scrubbing and fixes to repair or rebuild links and metadata. The module integrates with Data::TagDB for richer metadata, File::Information for file analysis and Data::URIID for extraction, and it exposes helpers to add new digests and to run migrations and exports, although some helper methods are marked deprecated and the add_digest API is experimental. Use File::FStore when you need a durable, integrity-checked file store with digest-based lookup and basic lifecycle tools, and use companion modules if you require more extensive tagging or metadata features.

Zuzu is a small Perl helper for running ZuzuScript from Perl programs. It offers zuzu_eval to parse and execute a script string and zuzu_evalfile to load and run a UTF-8 script file, with both returning the evaluation result and accepting runtime options such as module denial and additional library paths for sandboxing or extending the environment. Use it when you need quick one-shot execution of ZuzuScript, lightweight integration into Perl tools, or simple testing of Zuzu code.

SPVM::Go brings the Go language style of concurrency to SPVM, providing a Go class that lets you spawn lightweight goroutines, create buffered or unbuffered channels, perform select-style multiplexing, and coordinate work with wait groups, timers and contexts. It exposes scheduler primitives to yield and to block on IO with optional timeouts, plus sleep helpers and signal utilities, and ships companion modules such as Go::Channel, Go::Select, Go::Sync::WaitGroup, Go::Time and Go::Context. The implementation builds on coroutines so you can use familiar Go patterns inside SPVM programs, and note that some scheduler operations must be invoked from the main thread. Development and examples are on the project GitHub and runtime debugging can be toggled with the SPVM_GO_DEBUG environment variable.

Map::Tube::Generic is a lightweight wrapper that lets you pick a metro network at runtime and then find shortest routes between stations using whatever concrete Map::Tube implementation you choose. You construct it by naming a location or by supplying an existing map object, and most calls are simply delegated to the underlying map module so you get the network features without hardcoding a specific implementation. The module also provides utilities to discover available map modules across namespaces and to check which features a chosen map supports, but XML and JSON map input are not yet implemented. Errors are raised if a requested map module cannot be found or loaded. This is the first public release (version 0.1.0) and is intended for cases where you want runtime flexibility in selecting or enumerating metro network backends.

CVSS is a Perl module for calculating Common Vulnerability Scoring System scores and converting between representations such as vector strings, JSON and XML. It supports CVSS versions 2.0, 3.0, 3.1 and 4.0 and offers both object oriented and simple functional interfaces so you can build metrics programmatically, parse an existing vector string, or generate a vector string from metric parameters. From a CVSS object you can obtain base, temporal and environmental scores, the qualitative severity label and the individual metric values, and the module includes convenience helpers like decode_cvss, encode_cvss and cvss_to_xml. The implementation follows the official FIRST CVSS specifications, is open source, and is listed by FIRST as a community CVSS calculator library.