CPANscan

Alien::Xmake is a thin, user-friendly Perl wrapper around the xmake build tool that helps you locate, download, build, and drive xmake from Perl scripts so you can scaffold projects, configure builds, compile, run tests, package artifacts, and manage C/C++ dependencies without hand-editing build files. Its methods mirror xmake actions so you can call create, configure, build, run, install, package, show, project, lua and many plugin tasks programmatically and capture structured JSON output for introspection with helpers like target_info and lua_json. It also integrates with package management via xrepo and provides Alien::Base helpers for use inside alienfile recipes, plus a small Perl DSL (Alien::Xmake::Project) to generate xmake.lua from code. Recent releases reached v1.0.0, split Alien::Xrepo into its own distribution for clearer separation of concerns, and fixed Windows executable quoting so paths with spaces no longer break CreateProcess, and the module will install a local xmake for you when a system installation is not present.

MIDI::RtMidi::Util supplies simple, convenient helpers for working with real-time MIDI devices from Perl, making it easy to list available input and output ports, open a device by matching part of its name, and stop and close devices when you are done. It exposes input_ports and output_ports to return lists of open port names, in_port and out_port to open a named MIDI::RtMidi::FFI::Device for input or output, and stop_device to cleanly close a device, so it is handy for small scripts, quick prototyping, and simple device selection and cleanup without needing to deal with lower level details.

Pod::Markdown::Githubert converts Perl POD into GitHub-flavored Markdown and builds on Pod::Markdown by adding GitHub-aware tweaks that make rendered docs behave correctly on GitHub. It rewrites internal L</...> links to match GitHub heading ids, lets you embed raw GitHub Markdown with "=for github-markdown" blocks, and redirects Perl manual links to perldoc.perl.org when metacpan would be incomplete. Verbatim paragraphs become fenced code blocks with normalized indentation and proper handling of code that includes backticks or appears inside lists. Syntax highlighting is supported via "=for highlighter language=FOO" and you can set a default language with the hl_language method or constructor option. The module also escapes dollar signs to avoid GitHub treating text as TeX math and prefers asterisk-based italics to match GitHub rendering. Recent notable updates added the hl_language option and fixed a documentation code-block language declaration while including license files.

Alien::OpenCV is an "Alien" distribution that makes the OpenCV computer vision library available to other Perl modules on CPAN by either detecting and using a system install or downloading and building OpenCV into a private location when needed. It integrates with common Perl build and FFI workflows so XS modules, Inline::C/CPP code, and FFI::Platypus consumers can find the headers and libraries without forcing users to install OpenCV themselves. Built on the Alien::Base framework, it is intended to simplify dependency management for Perl bindings to OpenCV.

pplquery is a lightweight command-line client for running OpenSearch PPL queries from a file or standard input and emitting results as a readable table, JSON, or CSV. It can target a cluster directly via flags or environment variables or use named connection profiles stored in a JSON config file to keep endpoint, authentication, TLS, and timeout settings together, and it supports HTTPS with basic auth, password-from-file or environment, custom CA files, and an insecure testing mode. The tool validates connection files strictly, avoids taking passwords on the command line, and includes a companion VS Code extension that runs .ppl files from the editor and shows results inline. It is ideal when you need a simple, scriptable way to run PPL queries against self-hosted OpenSearch clusters; it does not implement cloud provider signing or other auth schemes such as AWS SigV4, API keys, bearer tokens, or mutual TLS.

File::Raw is a high-performance file utility for Perl that gives you fast, low-overhead operations for reading, writing, streaming and inspecting files, with functions exported as file_* helpers such as file_slurp, file_spew, file_each_line and file_mmap_open. It is built for large files and tight loops, offering zero-copy mmap access, direct read/write syscalls, efficient line iteration and a chunked iterator for pull-based parsing, plus a stat cache to avoid repeated syscalls. A flexible plugin system lets you register transforms and record parsers (csv, gzip, json, etc.) and chain byte-level and record-level plugins when slurping or spewing, while streaming callbacks remain memory efficient for truly large inputs. Utility helpers cover common filesystem needs such as copy/move/unlink, mkdir/mkpath, head/tail and platform-optimized native copies where possible. Notable recent work in 0.17 added chunk_iter as a pull-read counterpart to each_line and an include/file_chunk.h C API so XS consumers can read chunks from C without copying.

Perl::Critic::Grape is an add-on for Perl::Critic that enforces a focused set of stylistic and safety rules to make Perl code easier to read and maintain. It insists on explicit parentheses when calling built-in functions and forbids inline do blocks so intent is clearer. It discourages manual ref checks and encourages using sigils to indicate data types while reserving the dereference arrow for method calls. It also enforces consistent return behavior, requires subroutines to be ordered by dependency, prefers array and hash slices for lookup sequences, and bans the implicit topic iterator in favor of named loop variables. If you want a small, opinionated suite of checks to improve clarity and consistency in Perl codebases or team projects, this collection is likely to be useful.

Syntax::Keyword::Dynamically adds a single keyword, dynamically, that you put before a scalar assignment to temporarily swap in a new value and have the original restored automatically when the enclosing scope exits. It acts like a more flexible local because it works with lexical variables and with lvalue functions or accessors as well as package variables, and it guarantees restoration even across exceptions, goto or loop control changes. The module respects tied variables and magic so any GET happens once at assignment and any SET runs at assignment and again when the original value is restored, and hash element assignments will add or remove keys as needed to return to the prior state. It also integrates with async code so values are correctly swapped across await points. Use this when you need reliable, temporary dynamic changes to scalars that survive unusual control flow and async context switches.

Music::Drummer is a tiny, user-friendly alias for the MIDI::Drummer::Tiny module that makes drum-related functionality easier to find by providing a clearer module name and searchable keywords like drum, drums, and drumming. It exposes the same simple API for creating MIDI drum patterns and routines such as count‑ins, so you get the capabilities of MIDI::Drummer::Tiny under the Music::Drummer namespace without added complexity. The package is intentionally lightweight and primarily maintained to track and stay in sync with the upstream MIDI::Drummer::Tiny releases, with occasional prerequisite bumps to match updates.

MIDI::Drummer::Tiny is a compact Perl toolkit for programmatically creating MIDI drum parts and metronomes so you can script realistic drum patterns instead of playing them by hand. It gives sensible defaults for a GM percussion kit, common note durations and time signatures, and handy methods to add metronomes in many meters, patterned beats, fills, flams, rolls and crescendo rolls with optional swing and accent control, then write the result to a MIDI file or use a soundfont for playback. You control bpm, volume, channel and the individual drum patches, and higher-level features like sync_patterns, pattern variation callbacks and an add_fill helper make it easy to generate Euclidean or algorithmic rhythms. Recent releases added a Grooves module and improved handling of shared groove pattern files, including a new swap_pat() helper and refinements to groove naming, making it even easier to reuse and swap built-in rhythmic patterns. If you want to automate drum-score generation, experiment with rhythmic algorithms, or produce quick MIDI drum tracks from Perl code this module is a practical, well-documented choice.

Mojolicious::Plugin::OpenTelemetry is a drop-in plugin that automatically instruments Mojolicious web apps to emit OpenTelemetry traces for incoming HTTP requests. Once installed it creates a server span around each endpoint, injects any propagation data from incoming headers, and records standard HTTP and network attributes such as method, path, scheme, client and server addresses, user agent, query string, response status and error details when applicable. It works with async actions and nested routes and re-raises any exceptions after recording them so your app behavior is unchanged. You can customize the tracer name or let it derive one from OTEL_SERVICE_NAME or the app moniker. Note that the plugin must create a temporary span name containing only the request method before the matching route is known, so sampling decisions will not see the final method+route name; a recent update switched to an around_dispatch strategy to allow instrumenting static responses and nested routes but introduced this tradeoff.

Signature::Attribute::Checked is a small Perl extension that lets you add a :Checked attribute to subroutine parameters so incoming arguments are validated against Data::Checks-style constraints before the function runs. It works with sublike constructs such as Sublike::Extended and accepts an expression that yields a checker from Data::Checks, a Types::Standard constraint, an object with a check method, or a package name that provides check. The checker expression is eval()ed at compile time and the check is applied at each call, throwing an exception and preventing the subroutine body if a value fails. Only scalar parameters are supported and the check runs only once at invocation time, so the parameter may be reassigned inside the routine without further validation. This facility is intentionally experimental and depends on XS::Parse::Sublike, so the API and behavior may change as Perl develops and it does not extend to core parameter syntax, lexicals, or class fields.

Fugu is a collection of Perl modules that package the common plumbing used by OpenBSD-style daemons into reusable components. It gives you daemonization, configuration parsing, logging, PID and control sockets, privilege dropping, sandboxing, signal and child process handling, a simple event loop, IPC tools including an imsg codec and newline-delimited JSON over sockets, and utility pieces like an MQTT subscriber, HTTP proxy, REPL and file/state helpers. The distribution targets single-process server-style programs, requires only core Perl 5.36 with optional CPAN features loaded lazily, and includes a sans-IO Protocol::Imsg implementation. Pick Fugu when you need a ready-made, production-oriented toolkit for building and operating daemon-like Perl services.

Data::HashMap::Shared is a high-performance shared-memory hash map for Linux 64-bit Perl that makes it easy to share keyed data, counters and caches between processes by memory-mapping a file or using memfd/anonymous mappings. It provides several type-specialized variants for integer and string keys and values, optional LRU eviction and per-key TTLs so the same structure can act as a fast cross-process cache, lock-free read paths and futex-based writers for low overhead, atomic counters and CAS operations, sharding for parallel writes, and conveniences like batch ops, cursors, freeze/read-only snapshots and diagnostic stats. Small strings are stored inline and larger values use an arena allocator with explicit sizing, and the module exposes both fast keyword-style functions and normal method calls. It is designed for speed and real-world use but comes with practical cautions about crash-recovery, TTLs tied to the local monotonic clock and PID-based recovery across reboots or different PID namespaces. In the recent 0.20 release inserts now reclaim expired slots and will evict to satisfy arena allocation even on overwrite, and sharded sets now record shard count and route on a different part of the hash which is an incompatible change requiring all processes that share a sharded set to be upgraded together.

WWW::Mechanize::Chrome is a Perl module that controls a Chrome or Chromium browser via the Chrome DevTools Protocol, giving you a familiar WWW::Mechanize-style object to drive real browser tabs. It delegates fetching and rendering to Chrome so you can execute JavaScript, query the DOM with CSS selectors or XPath, intercept and inspect network requests, take screenshots or produce PDFs, and interact with forms and dialogs, making it well suited for scraping modern JavaScript-heavy sites, automated testing, and tasks that require a full browser engine. The module can run Chrome visibly or headless and returns HTTP::Response objects for compatibility, but it does require a Chrome-compatible browser to be installed and still lacks some WWW::Mechanize methods such as full POST support and a few legacy features, so check the docs for limits and quirks.

Loop provides compact, high-level iterators for Perl variables so you can process arrays, hashes, and files with minimal boilerplate. It supplies array iterators that pass the current index and allow in-place modification of the original array by assigning to the parameter, hash iterators that support safe nested looping over the same hash without conflicts, and file iterators that hand you line numbers and text for straightforward line-by-line processing. The interface is lightweight and non-exporting so you invoke Loop::Array, Loop::Hash or Loop::File with the target and a callback subroutine, making it convenient for quick scripts and simple data munging. This is the original 1.00 release.

Amazon::Credentials is a small utility for Perl that finds and returns AWS credentials by trying a configurable chain of providers such as environment variables, container endpoints (ECS, Fargate, Lambda, EKS pod identity), EC2 instance profile metadata (IMDSv2), web identity OIDC tokens, and local ~/.aws config and credentials files, and it provides a simple object API plus a command line helper to format or export the discovered credentials. You can control the search order, timeouts and caching behavior, check token expiration and refresh renewable credentials, and it supports SSO flows, credential_process helpers, and normalization of STS assumed-role ARNs to IAM role ARNs for use with IAM APIs. The module is designed with security in mind so credential values are kept inside closures to avoid accidental leakage via dumps or logs, and logging was recently reworked to further reduce the risk of exposing secrets. Version 1.4.0 also improves SSO handling and always uses regional STS endpoints for web identity exchanges. One current limitation is that it does not automatically resolve chained profiles that use role_arn and source_profile or credential_source in ~/.aws config.

Reaper provides a simple, reliable way to handle child process exits in Perl by installing a $SIG{CHLD} handler that can be used globally or scoped locally to a block. It lets you wrap code in reaper { ... } so any children that exit while the block runs are caught and their exit status recorded, and it supplies reapPid to register specific process IDs to reap and pidStatus to retrieve a recorded exit status. The module supports chaining of handlers so it does not blindly replace existing handlers and it avoids stealing exit codes by only reaping PIDs you register. It does rely on cooperating code not to install conflicting handlers, but otherwise makes preventing zombie processes and capturing accurate child exit codes much more straightforward than ad hoc signal handling.

Mail::JMAPTalk is a small, pragmatic Perl client for talking to JMAP servers that wraps HTTP::Tiny and handles JSON encoding, decoding and basic authentication so you can issue raw JMAP method calls without a heavy framework. It provides helpers to build and send method invocations (CallMethods and a single-call Call), upload and download binary blobs, and perform non-standard JMAPAuth login to obtain a token, but it does not implement high-level mail object models so it is best suited to scripts or applications that need direct control of the JMAP wire protocol. Upload will attempt to detect a MIME type via File::LibMagic if available and otherwise falls back to application/octet-stream, extra headers are supported, and verbose request/response logging can be enabled with DEBUGJMAP. A recent important change adds an accountId option and accessor so the client can automatically include the required accountId on calls that omit it, which helps conform to RFC 8620 and avoid servers rejecting requests.

Antybrowser::SDK is the official Perl client for the Antybrowser Local API that lets you control a running Antybrowser desktop app from Perl. It provides easy access to system status and settings and to manage profiles, automations, groups, proxies and extensions, including creating, updating, starting and stopping profiles and running automations. The module talks to the local API on a configurable port (default 5173) and requires an Antybrowser API key and the desktop app running with the Local API enabled. Methods return decoded JSON hashrefs and the client dies on non-2xx responses, so wrap calls in eval to handle errors gracefully. Installable from CPAN, this SDK is a handy choice for Perl developers who need to script, automate or integrate Antybrowser functionality into their tools.

Antybrowser is the official Perl SDK for the Antybrowser Local API, offering a simple client to access the service from Perl programs. You create a client with your API key and call methods such as get_profiles to retrieve browser profiles and related data exposed by the local API. It is intended for Perl developers who want to integrate Antybrowser functionality into scripts or automation tasks. The module is provided by Antybrowser.com and is released under the MIT license.

SPVM::Sys is a cross-platform, system-level utility for SPVM that gives you direct access to file and directory operations, low-level file descriptors, sockets and network primitives, time and clock functions, process control and signals, and user and environment database access via a set of static methods. It wraps common POSIX and platform APIs so you can open, read, write, and manage files and directories, control sockets and TCP keepalive settings, fork and exec processes, examine file attributes with Perl-style -X tests, and manipulate environment variables and user/group entries. The module handles Windows UTF-16 to SPVM UTF-8 filename conversion and sets close-on-exec flags where supported to help portability and safety, and it bundles many related submodules for ioctl, select, stat, time, and socket address handling. Use SPVM::Sys when you need reliable, low-level system calls from SPVM as the foundation for networking, file IO, process management, or building higher-level libraries.

Test::Load::Helper automatically finds and loads a test helper file by walking up the directory tree from the calling test, so you can avoid hardcoded relative requires. It evaluates the helper inside the target package with strict and warnings enabled, supports a custom filename or relative path via the file import option and lets you load helpers into a dedicated package via the into option. Helpers can chain to their parent helpers so local and shared fixtures accumulate, and the module deduplicates loads so the same helper is not evaluated twice into the same package. Traversal can be bounded by setting TEST_LOAD_ROOT to prevent crossing project boundaries, and if no helper is found the module quietly does nothing. Recent work lowered the required Perl version to 5.10.

Clipboard::Any provides a simple, uniform Perl interface for working with the system clipboard across several Linux desktop clipboard managers. It detects or accepts a specified backend such as KDE Plasma Klipper, clipit, parcellite, or xclip and exposes operations to add or clear the current clipboard, clear the full history, list history items, fetch a specific history entry, and detect which manager is running. Each operation returns an "enveloped" result array with an HTTP-like status code, a reason string, an optional payload and optional metadata so your scripts can handle success and errors consistently. Be aware that xclip is treated as an X selection interface with primary and secondary selections rather than a full history and that Klipper cannot return non-text items like images through its text APIs, so history and non-text behavior varies by backend. This module is handy when you need cross-manager clipboard handling in command-line tools or automation on Linux and welcomes contributions to add support for more environments.

Nmap::Scanner is a Perl wrapper for the nmap network mapper that lets Perl programs launch scans, capture nmap XML output, and work with the results as native objects rather than parsing text. You can build scans by setting options and targets and run them in batch mode to get a Results object containing Host and Port objects, or use event mode and register callbacks to be notified as hosts are discovered, ports are found, scans start and finish, or when hosts are closed or have no open ports. The module mirrors nmap's XML model so services, OS guesses, addresses and other data are available through simple accessor objects, making it easy to integrate scanning into larger OO Perl projects or automation scripts. It requires a local nmap installation (nmap 3.10+ to use all features) and supports running scans from files or via the nmap binary. Recent updates improved XML error reporting by using open3 and added task, task progress, and distance objects plus event hooks for task start/stop and progress, which helps build responsive GUIs or progress-aware tools.

Git::MoreHooks is a collection of extra Git hook plugins that extend the Git::Hooks framework to add checks and integrations you can enable from your git config. The bundle provides useful hooks such as Perl code checks (currently via Perl::Critic), commit author validation against mailmap entries, indentation checks with per-file exceptions, Jenkins build triggers, repository administration helpers and a recently added ScanCtags hook for ctags scanning. It is intended to be used through Git::Hooks and requires Git::Hooks 2.8.0 or later and Log::Any for logging, while several hooks have optional feature dependencies like Perl::Critic, Jenkins::API and Git::Mailmap that are loaded at runtime and reported if missing. The project is actively developed so behavior may change between releases, and the author has improved robustness by making optional modules load dynamically and report errors instead of crashing.

PGXN::API is a ready-made toolkit for hosting the PGXN REST API and serving a browsable, JSON-based mirror of PostgreSQL extensions. It syncs a mirror via rsync, merges and enriches the mirror metadata, converts README and other docs to cleaned HTML, builds full-text search indexes and exposes those resources through a Plack-based web server you can run with pgxn_api_server. Use pgxn_api_sync in a cron job to keep the document root up to date and point the server at that directory to provide the API, browseable source files, and search endpoints. The module works with PGXN::Manager for mirror creation and with WWW::PGXN for client access, and its indexer recognizes multiple doc formats and generates per-distribution and per-user JSON files for easy consumption. Recent releases improved Markdown handling by switching to Text::Markdown::Discount so code fences, tables and definition lists render correctly and added a few more allowed HTML elements, and the project has removed macOS support where native dependencies no longer build. If you want to run your own PGXN-compatible API or build a similar lightweight distribution mirror with search and documentation rendering, PGXN::API gives you the sync, indexing and server pieces you need.

Matplotlib::Simple is a Perl wrapper that lets you generate matplotlib charts from native Perl data structures by emitting a Python3 script and running it to produce image files, giving a compact, consistent API and helper functions for common tasks so you do not have to write Python plotting code by hand. It accepts hashes and arrays as input and supports single and multi-panel layouts, overlays, legends, colorbars and many plot types such as bar, plot, scatter, hist, hexbin, imshow, violin and a “wide” summary for repeated runs, and it can write editable Python files to the system temp directory or execute them for you. The module requires a Python 3 interpreter and matplotlib and optionally matplotlib-venn for proportional Venn diagrams. The recent 0.312 release fixed important correctness issues in the wide summary by sorting runs before interpolation, limiting each run’s contribution to its own x-range and adding better validation, and it also improved how data-derived labels are escaped so keys containing quotes or backslashes are emitted safely as Python string literals. If you prefer to drive high-quality matplotlib output from Perl without hand-coding Python, Matplotlib::Simple streamlines that workflow.

Data::FormValidator::Constraints::NumberPhone provides small, ready-made constraint functions you can plug into Data::FormValidator to validate telephone numbers using Number::Phone. It includes FV_american_phone for easy validation of North American numbers (US and Canada) and a more general FV_telephone that takes a list of country codes to define which national formats are allowed. FV_telephone accepts no countries by default so you must supply the ones you want. If you already use Data::FormValidator and need reliable phone-number checking without writing your own code, this lightweight wrapper makes integration with Number::Phone simple.

Punk::Challenge provides a lightweight proof-of-work gate for Punk applications that asks a visiting browser to solve a small JavaScript puzzle and then issues a signed clearance cookie proving the client solved it. It ships as a Punk plugin and exposes a challenge keyword and guards so you can require the puzzle before sensitive pages such as login or deploy it as a softer alternative to outright rate limiting. The approach needs no third party, no images and no human interaction because the work is done in the browser and verified by the server. Use it together with Punk::Challenge::Token for token handling and to sit in front of Punk::RateLimit when you want to avoid returning 429 responses. This is the module's initial public release.