CPANscan

App::Test::Generator is a toolkit that helps you automatically create rigorous tests for Perl code by turning formal input/output schemas or heuristically extracted signatures into runnable fuzzing, property-based and corpus tests. It generates Test::Most harnesses from YAML or extracted schemas, produces deterministic edge-case checks alongside randomized fuzzing, supports semantic generators for realistic data and Test::LectroTest properties, and can validate outputs with Return::Set and Params::Validate::Strict. The distribution also bundles command line tools to extract schemas from .pm files, generate benchmarks, test POD examples, run mutation testing and LCSAJ path analysis, deploy ready-made GitHub Actions workflows, and build a combined coverage and mutation dashboard that helps reproduce and triage CPAN Testers failures. A mutation-guided pipeline can turn surviving mutants into TODO stubs or augmented schemas so CI progressively closes testing gaps. Recent releases added corpus minimization to keep fuzz corpora small and fixed several robustness issues including cleaning up stray files created during test runs and improving schema extraction.

Developer::Dashboard is a local developer "home" that gathers your bookmarks, notes, helpers, health checks, file and path shortcuts, Docker Compose workflows, and small automation tasks behind one consistent entry point: a browser UI, prompt status layer, and a single CLI that all share the same runtime. It stores saved pages and executable bookmark blocks with Template Toolkit rendering, runs background collectors to prepare cached state for fast prompt and web indicators, and exposes handy CLI tools for opening files, resolving Perl and Java names, and querying JSON, YAML, TOML, properties, CSV and XML. The runtime is layered so a project-local ./.developer-dashboard can override your home settings while still falling back to ~/.developer-dashboard, helpers are staged privately to avoid polluting PATH, and a simple skills system lets you extend the dashboard with isolated plugins. The packaged web server runs on port 7890 with optional HTTPS and a deliberate loopback-based access model, runtime files are hardened by default, and cross-platform installers and commands are provided for Unix and Windows. If you want a single, configurable place to collect per-project shortcuts, repeatable health checks, status indicators, and lightweight automation that works across language stacks, this module is directly relevant; it is implemented in Perl but is designed to help mixed-language teams as well.

App::Netdisco is an open source, web‑based network management application that discovers devices via SNMP and stores collected data in PostgreSQL so you can locate machines by MAC or IP, see the switch port they use, manage ports (shutdown, VLAN, PoE), inventory hardware, and generate network diagrams. It bundles a web frontend with a built‑in server and a backend daemon for polling and performing actions, and it supports plugins, a DBIx::Class database API, Docker images for easy deployment, and an online demo to try before installing. The project targets administrators of real networks, documents installation and upgrade steps, and requires Perl 5.10+ and PostgreSQL 9.6+ with additional system packages for full functionality.

Lingua::Word::Parser is a Perl module that breaks a word into known and unknown parts by matching a regex-driven lexicon of affixes loaded from a file or a database. You create an instance with the target word and a lexicon source and then use methods like knowns to list matched fragments, power to enumerate non-overlapping partitions, and score or score_parts to rank candidate partitions by character coverage, chunk counts and a simple familiarity metric while returning human-readable definitions for matched parts. Lexicon entries are regular-expression patterns mapped to short definitions so you can capture prefixes, suffixes and combining forms. The module is handy for lightweight morphological analysis, tokenization helpers, spelling or learning tools, and small NLP pipelines where you want readable partitions and scores rather than deep linguistic modeling.

BATsh is a pure-Perl, cross-platform bilingual shell that lets you write and run scripts combining Windows cmd.exe batch syntax and Unix bash/sh syntax in the same file, switching mode automatically on a line-by-line basis while sharing variables through a common BATsh::Env. It implements a large subset of both worlds including pipelines, I/O redirection, functions, positional parameters, arrays, brace and tilde expansion, command and arithmetic substitution, traps, getopts, and CP932 (Shift_JIS) script support, so you can run mixed CMD/SH examples without needing an external cmd.exe or /bin/sh. Non-built-in utilities are invoked as external programs and therefore require the corresponding executable on the host OS, and a few words like the reserved "time" are intentionally not implemented. The 0.11 release fixes several practical interpreter issues: one-line control structures now allow trailing commands and redirections as bash does, the REPL startup bug was repaired, backgrounded builtins no longer escape to an external shell, and documentation was unified, making the module more robust for interactive use and mixed-mode scripts. If you need to run or teach mixed Windows and Unix shell code, or want a single interpreter to experiment with both syntaxes from Perl, BATsh is likely relevant.

Music::ModalFunction is a Perl utility for querying a Prolog-based music theory database to discover relationships between notes, chords, modes or scales, keys and their diatonic functions. You construct an object binding any combination of chord, chord root, mode or key and their functional or Roman-numeral labels, and unbound arguments return all matching possibilities so you can ask things like which chords two keys share, in which modes a given chord can function, or how Roman numeral functions map between scales. Results can be returned as simple lists or as named hash references and you can switch between modal and non-modal scales such as harmonic minor or diminished when needed. Note names use flats only rather than sharps and the module author warns that the choice of the names "mode" and "key" in the API can be confusing, but otherwise the module is a practical tool for composers, arrangers, educators or software that needs to reason about common chords, pivot chords and functional harmony.

WebDyne is the core runtime for the WebDyne framework that renders ".psp" pages to HTML either as the main request handler under servers like Apache/mod_perl, PSGI, or PAGI or as a standalone renderer callable from scripts. It exposes simple functions such as html and html_sr to convert templates that embed Perl into HTML, supports passing parameters, template parsing and caching, chained handlers, filters, CGI-style parameter access, and integration with other WebDyne modules. In standalone mode it will create a fake request object if needed, can write output directly to a filehandle or return the rendered HTML, and a small command line renderer is included for quick generation and diagnostics. Full usage examples and documentation live in the module source and on the project GitHub, making WebDyne a practical choice when you want a Perl-centered templating and request-handling system for web apps or offline page generation.

Class::Simple::Readonly::Cached is a tiny decorator that wraps a Perl object and transparently caches method results so repeated calls with the same method name and arguments are served from cache instead of re-invoking the inner object. It supports a simple in-process hashref for fast ephemeral caching or any CHI-compatible backend for shared or persistent caches, and it records hit/miss statistics and exposes the wrapped object when you need to bypass the cache. This module is best for read-only or effectively immutable objects because the cache is never invalidated automatically, and callers should be aware of limitations in its naive key serialization such as collapsing undef arguments, possible collisions when arguments contain the string "::", and a scalar-vs-list context mismatch that can cause extra invocations. The recent 0.13 release fixes several important bugs including an @ISA-related AUTOLOAD bypass that could silently skip caching, closes a DESTROY-related reference leak, hardens can()/isa() during global destruction, and adds many tests and performance improvements so caching is now more reliable and efficient.

Mojolicious is a modern, full‑featured real‑time web framework for Perl that bundles routing, a plugin system, a powerful templating engine, content negotiation, session and cookie management, form validation, testing tools, a static file server and a built‑in HTTP client so you can build APIs, web apps and WebSocket or event‑driven services without lots of plumbing. It exposes hooks and helpers for application‑wide behavior, supports embedded and command‑line apps and emphasizes sensible defaults and developer ergonomics. The project is actively maintained and recent releases improved security by masking CSRF tokens per request to mitigate BREACH attacks and added experimental support for partitioned cookies and related session attributes, so it is a good choice if you want a polished, batteries‑included Perl web framework with ongoing security and feature work.

Git::Native is a lightweight Moo-based Perl interface to libgit2 that lets you work with Git repositories natively from Perl without spawning the git executable, making it a good choice when you need many or frequent Git operations or want lower overhead than shelling out. It wraps libgit2 via FFI::Platypus through Git::Libgit2 and provides repository operations such as open, open_ext (searching up from a path), init (including bare repos), validation of reference names, and higher-level actions like creating blobs, building trees, and creating commits or updating refs. Use Git::Native when you want native libgit2 behavior from Perl; it contrasts with Git::Wrapper and Git::Repository, which fork the git binary, with Git::Raw, which is an XS binding that has maintenance and stability issues, and with Git::PurePerl, which is read-only. It requires libgit2 to be available and is maintained on CPAN with a GitHub issue tracker for bugs and contributions.

Git::Libgit2 provides thin FFI::Platypus bindings to the libgit2 C library via Alien::Libgit2, exposing the native C surface for callers who need direct low-level access. It exports lifecycle and utility functions such as init_lib and shutdown_lib which manage libgit2 initialization reference counts, version which returns the library version, check_rc which turns negative libgit2 return codes into Git::Libgit2::Error exceptions, and oid_from_hex and oid_to_hex for converting between 40‑character hex OIDs and the raw 20‑byte git_oid buffers. The API intentionally mirrors the C semantics so you must manage lifetimes and handles yourself, for example the scalar returned by oid_from_hex contains the actual OID buffer and must be kept alive while libgit2 uses it. Use this module when you need direct, low-level control or are building higher-level bindings, and prefer Git::Native if you want a safer, more Perl-ish wrapper.

MCP::Run is a Perl base class that makes it simple to expose a command-execution tool over the MCP protocol so other processes can ask the server to run shell commands and receive exit code, stdout, and stderr. It registers a configurable "run" tool that accepts a command plus optional working directory and timeout, and subclasses provide the actual execution by implementing an execute method; MCP::Run::Bash is the provided ready-to-use implementation that runs commands under bash. The module offers security and policy hooks via an allowed_commands whitelist and a validator coderef, lets you set sensible defaults for working directory and timeout, and provides a format_result hook to control the returned text. It also integrates optional output compression and filtering aimed at making command output more compact and LLM-friendly, and it includes convenience entry points for running as a stdio MCP server or installing compression hooks. The recent 0.104 release cleans up compressor behavior by normalizing undef streams and avoiding warnings when transforms drop lines, and it fixes filter resolution so the most specific command filters reliably win.

Win32 is the standard Perl interface to many Windows APIs, providing a convenient collection of functions for Windows-specific tasks so Perl scripts can query OS and filesystem details, manipulate files and directories, work with paths and code pages, get process and thread IDs, check privileges, display message boxes, generate GUIDs, perform simple HTTP downloads and even initiate or abort system shutdowns. Where supported by the Perl core (generally Perl 5.8.9 and later) several routines are Unicode-aware for file and environment names. A few low-level helpers are deprecated in favor of dedicated modules like Win32::API and Win32::Process, and you should note the documented caveat that modern Windows volumes may disable 8.3 short path names which can affect functions that return ANSI short names. Overall it is the practical, full-featured toolkit for doing Windows-specific system work from Perl.

PGPLOT is a Perl wrapper that lets you call the full PGPLOT scientific plotting library from Perl using one-to-one function mappings, so you can draw axes, points, images and annotated plots with familiar Perl scalars, arrays and subroutine references. It handles ordinary numeric and string arguments, 2D and packed image data, and even binary-packed buffers passed by reference for efficient large-array plotting, and it accepts Perl code references for callback-style functions. Because PGPLOT is a Fortran/C library you must install and build the underlying PGPLOT library separately and beware of some platform-specific build steps such as linking libpng and zlib for PNG output, but once installed the module gives direct access to the library’s full feature set and includes debugging support and many usage examples; if you need richer numeric array manipulation the PDL ecosystem interoperates well with this module.

Ereshkigal is a centralized ban manager for firewalls that runs lightweight per-backend worker processes and exposes a simple newline-delimited JSON API over a Unix socket so other tools can add, remove, query, and checkpoint IP and CIDR bans across heterogeneous firewall backends. It is configured with a TOML file that defines kur instances or manager-side fan_out groups, and supports per-kur options such as backend, ports, protocols, ban duration, periodic checkpointing, and basic user/group authorization for commands. The manager supervises and restarts kur processes, fans out requests to groups or individual kurs, and offers operations like ban, unban, cidr_ban, checkpoint, re_init and status, making it suitable for system administrators or automation tooling that must keep bans synchronized across multiple firewall mechanisms. Configuration and validation errors are treated as fatal on startup. This is the initial 0.0.1 release.

Dist::Zilla::Plugin::GitHub::CreateRelease automates creating a GitHub Release for a Dist::Zilla-built CPAN distribution and uploads the distribution archive to that release. It pulls release notes from a variety of sources such as signed notes, a ChangeLog, or a specified file and can wrap notes as code, mark releases as drafts, attach a checksum (SHA‑256 by default), and customize repo, owner, branch, title, and identity selection. The plugin expects that your dist has already been released, tagged and pushed to GitHub and it uses Config::Identity::GitHub for API credentials (supporting per-repo identity files and GPG‑encrypted identity files). If you publish modules to CPAN and also maintain a GitHub repository this plugin saves the manual steps of creating the release and attaching the tarball. Recent updates add extraction of notes via CPAN::Changes and fix repository owner detection and HTTP response handling so it more reliably finds the right repo and release notes.

Dist::Zilla::PluginBundle::Author::Plicease is a ready‑made collection of Dist::Zilla plugins that encapsulates Graham Ollis's preferred build, test, packaging and release workflow for Perl distributions. It wires together common tasks such as gathering and pruning files, creating MANIFEST and metadata, handling README and pod, automatic prereq and version detection, Git tagging and pushing, CI and release-test scaffolding, and uploader hooks, while exposing options like which installer to use, readme source, whether to include release tests, copying Build/MakeMaker files into the repo, allowed dirty files for Git, and platform release restrictions. The bundle is primarily intended to be used for the author's own dists or to make it easy for contributors to reproduce his release setup, and it includes an example/unbundle.pl script and guidance to convert the bundle into editable config if you want to adopt or modify its defaults. Recent notable changes in v2.80 include updated GitHub Actions templates (v6), a raised minimum supported Perl version (now 5.22), and a new starter template for Perl 5.42.

App::sdif bundles three small command-line utilities that make diffs easier to read and track. sdif renders standard diff output in a clear side-by-side layout, cdif adds visual highlighting to show changes at the word or character level, and watchdiff repeatedly runs a command and emphasizes what changed between runs. The tools are designed to plug into common workflows such as using sdif as a git pager and they include options for improved word segmentation with mecab for certain languages. Installable from CPAN with cpanm and configurable via simple rc and git settings, this package is a lightweight way for developers to get more readable, visually informative diffs in the terminal.

Dist::Zilla::PluginBundle::Git::CheckFor is a small Dist::Zilla plugin bundle that runs a set of Git sanity checks as part of your release process, making it easy to catch common mistakes before you ship. By adding [@Git::CheckFor] to your dist.ini you get bundled checks that verify you are on an appropriate branch, detect leftover autosquash commit messages like "fixup!" or "squash!", and look for common merge mishaps, among other repository linting tasks. It simply groups the related Dist::Zilla::Plugin::Git::CheckFor::* plugins so you can enable them all at once, and the recent 0.015 release fixed an @INC related issue and removed a problematic MooseX dependency to improve installation on bleeding‑edge Perls. If you publish Perl distributions with Dist::Zilla and want automated, git-focused pre-release checks, this bundle is a convenient way to add them.

Desktop::XWindowManager::Util provides small, script-friendly utilities for inspecting and manipulating X11 windows with a focus on KDE "activities". It is a thin wrapper around existing command‑line tools such as wmctrl, so it works best with EWMH‑compliant X11 window managers like KWin, Xfwm and Mutter and only partially with minimalist WMs or Wayland sessions that rely on an X compatibility layer. The module exposes functions to list windows with flexible filters, retrieve KDE activity GUIDs for a given window, and move windows between activities, and its functions return a uniform enveloped result containing an HTTP‑style status code, a reason string, the payload and optional metadata which makes it easy to handle success and error cases in scripts. Functions are not all exported by default but are exportable for use in automation or tools that need to query or reorganize windows by title, ID or KDE activity, and recent updates added filters for KDE activity name and current activity as well as support for multiple activity targets when moving windows. Because it delegates work to external utilities, its capabilities depend on the underlying window manager and installed tools rather than trying to implement low level X or Wayland logic itself.

Dist::Zilla::PluginBundle::Author::GETTY is a ready-made Dist::Zilla configuration bundle that wires up the author GETTY's preferred plugins and sensible defaults so you can build, test, and release Perl distributions with minimal setup. It handles versioning, metadata, PodWeaver, Git-based version management and release commits, optional GitHub release publishing, install-after-release, and support for XS or Alien-based C libraries, plus convenient hooks to run scripts before or after build and release. The bundle auto-detects GitHub remotes but can emit generic or Gitea/Forgejo metadata for self-hosted forges, excludes README.md from release tarballs by default, and can also add Docker image build and CI wiring through a shared GitHub Action, so it suits pure-Perl modules, XS modules, and packaged C-library wraps. Configuration options let you opt out of particular behaviors, mark a dist as up for adoption, add IRC support in metadata, restrict which files get $VERSION rewritten, and pass through Alien or Docker settings without manual plugin plumbing. Notable recent change in v0.317 adds a tag_format option so you can control the format of Git tags produced at release time, for example to prepend a v for other ecosystems while keeping Perl version semantics intact.

Net::Firewall::BlockerHelper is a lightweight Perl helper for programmatically managing IP bans across multiple firewall backends. It exposes a simple API to initialize and teardown firewall rules, ban and unban IPv4 and IPv6 addresses, handle CIDR ranges when the chosen backend supports them, list current bans, flush all bans, and reapply rules. The module validates ports, protocols, IPs and CIDRs, offers a configurable self_heal mode that checks and restores the backend setup before each action, and delegates actual rule work to backend implementations such as ipfw. Error handling is done via Error::Helper and failures are treated as fatal, making this module a practical choice for scripts or services that need a uniform way to manage blocking across different firewalls.

POE::Component::Server::JSONUnix is a compact, event-driven server you can drop into a Perl app to expose a simple JSON request/response API over a Unix domain socket. It speaks newline-delimited JSON where each message names a command and carries optional arguments and an id, and handlers are just a dispatch table you register at startup, at runtime, or by subclassing. Handlers may return results synchronously, raise errors, or operate asynchronously by holding a context object and replying later, so it fits both simple control commands and longer-running work. The component includes built-in discovery and health checks, optional authentication via either a cookie ownership challenge or kernel peer credentials on supported platforms, and an optional per-command permission policy that can restrict access by user or group. Errors and malformed input are turned into safe error responses so other clients and the server stay intact. It is ideal as a local RPC or control endpoint for daemons, command-line tools, cron jobs, and other processes on the same host.

Algorithm::Classifier::IsolationForest is a Perl implementation of Isolation Forest and Extended Isolation Forest for unsupervised anomaly detection that scores and flags outliers in multivariate numeric data. It supports classic axis-aligned trees or oblique hyperplane splits for elongated or multimodal data, offers a majority-voting aggregation mode, can learn a contamination cutoff from training data, and provides both batch and streaming (Online) variants. The module includes practical features for production use such as saving/loading models as JSON, named-feature and munger support to convert tagged input into numeric features, a packed-data wrapper for repeated fast scoring, and optional native acceleration via Inline::C and OpenMP that yields large speedups while preserving result parity with the pure-Perl implementation. Recent releases added fit_from_csv for training directly from very large CSV files without slurping them into memory and explain_samples which reports per-feature attributions (ablation and path methods) to help you understand why a point was scored as anomalous. If you need a robust, configurable anomaly detector for offline, interactive or streaming workflows that can scale with optional native acceleration and offers model persistence and explainability, this module is likely relevant.

IO::K8s provides typed Perl objects and serialization helpers for working with Kubernetes resources, letting you convert between JSON, YAML and Perl structures while ensuring the correct types that Kubernetes expects. It can load and validate YAML manifests including multi-document files, collect validation errors, construct objects programmatically, serialize to YAML or JSON, and save manifests to disk. The module supports Custom Resource Definitions by letting you write small CRD classes or by auto-generating classes from a cluster OpenAPI spec, and it can merge external resource maps such as Cilium to add third‑party CRDs and handle name collisions. IO::K8s is designed to work with Kubernetes::REST for live CRUD operations and exposes convenient methods like inflate, json_to_object and object_to_struct to move data between formats. Be aware that the library was rewritten for this major release, moving from Moose to Moo and replacing individual List classes with a unified List class, so upgrading may require code changes.

Crypt::OpenSSL::PKCS12 is a Perl wrapper around OpenSSL's PKCS#12 API that makes it easy to read, create and manipulate .p12/.pfx bundles from Perl. You can load a PKCS12 blob from a file or string and extract the end-entity certificate, CA chain and private key as PEM, verify the bundle MAC, change the bundle password or create a new PKCS12 file or raw DER string, and obtain the same human-readable info output that the openssl command produces or receive that information as a structured hash. The module supports OpenSSL 1.x and 3.x but changing passwords is not reliably supported on OpenSSL 3.x so recreating the file may be preferable, and it offers flags to suppress keys or certificates when dumping. It requires an OpenSSL installation and Perl 5.14 or later, and recent releases include important security fixes and crash bug fixes so upgrading to the latest version is recommended.

Crypt::OpenSSL::X509 is a Perl wrapper around OpenSSL's X.509 API that makes it simple to load, inspect and reformat X.509 certificates from files or in-memory data, in PEM or ASN.1 form. It exposes high-level accessors for common certificate fields such as subject, issuer, serial, validity dates, public key details and fingerprints, plus helpers to check expiry, test for self-signed certs and emit the cert back as PEM or DER. The module also parses extensions and Subject Alternative Names, returns extension and name objects you can query by OID or friendly name, and provides convenience routines for key IDs, bit strings and extended key usages; note that some extension helpers will croak on malformed DER so you should guard calls when handling untrusted input. It is actively maintained for compatibility across a wide range of OpenSSL and LibreSSL releases including OpenSSL 4.x. Recent releases include important security hardening and bug fixes addressing two CVEs and several memory and parsing issues, so updating to the latest version is strongly recommended.

Tie::Google::Sheets lets you treat a Google Sheets document like a Perl hash by mapping worksheet titles to hashes of A1 cell addresses so you can read and write cells with simple Perl syntax such as $doc{Sheet}{A1}. You create the tie with a spreadsheet id or URL and authenticate with a Google service account JSON key or a supplied OAuth bearer token, and you can create, list or delete sheets either by assigning or deleting top-level hash keys or by calling methods on tied(%doc). The module exposes only cell values, not formatting or formula metadata, and every cell access issues a separate Google Sheets API call so it is not optimized for bulk operations. Remember to share the spreadsheet with the service account email and that a spreadsheet must always retain at least one worksheet so you cannot clear the tied hash completely.

Open::API is a focused OpenAPI 3.1 toolkit that compiles a single spec at startup and gives you both a high-performance PSGI server and a spec-driven HTTP client. You hand it a hashref, JSON or YAML text, or a filename and it precompiles every parameter, header, cookie and body schema via JSON::Schema::Fast so routing and validation happen on a fast C path. Handlers are wired by operationId and receive typed, default-filled inputs with cookie parsing and decoded bodies, and you get optional response validation plus before and after hooks for authentication and response mutation. It supports nonblocking Futures on compatible servers, fails fast on malformed specs or duplicate operationIds, and the same compiled object drives Open::API::Client when Fetch is available. The module only supports OpenAPI 3.1, requires JSON::Schema::Fast, and is released as version 0.01.

File::ValueFile is a compact Perl utility module that supplies global helpers for working with ValueFile-formatted data and is intended to be used together with File::ValueFile::Simple::Reader and File::ValueFile::Simple::Writer rather than as a full reader or writer itself. It provides known() to enumerate well known tag identifiers and add_utf8_marker() to register formats or features that should be treated as UTF-8, accepting identifiers in the Data::Identifier form so the Simple reader and writer can autodetect encoding and tag formats. The module acts as a central place to manage tag and encoding behavior across the File::ValueFile tools. The recent v0.11 release added support for writing multiple tag names, accepts Data::Identifier objects for tag names, fixed comment encoding issues, and updated dependencies.