CPANscan

Catalyst::Plugin::I18N adds internationalization support to Catalyst apps by letting you use gettext-style .po/.mo files or Locale::Maketext lexicons under your application's I18N namespace and calling $c->localize (or its alias loc) from controllers or templates. It provides helpers to get and set available languages, return the current language or a language tag, and enumerate installed languages with readable names based on I18N::LangTags::List. You can tweak how translations are handled by passing maketext_options to control Locale::Maketext::Simple behavior and the plugin includes an i-default fallback to your MyApp::I18N so missing keys can fall back sensibly. A recent update added an Installed Languages feature and improved i-default fallback handling.

WebService::OPNsense is a lightweight Perl client for the OPNsense REST API that gives you convenient, lazy access to the firewall appliance from scripts and automation. Built with Moo and reusing WebService::Client, it authenticates with an API key and secret over HTTP Basic Auth and exposes controller objects for common areas like firewall rules, system status, DNS/DHCP, IPsec, OpenVPN, captive portal, traffic shaping and backups so you can query and manipulate the appliance without handcrafting HTTP calls. The module is alpha quality and the OPNsense API itself is not versioned so upgrades to the firewall can require updates to the client, but the author actively maintains it and the recent 0.003 release fixes endpoint path mismatches and adds example scripts for reverse DNS and service info.

Math::Float32 provides an object-oriented Perl interface to IEEE 754 single-precision (_Float32) numbers so you can create and manipulate true 32-bit float values from Perl. You make Math::Float32 objects from integers, strings or Perl floats and inputs are rounded to 24 bits of precision using round-to-nearest, ties-to-even, so avoid double rounding by passing a string when you need an exact bit pattern. The module overloads arithmetic and comparison operators and common math functions so you can use normal + - * / % ** comparisons and functions like log, exp, sqrt, abs and int while preserving single-precision semantics. It understands IEEE special values such as NaN, signed zero and +/-Inf and provides helpers to inspect and modify bit patterns, pack and unpack hex encodings, convert to Perl NV, and step to the next representable value with flt_nextabove and flt_nextbelow. Operations involving Math::Bfloat16 defer to that module and return bfloat16 objects. Use Math::Float32 when you need precise single-precision behavior for testing, interoperating with C floats, or exploring numeric edge cases; for ordinary high-level numeric work Perl's native double precision will usually be sufficient.

Tk::DocumentTree is a Perl/Tk megawidget that gives you a compact, scriptable document tree for GUI apps by combining a label with a folder/file browser. It automatically builds a folder view from added paths, highlights files that are modified or missing (marked as untracked), and exposes simple methods for adding, deleting, showing and selecting entries as well as collapsing and expanding folders. You can customize icons and selection behavior via callback options and a right‑click context menu, and retrieve lists of tracked or untracked files for integration with other code. The module was recently reimplemented on top of Tk::ListBrowser instead of Tk::ITree, which brings built‑in filtering support and improved behavior. If you need a lightweight document browser widget for a Perl/Tk application, this provides ready‑made UI and programmatic hooks to manage and display project files.

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.