CPANscan

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.

Authen::SASL is a Perl framework for handling SASL authentication so your client or server code can negotiate standard login methods and optional connection security without reimplementing protocol details. It exposes a simple API to select mechanisms, supply credential callbacks, and perform the stepwise challenge/response exchange used by protocols like SMTP and IMAP. The module is pluggable so it will try to load a high performance XS backend that wraps the Cyrus SASL C library first and fall back to a pure-Perl implementation, or you can force a specific plugin yourself. It also supports SASL security layers where available, exposing properties such as ssf and methods to encode, decode, or wrap sockets for encrypted I/O. If you are building networked applications that must support multiple SASL mechanisms or want a reusable, protocol-agnostic authentication layer, Authen::SASL provides the tools to do that with minimal integration work.

Net::IP::LPM is a Perl library that implements fast Longest Prefix Match for both IPv4 and IPv6, letting you store IP prefixes with associated values and quickly find the most specific match for a given address. You add prefixes with add and then perform lookups with lookup or the faster lookup_raw after rebuilding the internal table, and you can inspect the trie with info or dump and clear it with finish. The module uses a trie-based algorithm and is optimized for large routing tables, with real-world performance on the order of a million lookups per second on common hardware. It is a mature option when you need high-speed IP prefix matching for routing, IP classification, or similar tasks and recent releases include security fixes that improve prefix validation and bounds checking.

Plack::Middleware::Greylist is a Plack middleware that rate limits HTTP requests by client IP or network block so you can throttle abusive clients or allow trusted networks higher throughput. You configure a default per-minute rate and a greylist of CIDR blocks that can be whitelisted, blacklisted, given a specific numeric rate, or assigned special handling such as a "norobots" rule that only allows robots.txt. Limits can be applied per individual IP, per entire netblock, or grouped under a named bucket so multiple ranges share a quota. Counts are stored in a shared cache file by default using Cache::FastMmap so the middleware works across processes and it returns HTTP 429 with a Retry-After header when a client exceeds its quota. You can also supply a callback to handle or log blocked events instead of the built-in logger. The module requires Perl 5.20 or later and notes some caveats such as not enforcing consistency between overlapping netblocks, potential odd merges when using Config::General, and the fact that some crawlers may ignore HTTP 429 responses.

Novel::Robot is a small toolkit for automating the collection and repackaging of web fiction, aimed at developers who want to fetch, parse, and bundle online novels for offline reading or further processing. Its Browser component handles retrieving pages and following links with basic navigation helpers. The Parser component extracts structured content such as chapter titles, body text, and simple metadata from fetched HTML. The Packer component assembles parsed chapters into single outputs for distribution or archiving, such as concatenated text or simple ebook formats. The modules are useful if you need a straightforward, code-first way to scrape and organize serialized fiction from the web for personal use or integration into larger workflows.

Open::API is a Perl toolkit that reads an OpenAPI 3.0 or 3.1 document, compiles every parameter and schema into JSON::Schema::Fast validators and uses that single compiled contract to power both a PSGI server and a spec-driven HTTP client. Routing and request validation run on a C hot path for low overhead, and the library exposes match and validate_request for integration with other frameworks while Open::API::Plack and Open::API::Client provide ready-made server and client implementations. It upconverts OpenAPI 3.0 schema dialects into a 3.1 shape at load so tooling and validation see a single schema model, expands discriminators into precise branch checks, and can synthesize deterministic mock responses from the spec. The module also offers response checking and coverage counters for sampled runtime validation, and it installs a public C ABI header so other XS dispatchers can route and validate without a Perl frame. Recent fixes include a relaxed ABI version check to improve compatibility when provider and consumer tables evolve.

Fetch is a high-performance HTTP client for Perl that gives you an async-first user agent with HTTP/1.1 and HTTP/2 support, connection pooling, streaming response bodies and native WebSocket support. Every request returns a Fetch::Future so you can write simple synchronous code with ->get or scale to thousands of concurrent requests by driving a supplied event loop or plugging into IO::Async, AnyEvent or Hyperman. It includes conveniences you expect from a modern client such as per-request timeouts, TLS verification, a cookie jar, JSON request/response helpers, redirect handling, on_headers/on_body streaming callbacks and a lean simple_response mode for very high-throughput consumers. Fetch also exposes a C ABI for embedding in XS modules and provides an on_request observer hook plus a clone facility to share connection pools while isolating options like cookie jars. A recent notable improvement is that Fetch::Future now implements the Future::AsyncAwait awaitable API so requests work naturally inside async subs and you can attach on_cancel handlers to futures.

GitHub::Actions is a small helper for writing GitHub Actions steps in Perl that exposes the runner's GITHUB_* environment variables and provides lightweight wrappers around GitHub workflow commands. It gives you simple functions to set environment variables and step outputs, emit debug, warning and error messages, report errors with file and line info, group log output, append Markdown to the job summary and control the step exit status. The module is intentionally minimal and dependency free so you can use the system Perl on GitHub runners or install it via CPAN or include it in your repo with fatpack, and it is used from a step with shell: perl {0}. Remember to call exit_action when you want the step to fail after reporting errors and note that job summaries are concatenated from all steps which can introduce blank lines and may affect some Markdown constructs like tables.

Punk::Push adds Web Push notification support to the Punk web framework so you can send browser push messages from your app by registering VAPID keys and calling a simple push_send helper from request handlers. It integrates with the Punk::Plugin::Push plugin for configuration and helpers and relies on VAPID for the RFC 8291 encryption and RFC 8292 identification used by modern Web Push services. If you build web apps with Punk and need to notify users in real time from the server, this module provides a compact, framework-native way to do that. This is the initial 0.01 release and the code is available under the Artistic License 2.0.

Developer::Dashboard is a local “home” for development that brings your browser, shell prompt, and CLI under one consistent runtime so links, notes, repeatable actions, health checks, file and path shortcuts, Docker Compose workflows, and lightweight data queries live behind a single entrypoint instead of scattered scripts and tabs. It provides a small web UI (default 127.0.0.1:7890), a prompt integration that shows cached indicator state prepared by background “collectors”, a CLI with helpers like jq/yq/tomq/open-file/workspace, a bookmark-style page engine with Template Toolkit and isolated CODE blocks, layered per-project overrides (DD‑OOP‑LAYERS), and an extensible “skills” system so teams can add project-local commands, pages and docker roots without touching system paths. The tool is written in Perl but is language-agnostic in its helpers and works well in mixed-language repos; runtime state is file-backed so prompts and the web UI remain fast by reading prepared results rather than re-running probes. Recent 4.30 fixes are notable: session records with missing expiry are now rejected and swept, misconfigured collectors no longer fork runaway workers, and the in-process d2() helper was changed to a lazy dotted-proxy form that requires a terminating ->() call (an intentional, documented incompatibility for embedded users).

App::Netdisco is an open source, web-based network management tool that discovers and inventories equipment by polling devices via SNMP and storing the results in PostgreSQL. It helps network teams quickly locate a host by MAC or IP and see the exact switch port, perform port actions such as shutdown, VLAN and PoE changes, generate inventories by vendor, model and OS, and visualise topology with interactive maps. The distribution includes a browser UI with a built-in web server, a backend daemon for scheduled collection and job handling, command line utilities for ad-hoc work, a plugin system and an API for customization, and it is available as container images for easy deployment. It requires Perl 5.10+ and PostgreSQL 9.6+ and provides documentation and community support for installation and tuning. Recent releases streamline deployment by reducing container image size and make the device Ports view much faster and more responsive.

Desktop::KDE::Util is a small helper library for Perl developers who need basic utilities when working with the KDE desktop. Its primary provided routine, which_qdbus, searches your system for qdbus binaries and returns their paths so your script can locate and invoke KDE's D-Bus command-line tool. The function is available for import but not exported by default. This is an early, focused release refactored from Desktop-KDEActivity-Util, so it is lightweight and best suited to scripts that simply need reliable discovery of qdbus rather than a full KDE integration framework.

Music::Percussion::Tabla is a Perl module for programmatically generating tabla rhythms as MIDI using a bundled 4.1MB Tabla.sf2 soundfont and a simple API of strikes, rests and preset thekas (groove patterns) like teentaal, dadra and rupaktaal. You work at a high level with named bols such as ta, ge, ke and composite double-strikes like dha, and the module maps those names to one or more MIDI patches and picks patches at random for natural variation. It supports simultaneous notes, custom patch numbers, duration helpers (for example eighth or sixteenth) and a write() method to save the generated score as a MIDI file, and the docs include instructions for using the soundfont with common synths such as FluidSynth. The strike() method now returns MIDI note specifications so you can handle notes externally and the module exposes the default patch mappings while letting you override or address patches directly. A few patch syllable names are noted as unknown by the author, but otherwise this is a practical tool if you want to script authentic tabla patterns from Perl without handcrafting MIDI events.

Configd gives a conf.d-style workflow to software that has no drop-in directory by turning a monolithic config file into generated output and a fragments directory that other packages or provisioning tools can safely add to. You tell it a language like postfix and it can "adopt" the service by moving the original file into a 00-original fragment, create a main.cf.d directory for fragments, install a systemd drop-in so the file is regenerated on start or reload, and later "build" or "release" the files as needed. Its language plugins know which settings should merge as lists and which must be chosen outright so you do not lose values when two actors configure the same daemon, and it intentionally avoids combining ordered restriction lists where order matters. Caveats are that comments do not survive into the rebuilt file and edits to the generated file are temporary until the next restart, and you should only use Configd where a native conf.d does not already exist. It requires only core Perl 5.34 or newer so it can run from systemd ExecStartPre without extra dependencies. This initial release adds language support for postfix, opendkim, opendmarc and redis.

Stats::LikeR brings a large, R-like statistics and data-frame toolkit to Perl with a focus on speed and familiar idioms, offering tests and estimators (t tests, ANOVA/aov, glm, Cox/coxph, Wilcoxon, Kruskal, chi-squared, Fisher, ROC/AUC, BEDROC, and many more), distribution functions (pnorm/qt/pf/qf, etc.), effect-size measures and resampling helpers, plus a full set of data-frame operations for reading, writing and reshaping tables (read_table/write_table with CSV/TSV and .xlsx, view, concat/rbind, merge, group_by/agg, assign, filter, melt, pivot_table, qcut and others) that work with multiple in-memory shapes (array-of-arrays, array-of-hashes, hash-of-arrays, hash-of-hashes). Most heavy computation is in XS so common operations are fast and memory conscious, the API and outputs intentionally mirror R so results and names are familiar, and many routines were numerically validated against R and SciPy for accuracy. If you want to run standard statistical analyses, build tidy data pipelines, or port R/pandas workflows into Perl while keeping high performance, this module is directly relevant. Noteworthy recent work fixed a tricky join edge case so merge(left.on => ..., right.on => ...) now handles right-side columns named like the left key and the join implementation was cross-validated against R and pandas for correctness and performance. The package also includes an interactive help routine h() to print a function's embedded documentation at runtime.

Perl::Unix::Keywords provides four small prototype-driven helpers, walk, group, uniq, and xargs, that let you write concise, keyword-like list and filesystem operations in Perl 5.10 and later. Walk performs a deterministic depth-first, pre-order traversal of given roots and lets your block emit zero or more values per path while avoiding following directory symlinks. Group computes a key for each input and returns key/arrayref pairs (or a hashref in scalar context) with values kept in input order. Uniq canonicalizes items via your block and supports two modes, first to keep the first-seen representative and count to tally occurrences, and it throws on unknown modes. Xargs lifts a Perl list into the argv of a single external command using Perl’s list-form system call to avoid shell interpolation, accepts a scalar or arrayref command spec, returns the raw system status, and does nothing for an empty list. The module intentionally keeps a small, composable core rather than reproducing all Unix-tool options, has no non-core runtime dependencies, and the initial 0.01 release introduced these prototype-based functions along with tests and documentation.

VAPID is a Perl module for sending Web Push notifications directly from your server without relying on services like Firebase, by implementing the Voluntary Application Server Identification standard. It helps you generate and validate VAPID public and private keys, encrypt payloads using the modern aes128gcm web-push encoding per RFC 8291, build complete HTTP::Request objects with the correct Authorization and crypto headers, and optionally send notifications via LWP for a one-call solution. Version 2.00 moved to the RFC 8291 single-body format so encrypted messages are returned as a single string and the module emits the RFC 8292 form of the Authorization header rather than older draft headers. The API also includes helpers for subject and expiration validation, timestamp generation, and subscription validation, making this a practical choice when you need direct control over web-push delivery from Perl, while keeping in mind the protocol limits on encrypted payload size and the requirement to use fresh ephemeral keys for each message.

Punk::Feed is a small, easy to use plugin for the Punk site framework that automatically produces Atom and RSS feeds for your site. You enable it with the Feed plugin, provide basic site metadata like host, title and author, and then supply a feed block that maps your content records into feed items; the module will serve both /feed.xml and /feed.rss so visitors and aggregators can subscribe to your updates. It is aimed at developers building Punk-based sites who want a simple, configurable way to publish feeds without extra plumbing. This is the initial 0.01 release, published on 2026-09-05.

Punk is a modern, fast MVC web framework for Perl that gives you a compact DSL to declare routes, guards, static mounts, OpenAPI-backed APIs, WebSocket and SSE endpoints, caching, sessions, auth, CSRF and many common web concerns with one coherent registry. It compiles and freezes the whole app at to_app time so routing and guards run as cheap lookups and handlers are plain coderefs, which makes request dispatch very efficient. The toolchain includes generators and dev commands to scaffold projects from OpenAPI, run a dev server, inspect routes and run tests with an in-process client. Plugins and view engines extend the core and named routes, mounts and a simple publish/subscribe bus let you build multi-worker apps while features like a C ABI and async futures give low-level observability and nonblocking handlers for evented servers. Punk also documents the operational tradeoffs it makes. Some features such as nonblocking WebSockets, the shared message ring and optimal performance assume Hyperman or compatible PSGI servers. If you want a batteries-included Perl web framework that prioritizes runtime efficiency, sane boot-time validation and easy OpenAPI integration, Punk is worth a look.

Robots::Validate is a utility for web applications that checks whether an HTTP user-agent string that claims to be a known web robot actually comes from the robot's documented IP space. It uses a rules file of agent names, domain suffixes and network blocks to either match an IP directly or perform reverse DNS plus forward-confirmation to verify a hostname belongs to the robot, and it returns a clear success, failure or unknown result so you can treat bots differently in logging, rate limiting or content negotiation. The module now matches multiple agent substrings efficiently with the Aho-Corasick algorithm, supports a configurable TOML rules file, optional caching of results and adjustable validation modes to control how overlapping agent names are handled. The recent 0.4.0 release is a complete rewrite that raises the minimum Perl version, adds caching and match-mode control and introduces limits on forward DNS lookups to mitigate abuse. Be aware that the rule set is not exhaustive, cloud or decentralized crawlers may not be verifiable and DNS-based checks can be unreliable, so you should follow the module's guidance when configuring cache expiry and domain suffix rules.

UUID is a Perl library for creating and handling RFC4122-compatible Universally Unique Identifiers, offering simple functions to generate, parse, stringify, compare, and inspect UUIDs in both binary and text form. It supports versions 1, 3, 4, 5, and the newer v6 and v7 proposals, so you can produce time-based, namespace-deterministic (MD5 or SHA-1), or largely random identifiers depending on your needs, and you can extract version, variant, or timestamp information when available. The module returns UUIDs as packed 16-byte binaries or standard dashed strings, provides helpers for namespace-based deterministic IDs useful when merging datasets, and includes a built-in cryptographic-grade random source based on ChaCha20 mixed with Xoshiro and seeded from the best OS-provided entropy. Optional state persistence keeps time-based sequences safe across restarts but can be slow and carries a security caution around file placement. The module is thread safe, no longer requires libuuid, and aims to be a drop-in, portable way to generate unique IDs across systems and processes.

PDL::IO::HDF is a PDL extension that lets Perl Data Language programs read and write HDF4 files through HDF's SD, VS and V interfaces. You create a file handle with PDL::IO::HDF->new("file.hdf") and then call the individual interface methods via the $HDF->{SD}, $HDF->{VS} or $HDF->{V} objects to fetch datasets, fields and metadata. The module exposes HDF access-mode and data-type constants mapped to PDL types so numeric arrays translate cleanly between PDL and HDF4, and it supports HDF chunking/compression on SDS datasets with a Chunking() switch. Errors return undef for easier checking and the code has been modernized over time; note that this targets HDF4 rather than HDF5. Recent maintenance includes packaging and documentation updates and a compatibility fix for HDF 4.4.

Task::WebDyne::PAGI is a meta package that installs the Perl modules required to use PAGI with the WebDyne framework. It does not provide runtime functionality itself but acts as a convenience installer that gathers and installs the needed dependencies so you can quickly set up an environment for combining PAGI and WebDyne. Install it with cpan or cpanm to automatically pull in the required modules.

WWW::Noss is the internal backend for noss, the command-line RSS and Atom feed reader and aggregator, and implements the full set of commands used by the frontends such as updating and reloading feeds, listing and reading posts, opening URLs, marking read/unread, managing feeds and groups, discovering feed URLs, and importing/exporting OPML files. It is a private module that parses command-line options, drives feed fetching and storage, and provides the functionality behind the noss UI tools so you should consult the noss manual for user-facing documentation rather than using this module directly. The project supports modern feed features including Atom, MRSS, compressed feeds, configurable and colored output, and concurrent access by multiple noss instances. Recent releases improve performance and remove the Parallel::ForkManager dependency by handling forking internally while adding convenience and UI tweaks such as per-feed open commands and improved nossui temporary file handling.

BarefootJS::Backend::Xslate is a lightweight rendering backend that lets the BarefootJS runtime render Kolon-style Text::Xslate templates. It either accepts a ready Text::Xslate instance or will build one from a list of template directories and options, and it runs with or without a web framework so it works under PSGI/Plack or in standalone scripts. The module is designed to be paired with the @barefootjs/xslate compile-time adapter which emits .tx templates that call the runtime as a bf object, and templates are rendered with HTML auto-escaping enabled while helpers can return mark_raw to emit safe markup. Common runtime hooks are provided, including encode_json, mark_raw, materialize, and render_named which binds the runtime into the template and renders name.tx with supplied variables. If you use BarefootJS and prefer Kolon/Text::Xslate templates this backend provides a simple, framework-agnostic bridge.

Config::MVP is a small Perl framework for assembling structured, package-oriented configuration into a sequence of named sections, where each section records a package name and a hashref of settings to drive plugin-style initialization. It does not read files or databases itself but is the helper that readers use to build up configuration step by step via an Assembler state machine, expanding section names into package names, collecting settings into a payload, and handling multi-value parameters by pushing them into arrayrefs. Packages can opt in to friendly behavior by providing mvp_aliases to rename settings and mvp_multivalue_args to declare which keys should always be multi-valued. The resulting Config::MVP::Sequence of Config::MVP::Section objects makes it trivial for applications to instantiate plugins or configure subsystems by calling each section's package->new with the payload, and the Assembler, Sequence, and Section classes are intentionally simple and easy to subclass for customization.

WWW::Spotify is a lightweight Perl client for the Spotify Web API that exposes catalog and user endpoints as simple methods so you can fetch albums, artists, tracks, shows and audiobooks and manage playlists and the authenticated user’s library without hand‑writing HTTP calls. Calls return JSON structures by default and can be auto‑decoded to Perl data, and a handy get method powered by JSON::Path lets you extract values from the last response. The module supports the OAuth authorization‑code flow via authorize_url, get_access_token and refresh_access_token and automatically attaches bearer tokens to requests. You can supply your own LWP::UserAgent for custom networking or debugging and install a custom_request_handler to inspect HTTP::Response objects, while helpers like response_status, response_content_type, die_on_response_error and last_error simplify error handling. The 1.000 release contains breaking changes to match Spotify API removals and security fixes, notably removing several deleted endpoints, making bearer tokens mandatory for every request, treating ua as a plain LWP::UserAgent, changing the custom request callback to receive an HTTP::Response, and storing last_result as UTF‑8 bytes, so review the changelog before upgrading. If you need a practical Perl interface to query Spotify catalog data, automate playlists, or perform OAuth‑protected user actions, this module is a good fit.