CPANscan

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.

Net::CIDR::Set is a Perl module for representing and manipulating collections of IP addresses and ranges using familiar set operations such as union, intersection, complement and difference. It accepts CIDR blocks, explicit address ranges or single addresses, automatically merges overlapping ranges and can handle both IPv4 and IPv6 sets though they cannot be mixed in one set. Common tasks like membership checks, adding or removing ranges, merging sets and testing subset or superset relations are provided, and you can iterate over individual addresses, compact CIDR blocks or arbitrary ranges and export results as arrays or as a compact string with several formatting options. The module is stable and practical for tasks like private address checks or network summarization, and recent work has modernized testing and tooling; a prior release also fixed a security issue that disallows IPv4 quads with leading zeros (CVE-2025-40911).

EV::MariaDB is a non-blocking MariaDB/MySQL client for Perl that plugs into the EV event loop and uses the MariaDB Connector/C non-blocking API to run database work without stalling your event loop. It provides asynchronous connect, query, and prepared-statement workflows with callback-based results, optimized query pipelining for higher throughput, streaming row-by-row reads for very large result sets, server-side prepared statements with BLOB streaming, and async transaction and connection utilities, plus optional automatic UTF‑8 handling and column metadata. The API distinguishes pipelineable query calls from exclusive operations so you can safely queue many reads while reserving certain calls for idle moments, and it includes helpers such as escape and graceful async close. Note that multi-statement queries only return the first result set to the call callback while secondary results are drained and errors from those statements go to the connection error handler. The module is well suited to event-driven, high-concurrency applications and the recent 0.06 release focuses on bug fixes, input guards, and a POD documentation overhaul.

Alien::cmake4 is an Alien distribution that makes the CMake 4.x build tool available to Perl builds by finding a system installation or downloading and installing a binary or building from source when necessary. It exposes simple helpers so you can add the CMake bin directory to PATH and get the executable name for invoking CMake from Perl code, and it integrates with the Alien::Build ecosystem for automated dependency management. By default it will try a binary share install on common platforms like Windows, macOS and mainstream Linux and will fall back to a source build on other systems, and you can control behavior with the ALIEN_INSTALL_TYPE environment variable or force a source build with ALIEN_CMAKE_FROM_SOURCE. This is useful if your project or an Alien plugin requires a consistent CMake 4.x runtime across machines or CI, and it aims to be the preferred, up to date way to supply CMake to Perl-based build workflows.

Git::Server is a drop‑in replacement for a standard SSH Git server that gives you far more flexible server-side hooks and fine-grained access control than stock Git. It lets you enforce per-repo and per-branch rules, restrict who can rewrite history or push specific files, whitelist commit author emails or client IPs, and trigger webhooks or instant deployments on pushes. The distribution also includes convenience tools such as a git-client wrapper, git-deploy for automated deployments, git-verify for sanity checks, and a proxy.url feature to mirror or sync repositories to remote targets from the server side. Setup is simple using SSH authorized_keys to invoke the server command, and the module auto-configures hooks and ACLs on first access. The project is actively maintained on GitHub and recent releases have tightened security and reliability for proxy syncing and improved repository verification and deployment handling.

PGPLOT::Device automates the tedious work of turning a user or programmatic choice into a valid PGPLOT device string so applications can consistently open interactive or hardcopy plots. It understands interactive devices like /xs and /xw and can auto‑increment window ids when you request multiple windows, and it also handles hardcopy specifications of the form filename/device with automatic file extensions and printf-style variable interpolation using ${var:format}. You create the object from a user spec, optionally supply variables or override filenames at runtime, and then call next or current to get the device string to hand to pgbegin or a PDL::Graphics::PGPLOT::Window. Utility methods let your code ask whether the device is interactive, ephemeral, constant, or would change on the next call so you can decide whether to prompt the user or reopen windows. The module notes that PGPLOT::Device::PGWin is often easier for interactive usage and that it does not yet know which output formats can hold multiple pages, so formats like PNG may produce multiple numbered files.

Business::CAMT reads, writes and validates ISO20022 CAMT cash-management XML messages and turns them into usable Perl data structures or JSON so you can process bank account statements and related payment data in your apps. It supports creating CAMT messages from Perl hashes, writing them back to XML, and offers flexible schema version matching when namespaces do not exactly match the distributed XSDs. You can toggle readable long_tagnames for clearer Perl structures and enable Math::BigFloat for very large amounts. The distribution includes templates and example scripts to get you started, and the module will auto-load and compile the required schemas as needed, though not every historical schema version is bundled so you may need to select a compatible version with the provided matchSchema rules. Recent updates clarified the module's scope and added the latest schemas to improve compatibility.

Music::ScaleNote is a compact Perl helper for moving a pitch within a musical scale or by semitones and returning a Music::Note object for the result. You configure a scale name and starting scale note and then call get_offset to move by scale degrees or step to move by half-steps, with support for ISO and MIDI note formats and an option to prefer flats over sharps. It is useful for algorithmic composition, scale-aware transposition, and MIDI generation because it hides the details of scale positions while exposing simple options for offsets, formats and verbosity. The module works with Music::Note and Music::Scales, provides sensible defaults, and the latest 0.0805 release updates MIDI handling to use the new MIDI::Util::midi_format() function.

MIDI::Util is a compact toolbox of helper routines for working with MIDI from Perl, especially alongside MIDI::Simple, that makes common tasks like building a score, setting tempo and time signature, converting note names and durations, inspecting internal MIDI tables, and turning a MIDI::Simple score into event lists quick and straightforward. It also includes convenience for playback and soundfont use by emitting timidity configuration snippets and calling timidity or fluidsynth to play generated MIDI files, plus utilities to compute ticks and microseconds per tick for accurate timing. Nothing is exported by default so you explicitly import only the helpers you need, and the module is aimed at developers who generate, analyze, or play MIDI programmatically rather than low‑level MIDI protocol work. The recent 0.1305 update tightened up midi_format so it only substitutes MIDI-specific s/f accidentals when you pass the flag and fixed a few documentation typos. If you write scripts that create or manipulate MIDI sequences in Perl and want small, well scoped helpers to avoid reimplementing common plumbing, this module is likely relevant.

EV::Redis is an asynchronous Redis client for Perl that uses the fast C hiredis library together with the libev event loop to deliver high-throughput nonblocking access to Redis. It is a drop-in, backward-compatible replacement for EV::Hiredis and adds features you expect in production: automatic reconnection with configurable backoff and attempt limits, flow control via max_pending and local queuing with waiting timeouts, optional TLS support when built with SSL, and RESP3 server push handling via an on_push callback. Commands are issued with command or by calling Redis commands directly and can be handled with callbacks or run in fire-and-forget mode for maximum throughput, and pub/sub callbacks are persistent to receive ongoing messages. The module exposes connection and command timeouts, socket tuning options like keepalive and TCP_USER_TIMEOUT, and helpers to cancel or resume queued commands; it integrates cleanly with AnyEvent when EV is used as the backend. Note that EV::Redis treats all data as bytes and does not perform UTF-8 encoding or decoding for you, so you must encode and decode multibyte strings yourself. Overall EV::Redis is a low-latency, production-ready client for event-driven Perl applications that need speed and control over connection and queuing behavior.