CPANscan

DB::Handy is a self-contained, pure-Perl relational database engine that stores tables as fixed-length binary files and gives you a familiar DBI-like API — connect, prepare, execute, fetchrow_hashref, selectall_arrayref and friends — without any external server or non-core modules. It implements a surprisingly large slice of SQL‑92, including SELECT with JOINs and subqueries, aggregates, set operations, ORDER BY, LIMIT/OFFSET and single-column indexes to speed equality and range lookups, and it also exposes a lower-level engine API for direct file and schema operations. It is designed for portability and simplicity rather than full RDBMS fidelity, so it is not a DBI driver, it always runs in AutoCommit mode with no transaction support, it has no BLOB/CLOB or multi-column indexes, VARCHAR fields always occupy 255 bytes on disk and FLOAT values in .dat files are machine-native and therefore not portable across different architectures. The 1.10 release adds an important portability and integrity fix on Windows by rejecting reserved device names like con, prn and nul so tables and indexes cannot be accidentally written to the bit bucket, along with a raft of hardening and test-suite fixes. Use DB::Handy when you want an easy, dependency-free embedded SQL engine for modest datasets and simple queries and you can live with the documented limitations.

Dancer::Plugin::Auth::Google makes it easy to add Google OAuth2 sign‑in to a Dancer web app. It provides an initialization helper and a function that builds the Google authorization URL, automatically creates the /auth/google/callback route, and saves the authenticated user profile and tokens into the session so your app can check session('google_user') to know who is logged in. You must supply a session backend and register a Google application to get a client id and secret, then put those and a callback URL into your Dancer config. The default scope is profile but you can request additional scopes such as email or Drive. The saved session includes access and refresh tokens so you can call other Google APIs on behalf of the user. The module verifies TLS certificates by default to prevent MitM attacks and offers an insecure option for legacy behavior, and it also provides a legacy_gplus flag to reproduce the old Google Plus profile format if needed.

Dist::Zilla::PluginBundle::Author::ETHER is an opinionated, ready-made collection of Dist::Zilla plugins that encodes Karen Etheridge's preferred workflow for building, testing, and releasing Perl distributions. By adding [@Author::ETHER] to your dist.ini you get a preconfigured pipeline that handles file gathering, metadata and license management, pod weaving, a broad suite of quality and portability tests, Git and GitHub integration, and automated versioning and release steps. The bundle is configurable so you can pick installer backends, choose repository servers, enable an offline "airplane" mode, produce a cpanfile, perform fake releases for testing, and more while still benefiting from sensible defaults. It is ideal for Perl authors who already use Dist::Zilla and want a mature, flexible, maintained release setup without handcrafting every plugin.

Crypt::DES is a straightforward Perl wrapper that provides the classic DES block cipher with a Crypt::CBC-compatible interface, offering methods like new(key), encrypt, decrypt, blocksize and keysize. It operates on 8-byte blocks and uses 8-byte keys, so it is best used as a building block inside higher-level modes such as Crypt::CBC when you need to handle larger or streaming data. The module is maintained and portable across platforms, but the authors explicitly warn that DES is cryptographically weak and can be brute-forced on modern hardware, so you should not rely on it for real security. Recent updates added an explicit Security Considerations section and clarified replacement recommendations, pointing users toward modern alternatives such as Crypt::Cipher::AES (CryptX) or authenticated modes like Crypt::AuthEnc::GCM. If you need legacy DES compatibility or for testing and learning purposes this module is convenient, otherwise choose a contemporary cipher for any security-sensitive work.

Module::Metadata inspects Perl module files and extracts useful metadata such as package names, $VERSION values, and POD text without having to fully load the module into your program. It offers constructors to read from a filename, an open handle, or by finding a module on @INC, and can optionally collect and decode POD sections. The module evaluates version assignments in a controlled environment so it can return accurate version objects and it can generate CPAN META "provides" structures for a directory or a list of files, find module paths, and test whether packages are indexable by PAUSE. This is handy for CPAN authors, build tools, packaging scripts, and anyone who needs reliable module metadata for testing, packaging, or automation. Recent releases improve parsing for modern Perl "class" declarations and attribute syntax and include small test updates to handle upcoming Perl taint behavior changes.

PlackX::Framework is a lightweight micro‑framework built on Plack for creating PSGI web applications. It wires together a handler, request and response objects, and a small routing DSL so you can define routes and filters with minimal ceremony and call MyApp->app to get a PSGI app. Request and response objects extend Plack::Request and Plack::Response and provide a per-request stash and a flash cookie helper. The framework will auto‑create or load MyApp::Handler, ::Request, ::Response, ::Router and other pieces in your application namespace to keep setup simple. Template Toolkit support, URI helpers and a simple config layer are optional and pluggable so you can add them only when needed. The project favors low memory use and fast startup compared with larger frameworks and keeps dependencies small. It is still marked experimental and recent releases have focused on documentation and test fixes with the distribution published to CPAN in 2026.

Attribute::Handlers::Clean is a lightweight drop-in for defining Perl attribute handlers without polluting the UNIVERSAL namespace, so you can attach custom behavior to variables and subroutines declared in your module or its callers and subclasses while avoiding global side effects. You declare handlers as normal subs with the :ATTR annotation and they will be invoked during compilation or runtime phases with information about the package, symbol, referent and any attribute data, and the module supports type-specific handlers for scalars, arrays, hashes and code, raw-data mode to skip attribute parsing, and phase control such as BEGIN, CHECK, INIT and END. It also automates a common pattern for tying variables via autotie and autotieref, and provides a findsym utility to locate and memoize typeglobs for referents. The code is largely adapted from Damian Conway's Attribute::Handlers but scoped to the calling packages to avoid UNIVERSAL pollution, and note that as of version 1.06 the module requires Perl 5.010 or newer and the author acknowledges there may still be bugs.

Google::Auth is a lightweight Perl library that implements Google Application Default Credentials and automatic project ID detection so your Perl programs can obtain and refresh Google Cloud access tokens without wiring up OAuth flows yourself. It provides a simple default($scopes, $options) entry point that returns the best credentials for the current environment, whether that is a service account key, Compute Engine metadata, or external/federated account configurations, and exposes environment switches to control pluggable credential behavior. Recent releases added full OAuth2 browser flows with UserAuthorizer, WebUserAuthorizer, and a FileTokenStore, a gcloud-auth CLI dispatcher, and substantial security and compatibility hardening including safer external credential execution, stricter URL and proxy handling, and improved OpenSSL support. Use Google::Auth when you need standard, supported Google Cloud authentication in Perl with token management handled for you.

Workflow is a mature, standalone Perl workflow engine that models business processes as named states and actions that move an item between those states while consulting pluggable conditions and validators. You feed the system simple configuration files and use Workflow::Factory to create or fetch Workflow objects, then interrogate a workflow for available actions, required input fields, and a Workflow::Context that acts as a blackboard for your application data. The design is modular so you can supply custom action, condition, validator, observer and persister classes to store workflows in a database, the filesystem or other storage backends. Observers let other parts of your system react to events such as state changes and completed actions. Configuration now favors YAML over the older XML reader which the project plans to remove in a future major release. The distribution is actively maintained on GitHub and the latest 2.11 release fixes a packaging bug in the release tarball, so updating is recommended.

CryptX is a comprehensive Perl cryptography toolkit that bundles the LibTomCrypt and LibTomMath engines and exposes a large family of focused modules for hashing, authenticated encryption, block and stream ciphers, MACs, public‑key operations, secure randomness, key derivation, ASN.1 parsing, and a Math::BigInt backend. It is the distribution entry point rather than a single API, so you pick the concrete modules you need such as Crypt::AuthEnc for AEAD, Crypt::Digest for hashes, Crypt::PRNG for secure random bytes and tokens, Crypt::Mac for message authentication, and Crypt::PK for public‑key tasks. The docs give practical guidance and sensible defaults, recommending modern AEADs like ChaCha20‑Poly1305 or XChaCha20‑Poly1305 as first choices, AES‑GCM when hardware acceleration is available, Ed25519/X25519 for signatures and key agreement, and Argon2 for password hashing. Most modules croak on bad parameters while authenticated decrypt helpers return undef on verification failure so tampering can be detected. The project is actively maintained and recent changes added AES‑XTS mode and BLAKE3 digest support among other fixes and bundled library updates, making CryptX a solid choice when you need a broad, interoperable cryptography toolbox in Perl.

Stats::LikeR is a high-performance Perl toolkit that brings many of R's convenient statistical routines and data-frame style helpers into Perl, implemented mostly in XS so common operations run fast. It covers tidy-data reshaping and querying (agg, group_by, melt, pivot_table, concat/rbind, merge, join, select/drop columns, assign, filter), numeric summaries and transforms (mean, median, quantile, rank, scale, interpolate, fillna/ffill/bfill), a wide suite of statistical tests and estimators (t test, wilcoxon, chi-square, fisher, anova/aov, oneway_test, kruskal/dunn, binomial tests, correlations, ROC/AUC/DeLong, BEDROC), regression and modeling (lm, glm with Poisson and negative binomial, coxph, survfit, logrank), and convenient table I/O (read_table, write_table) while accepting multiple common frame shapes (array-of-arrays, array-of-hashes, hash-of-arrays, hash-of-hashes). The API is aimed at people who like R idioms but need to stay in Perl, and many routines are numerically validated against R and SciPy so you get both familiar behavior and careful tail/precision handling. Recent maintenance releases focused on correctness and robustness, with fixes that bring chisq_test into bit-for-bit agreement with R 4.6.1 and further bug fixes and XS improvements in versions 0.296 and 0.297, so the module is a good choice if you need fast, R-like statistics inside Perl.

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.