CPANscan

RT::Extension::AttachmentViewer is a lightweight plugin for Request Tracker 6 that converts the dropzone thumbnails into clickable previews so you can open attachments at full size in a popup rather than downloading them. It supports images, PDFs, audio, HTML and text files and will fall back to a browser download for types the viewer cannot render. Installation is straightforward: add the plugin to your RT_SiteConfig, clear the Mason cache and restart your webserver, and the source code is available on GitHub. If you use RT for ticketing and want faster inline inspection of attached files, this extension removes an extra step and speeds up review. Initial release 0.01 published 2026-04-29 by Gerald Sedrati.

Text::CSV_XS is a fast, production‑quality Perl module for reading and writing comma separated value data that gives you both a low level object API and a convenient high level csv function for common tasks. It parses CSV into arrays or hashes, writes arrays or arrayrefs directly to files or scalars, and supports flexible separators, quoting and escaping rules, header detection and munging, fragment selection, and streaming for large datasets. It handles embedded newlines and binary data when run in binary mode, offers UTF‑8 and BOM support, provides hooks and callbacks for filtering or transforming rows, and exposes detailed error diagnostics so you can validate and recover from malformed input. The module is mature and actively maintained and the latest release includes a security fix for a possible stack corruption issue, addressing CVE-2026-7111.

App::PerlGlue supplies a small command-line tool called perlglue that makes common text tasks easy by letting you use Perl expressions to filter, transform, and shape line-based text, CSV-ish files, and JSON Lines in a consistent way. You can do things like uppercase or lowercase streams, print or filter lines, run regex replacements on each line, pick CSV columns by header, convert CSV rows to JSON Lines, apply simple "{{field}}" templates per CSV row, and safely rename files with Perl substitutions. It is designed for developers and ops people who find ad hoc one-liners getting hard to maintain and want a readable, scriptable interface for everyday munging. Be aware that CSV parsing is intentionally simple and uses a basic comma/quote parser, conversion currently only supports JSONL output, and filter or replacement expressions are evaluated as Perl code so you should only run them on trusted input.

Email::Sender::Transport::Mailgun is a drop-in transport for the Email::Sender framework that sends MIME messages through Mailgun's messages.mime API, exposing Mailgun options like API key, domain, delivery time, DKIM and tracking controls as simple attributes you can set in code or via environment variables. It is ideal when you want to send well-formed MIME emails through Mailgun without using SMTP headers, and it supports region selection, retrying on 5xx API errors, and reading an API key from a file for containerized deployments. This module does not implement Mailgun's full messages API features such as templated batch sends or mailing lists, so if you need those advanced capabilities consider WebService::Mailgun or WWW::Mailgun instead. Recent updates added a convenient api_key_path option to load the key from a file and automatic retries for server errors.

App::Yath::Script is the lightweight entry point used by the "yath" test-harness script to bootstrap execution, load project and user configuration, pick a harness version, and hand off control to a version-specific script module (App::Yath::Script::V{X}). It provides the two main hooks the script uses, do_begin() for BEGIN-phase setup and do_runtime() for runtime delegation, and a handful of small utilities you can call from the script such as re-execing with preserved includes, normalizing paths, finding files up the directory tree, and converting module names to file paths. The module implements a practical version-detection policy so you can select a harness version via the first CLI argument, via versioned rc files or a symlinked .yath.rc, a local checkout in ./lib, or by falling back to the highest installed V# in @INC while keeping V0 reserved for explicit validation. Recent updates improved how the version is discovered by reading versioned rc filenames and honoring user-level rc overrides, making it easier to pin or override the harness version per project or developer.

Dist::Zilla::Plugin::Docker::API is a Dist::Zilla plugin that builds and optionally publishes Docker images from the files Dist::Zilla generates so you can produce container images alongside your Perl distribution releases. You can run it during the build or release lifecycle, choose whether to build from the build tree, the project source, or the release archive, and configure repository, Dockerfile, tags, push/load behavior, build arguments and OCI labels. The plugin supports template-driven tags and metadata, can push images to a registry or load them into the local Docker daemon, uses Docker daemon or environment credentials for registry access, and streams Docker build progress to your logs. This initial release offers tag templates, multiple context modes, configurable build options and real-time progress output, making it a straightforward choice for Perl authors who want automated Docker image creation and publication as part of their release workflow.

Test2::Harness is the backend test harness for Perl that runs and collects Test2 events, manages test processes, and provides the heavy lifting behind the user-facing App::Yath tool. It handles parallel and persistent runners, preload and reload support, resource management and timeouts, rerun and retry logic, coverage integration and a plugin system for things like git and system info. The module is aimed at projects with complex test workflows where you need scheduling, resource coordination, interactive inspection or advanced reporting rather than a simple one-off test run. You will normally use App::Yath for command line interaction, but Test2::Harness supplies the runner API, logging and orchestration that make features like shared job slots, persistent runners, and coverage aggregation possible. The project is actively maintained by Chad Granum on GitHub and recent releases have focused on scheduler resilience, resource-timeout and fail-on-resource-skip options, and fixes for encoding and flaky tests to improve stability. Choose Test2::Harness when you need a robust, extensible harness with deep Test2 integration and advanced test orchestration capabilities.

API::Docker is a Perl client for the Docker Engine API that provides a clean, object-oriented way to manage containers, images, networks, volumes, and to query daemon/system information. It connects to a local Docker daemon over a Unix socket or to a remote daemon over TCP and can automatically negotiate the highest API version supported by the server. The module is a pure-Perl implementation with minimal dependencies and uses Log::Any for logging. High-level API modules and entity classes let you list, create, start, stop, and remove containers, pull and push images, manage networks and volumes, and run exec commands inside containers. TLS support and certificate paths are available but currently marked experimental. This initial release was renamed from WWW::Docker and includes an HTTP/1.1 transport with chunked transfer support, making it a lightweight choice for programmatic Docker control from Perl.

MCP::Wiki is a small server library that turns a directory of Markdown files into a manageable, editable wiki. It extracts document structure for table of contents navigation, supports fine-grained paragraph-level edits, and can record changes using a git history so you keep versioned audit trails. You run it by pointing the server at a wiki root directory and optionally enabling git, and it is useful when you need a lightweight, file-backed documentation or wiki layer that can be integrated into other tools or workflows.

Developer::Dashboard is a Perl-based local “home” for day-to-day development that centralizes bookmarks, notes, small helper actions, repeatable checks, path and file shortcuts, and Docker Compose workflows behind one browser, prompt, and CLI entrypoint. It provides a lightweight web UI (default localhost:7890), a single dashboard command with many built-in helpers for querying JSON/YAML/TOML and opening files, a prompt integration that shows cached indicator status, and a collector system that prepares background health or status checks for fast prompt and UI rendering. The runtime is layered so a project-local ./.developer-dashboard can override a shared ~/.developer-dashboard while still inheriting defaults. There is a pluginable skills system for sharing command sets and pages, safe helper staging so global PATH is not polluted, and a deliberate access model that treats loopback requests as local admin while requiring helper accounts for remote access. Although implemented in Perl, the tool is language-agnostic and useful in polyglot repositories whenever you want a single, configurable place to keep links, repeatable tasks, status probes, and developer utilities.

RT::Extension::EmailReplyDelimiter is a small Request Tracker plugin that strips quoted content and any image attachments that follow a reply delimiter when mail is received, so only the user's actual reply is stored in the ticket. You enable it by adding the plugin and a list of delimiters to RT_SiteConfig.pm; delimiters may be literal strings or regular expressions, and recent updates add robust handling for quoted-printable and base64 encoded messages and better examples for removing Outlook-generated quoted text. It is useful for administrators who want to keep ticket histories clean and avoid duplicated quoted messages, but be aware that aggressive delimiter rules can remove forwarded content in some cases; the project and issue tracker are hosted on Codeberg and it is known to work with RT 4.2.16, 4.4.4, 5.0.1, and 6.0.2.

App::ClusterSSH is the internal core library that powers the ClusterSSH family of tools which open and control many terminal sessions at once. It provides the shared plumbing for parsing configuration, resolving and managing hosts and clusters, creating and tiling client windows, handling keyboard and paste events, macro substitution, sending text or commands to multiple sessions, and other cross-cutting features used by the user-facing scripts cssh, crsh, ctel, ccon and cscp. This module is not intended to be used directly by end users or applications; use the command-line utilities instead. Recent releases have added conveniences such as an external host_sort_command for custom window ordering, options to preserve host order and accept multiple config files, a configurable main window font, and improved clipboard behavior and release tooling.

OSLV::Monitor is a Perl module that adds OS-level virtualization monitoring to LibreNMS by loading a platform-appropriate backend such as FreeBSD or Linux cgroups and polling containers or jails for status and metrics. It provides a simple API where new constructs the monitor with options to choose the backend, set a cache and output directory (default /var/cache/oslv_monitor), filter which containers to include or exclude with regex lists, and adjust timing resolution, load initializes the chosen backend, and run performs the poll and returns structured results commonly emitted as JSON. This module is useful for LibreNMS administrators and system operators who want automated, configurable collection of per-container resource and status data across FreeBSD and Linux hosts.

Data::Path::XS provides fast, C-backed routines to read, write, delete and test values deep inside Perl nested hash and array structures using simple slash-separated paths. It offers four parallel APIs: a string-path API for convenience, an array-path API for binary-safe keys or empty components, a compiled-path API for reusing parsed paths in hot loops, and a keywords API that compiles to inline ops for near-native speed. path_set will autovivify intermediate containers and key semantics follow the parent container type so numeric pieces index arrays while other pieces act as hash keys, negative indices behave like Perl arrays, and UTF-8 flags are preserved. The string syntax does not escape slashes so use the array API when keys contain "/" or are empty. Note that write operations do not invoke tied STORE methods and will croak on tied containers, and compiled path objects should not be shared across threads. If you work with JSON-like nested data and need ergonomic access with options to optimize for repeated lookups or maximum throughput, this module is a strong choice.

This Perl module is a placeholder that exists only so CPAN will index the distribution and is not normally installed on a user system. The distribution itself is a command line tool for managing SlackBuilds from SlackBuilds.org, offering commands to search, query, build, install, remove and sync package repositories, and it has seen many usability and performance improvements over time. Recent changes include a new query option to list installed SBo packages that are not in the current repo and improved verbosity around git system calls. If you expected a reusable library this module is not relevant, but consult the distribution's scripts and documentation for the actual tool.

MARC::Validator is a compact Perl toolkit for validating MARC bibliographic records by discovering and running field-specific plugins. It provides a simple API to list available validators and ships plugins that spot common cataloging issues such as malformed ISBNs, duplicate control numbers, mismatches between leader/008 and field content, missing index or illustration indicators, genre tags like comics or manga, and UDC syntax in field 080. The module uses Module::Pluggable to find plugins, produces readable reports and recommendations from each check, and is aimed at library developers and cataloguers who need automated, field-level validation of MARC data. The project is actively maintained and the recent 0.18 release tightened UDC (080) checking and fixed a plugin detection bug.

Business::UDC is a lightweight Perl class for parsing, tokenizing and validating Universal Decimal Classification (UDC) strings, returning an abstract syntax tree, a list of tokens, the original source string and any parsing error. Instantiate it with a UDC string and then call is_valid to check syntax or ast and tokens to inspect the parsed structure, which makes it handy for library cataloging tools, import/validation pipelines and any system that needs to interpret UDC notations. The module focuses on syntax-level processing rather than classification logic, and the recent 0.04 release added detection of embedded spaces that are not allowed in UDC input and expanded tests for invalid strings.

MARC::Leader is a small utility for working with the leader portion of MARC bibliographic records. It converts a 24-character MARC leader string into a Data::MARC::Leader object and can serialize that object back into a leader string, so you can parse, inspect and rebuild record leaders in scripts and data pipelines. The module validates leader length and numeric fields and reports errors for malformed values, and it offers an optional verbose mode and integration with Data::MARC::Leader and helper printers for readable output. Recent updates added stricter numeric error reporting and a few robustness fixes, making it a reliable choice when you need programmatic access to MARC leader data.

Medusa is a lightweight Perl module that adds automatic auditing to subroutines simply by tagging them with the :Audit attribute. When enabled, it logs each call with its arguments and the return values so you can trace data flow, debug problems, or meet compliance requirements without altering your business logic. It is configurable at import time with options for logger class, log level and output file and it supports custom logger classes that implement a constructor and error/info/debug methods. Use is as simple as adding use Medusa to a package and annotating the subs you want audited, making it a practical way to get runtime visibility into method calls.

XS::JIT is a lightweight runtime JIT compiler that lets Perl programs compile and load C/XS code on the fly, making it a good fit when you generate C dynamically and need faster compile-and-load cycles than Inline::C. It skips Inline::C's parsing and xsubpp steps and invokes the C compiler directly, generates XS wrappers or aliases for XS-native functions, and caches compiled modules for quick reuse. The module exposes a simple compile API plus helpers to generate the full C source without compiling, check the cache, and return the proper INC and LIB flags so other XS code can link against its C API. It also provides macros to simplify argument handling and compatibility shims for code written for Inline::C. Recent releases improve error reporting by capturing compiler and linker stderr and fix Windows, Cygwin, and macOS linking issues so builds are more reliable across platforms.

Text::PO is a Perl library for reading, editing and writing GNU gettext PO and POT files and it also ships tools to export those translations to JSON and a small JavaScript loader for browser use. You can parse a PO, inspect or modify entries as objects, dump the result back to a .po text or serialize to a string, produce a hash or JSON for integration with other tooling, and synchronize or merge PO data with existing files or filehandles. The distribution includes a companion Text::PO::MO for .mo binary files and command line scripts for converting between PO, MO and JSON, and the parser supports optional nonstandard include directives with recursive, relative-path handling and circular-include protection. The module stores all state per object so it is thread-safe and offers convenience features such as meta handling, plural-form support, and save-as-JSON for faster loads and JavaScript consumption. Recent 1.0.0 work tightened plural handling and removed a global that could affect thread safety while improving the underlying globals handling, making the module more robust for concurrent use.

CPAN::Maker is a command-line tool and small toolchain for turning a Perl project into a CPAN-style distribution by locating your modules, scripts and tests, resolving dependencies, generating a Makefile.PL and assembling a tarball ready for upload. It prefers a YAML buildspec that describes paths, dependency files, extra files and metadata and can run the supplied make-cpan-dist bash wrapper to clone git repos, run dependency scanners (scandeps or Module::ScanDeps::Static), copy test and executable files and build the final tarball, while direct invocation will at minimum emit a Makefile.PL for you to tweak. The tool supports fine-grained options for dependency lists, min Perl version, inclusion of extra files, and logging, and environment variables let you preserve the generated Makefile.PL, skip tests or enable debug output for troubleshooting. In the recent 1.8.0 release the utility gained support for creating man-links so executables can point to a module's man page and fixed how script man pages are generated, making it a good fit if you want a repeatable, configurable way to prepare and package Perl modules for CPAN.

XML::PP is a tiny, pure-Perl XML parser intended for simple parsing jobs where heavier libraries are unavailable or cannot be installed. It provides a parse() method that produces a straightforward tree of nodes with names, namespaces, attributes and children, and a collapse_structure() helper that converts that verbose tree into a compact hash much like XML::Simple does, with repeated child elements collected as arrays and empty text nodes omitted. You can create the parser with options such as strict mode, warning-on-error, and a pluggable logger, and it supports basic namespace and attribute handling. The author recommends this only for lightweight scenarios and suggests using XML::Simple or XML::LibXML for most real-world needs, so reach for XML::PP when you need a dependency-free, easy-to-install parser for small tasks.

Physics::Ellipsometry::VASE is a Perl module for fitting optical thin-film models to variable-angle spectroscopic ellipsometry data, letting you extract film thicknesses and optical constants by matching model predictions for Psi and Delta to measurements. It reads simple whitespace tables or the native J.A. Woollam VASE format and will use provided uncertainty columns as fit weights, you provide a model routine that computes Psi and Delta from wavelength, angle, and parameters, and the module handles the Levenberg-Marquardt optimization via PDL::Fit::LM, numerical Jacobian estimation, and returns fitted parameters along with covariance and model values. It also offers multi-angle plotting through PDL::Graphics::Gnuplot and includes example scripts for common models, and note that the documented "layers" setting is informational only so your model function must encode the actual layer stack.

Iterator::Flex is a Perl framework for building and using stateful, feature-rich iterators that can rewind or reset, serialize their state, report or throw on exhaustion, and expose history like current and previous values so you can write more predictable streaming code and adapters that wrap other iterators. It ships with a set of common iterator implementations and adapters and has documentation for both using and authoring custom iterators, making it useful when you need more than a simple next() loop, for example to chunk, buffer, zip, permute, gather, or otherwise adapt streams of values. The distribution is still described as alpha quality, but it is actively maintained and recent releases fixed several edge-case bugs and improved exhaustion and capacity validation; note it is released under the GPLv3 license. If you need rewindable, restartable, or serializable iteration semantics in Perl, this module is likely relevant, otherwise stick to simpler iterator utilities.

Plack is the standard Perl toolkit for PSGI that acts like "superglue" between web frameworks and web servers, making Perl web applications portable and easy to run on many backends. It provides server adapters so the same application can run under CGI, FastCGI, standalone HTTP servers, or Apache without code changes. Plack also includes middleware and a simple DSL to compose and wrap apps, a command line runner called plackup, a convention for .psgi application files, request and response helper objects, and testing helpers so you can build, extend, deploy, and test web apps in a consistent way. If you write or deploy web applications or frameworks in Perl and want a server-agnostic, composable stack similar to Ruby Rack or Python WSGI, Plack is the relevant toolkit.

EV::Memcached is a high-performance asynchronous memcached client for Perl built on the libev event loop and implemented in pure XS so no external C client library is required. It implements the memcached binary protocol directly and supports pipelining, multi-get via GETKQ with a NOOP fence, and fire-and-forget quiet commands for maximum throughput. The client works over TCP or Unix sockets, offers optional SASL PLAIN authentication, configurable timeouts, flow control via a max_pending limit and a local waiting queue that can optionally replay across reconnects, and predictable lifecycle semantics where every pending callback is guaranteed to fire with a disconnect reason on teardown. Callbacks follow a simple (result, err) convention and exceptions inside callbacks are trapped so the libev loop is not unwound. Note that keys and values are treated as raw byte strings so you must encode and decode UTF-8 yourself and that SASL requires a memcached build with SASL support. If you need nonblocking, evented access to memcached from Perl or AnyEvent applications, this module provides an efficient, controllable client tuned for high throughput.

Starman is a fast, production-ready preforking PSGI/Plack web server for UNIX that runs any PSGI-compatible Perl application and manages a pool of worker processes for high concurrency and low latency. It uses a C/XS HTTP header parser for speed, supports HTTP/1.1 features like chunked transfer, keep-alive and pipelining, can listen on TCP or UNIX domain sockets, and integrates with Server::Starter for zero-downtime deploys while offering signal-driven controls for graceful restarts and dynamic worker scaling. Starman supports preloading for copy-on-write friendly memory usage, exposes the psgix.informational callback for sending 103 Early Hints, and is designed to sit behind a front-end proxy such as nginx for best results with slow clients. SSL support exists but is considered experimental and the server is explicitly UNIX-only. A recent important update fixes an HTTP request smuggling issue by giving Transfer-Encoding precedence over Content-Length in line with RFC 7230, addressing CVE-2026-40560.

Mojo::SQLite::Database::Role::InsertHelpers is a tiny add-on for Mojo::SQLite that gives your database object simple helper methods for common SQLite insert patterns, namely insert_or_ignore to perform INSERT OR IGNORE and skip rows that would violate constraints, and insert_or_replace (with insert_or_update as an alias) to perform INSERT OR REPLACE and overwrite conflicting rows. You enable it with with_roles on your Mojo::SQLite::Database and then call the methods with a table name and a hashref of column=>value pairs, which makes error-avoiding inserts and basic upsert-like workflows much easier to write. Be aware that using OR REPLACE can be destructive because it replaces the entire row and will clear fields you do not explicitly set, so use it only when full replacement is intended.

Qhull is a thin Perl interface to the well known Qhull geometry tools, letting you run convex hull computations, Delaunay triangulations and Voronoi diagram operations from Perl code. The current release is alpha quality and delegates work to Qhull::PP, which calls the qhull executable rather than linking the qhull library directly. That means you get Qhull's full capabilities but the module's API is still in flux and its option handling follows qhull's native style, so you may need to consult the qhull manual to use advanced features. If you need to integrate robust computational-geometry routines into scripts or prototypes and are comfortable with a wrapper around the external program, this module provides a straightforward way to do that.