CPANscan

XML::Feed is a Perl library for reading, creating and discovering web syndication feeds that hides the differences between Atom and several RSS versions. It can parse RSS 0.91, RSS 1.0, RSS 2.0 and Atom and offers a consistent API for feed metadata, entries and dates, converting dates into DateTime objects so you do not have to handle format quirks yourself. It supports parsing from strings, files, filehandles or URIs and can auto-discover feeds linked from an HTML page, and it integrates with LWP::UserAgent for network fetching. You can build, convert and splice feeds, iterate or add entries, and emit XML with as_xml. There are a few compatibility notes documented by the author: you can override the RSS parser class via a package variable but only XML::RSS::LibXML 0.3004 is known to work for parsing, and multi-enclosure support requires XML::RSS 1.44. The module is open source and maintained on GitHub.

File::Raw::XML is a compact, security-minded XML 1.0 and Namespaces 1.0 parser with a built-in canonicaliser designed for cryptographic signature workflows. By default it runs a strict profile that accepts UTF‑8 only and refuses DOCTYPEs thereby removing entity expansion, external DTDs and common XXE or billion‑laughs style attacks, and it offers an explicit full profile that adds DTDs, controlled entity expansion, validation, XInclude and extra encodings when you opt in. It builds a read-only DOM-like tree, supports XPath 1.0, can stream documents with a pull or push reader for low memory processing, and can serialize canonical bytes in Exclusive, Inclusive 1.0 and Inclusive 1.1 modes needed for XML Signature verification. The API includes a direct byte codec, a File::Raw plugin, ID indexing and editing/serialising helpers, and a small C ABI so XS consumers can parse, walk and c14n entirely in C for maximum performance. This is the initial public release.

Alien::Build::Plugin::Build::Xrepo is a plugin for Alien::Build that lets an alienfile install prebuilt packages from xrepo and a wide range of package stores such as vcpkg, conan, Homebrew, conda, apt, pacman, Cargo and others instead of downloading and compiling source. You declare one or more packages (with per-package options like version and kind) and the plugin uses xrepo to export package trees into Alien::Build’s staging area, then translates those trees into the standard runtime properties you expect such as cflags, libs, version and bin_dir and optionally FFI metadata for build_ffi consumers. The plugin isolates failures so a bad package does not stop its siblings, records errors in runtime properties and writes an xrepo.manifest of what actually installed, it fails fast and emits clear errors when the engine or xrepo executable is missing, and it exposes handy helper variables like %{xrepo_cflags} and %{xrepo_libs} for use in recipes. This is a brand new v1.0.0 release providing a straightforward way to leverage existing binary package ecosystems from within Alien::Build.

lazy is a developer convenience module that automatically installs missing Perl modules on demand so you can run someone else’s script without manually resolving dependencies. It hooks into Perl’s module loader and uses App::cpm to fetch and install any module that cannot be found, with options to install globally or into a local lib directory and to pass additional App::cpm flags. You can load it from the command line, from PERL5OPT so test runners like prove pick it up, or from your code and direct installs with -L or by using local::lib first. Do not use lazy in production, and note it only installs modules that are completely missing, it will not upgrade an already installed module that is too old because the hook only runs when require fails. Recent releases raise the minimum Perl to 5.24 and require App::cpm v1 to avoid broken cpm releases and ensure reliable installs.

MIDI::RtController is a Perl toolkit for processing and routing live MIDI controller data with user-defined plug-in filters. You create a controller with input and output device names, add named filters that react to specific MIDI event types or to all events, and run an asynchronous loop that forwards, modifies, duplicates or delays events using simple helper methods like send_it and delay_send. It works from the command line or inside scripts, supports multiple inputs sharing a single loop and output, and is ideal for tasks such as transposing notes, layering voices, remapping controls, building arpeggiators, or logging incoming events. Filters are plain Perl callbacks so you can implement custom mappings and effects easily. Note that input handling runs in a spawned worker process so you should call stop before discarding a controller to terminate that worker.

Alien::Xrepo is a Perl bridge to native package ecosystems that makes it easy to fetch and install shared libraries and runnable tools for use from Perl without touching the system package manager. It drives xrepo and can pull from many third party managers such as vcpkg, Conan, Homebrew, Conda, Cargo and apt so you can obtain libraries like libpng or sqlite3 and tools like ninja, cmake, python or node with a single call. The module handles platform, architecture and build-mode selection, prefers shared builds for FFI consumers, exposes precise paths and compiler flags via a PackageInfo object, and provides an env helper to run installed tools in the right runtime environment. A small on-disk cache avoids spawning xrepo on every call and you can isolate the install root for reproducible project-local stores or export downloads for offline use. If you are writing XS or FFI bindings, automating builds, or need guaranteed tool binaries at runtime, Alien::Xrepo automates acquisition, configuration and introspection so your Perl code or build system can find and use native dependencies reliably.

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.

HTML::FormHandler is a mature, Moose-based Perl framework for declaring, validating, rendering and processing form data in web and non-web applications. It separates form and field construction from rendering so you can define forms as Perl classes or as dynamic field lists, support nested and repeatable fields, attach custom validators and type constraints, and let validated data automatically update DBIx::Class rows if you are using a database. The module provides flexible parameter handling, error reporting, localization hooks and multiple rendering roles so it integrates easily with Catalyst and template systems or can be adapted to other presentation formats. If you want a robust, extensible way to centralize form logic and minimize controller code in a Perl app this is a good fit, though the authors note Data::MuForm is the successor and may offer additional benefits for new projects.

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.