CPANscan

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.

Perl::Tags generates ctags-style tag files for Perl projects so editors and IDEs can jump to subroutines, variables and module definitions quickly, and it is useful whether you want a simple command-line tool or integration with editors such as Vim. It ships with several taggers including Perl::Tags::Naive, a fast line-oriented scanner that is pragmatic and lightweight, Perl::Tags::PPI which uses PPI for more accurate parsing, and Perl::Tags::Hybrid which can combine both approaches, and it supports recursive, incremental tagging following use and require up to a configurable depth and even recognizes test module patterns like use_ok. You can run it from the perl-tags script or drive it from Perl code, extend it by supplying your own get_tags_for_file implementation, and output Exuberant ctags-compatible files that editors expect. The project was reorganized in the 0.30 series to split components out and add the Hybrid tagger, improved editor integration with a fatpacked script and better command-line options were added in later 0.31 and 0.32 bugfix releases. If you need reliable, extensible tag generation for navigating Perl code across modules and scripts, Perl::Tags provides both quick heuristics and deeper parsing options to fit different workflows.

InternetData is the official Perl client for the InternetData API. It lets Perl programs list and download the service's licensed IP and network databases and read the API catalog, per-database metadata, checksums, and your organization's recent download attempts. You construct a client with an API key that carries the db.download scope, or omit the key to make anonymous queries for public endpoints. The API calls are exposed under $client->database and each has both a blocking form and a nonblocking _p variant that returns a Mojo::Promise so it integrates cleanly with Mojolicious. Downloads use a Mojo::UserAgent you can supply for proxy or TLS needs and the client intentionally does not follow the HTTP redirect for downloads to avoid loading multi‑gigabyte files into memory. Errors are reported as InternetData::Error and the module supports configurable retries and timeouts. The client is MIT licensed.

OpenMP is a tiny metapackage that makes it straightforward to use OpenMP from Perl by pulling together the needed pieces and removing boilerplate. Installing it brings in OpenMP::Simple for C macros and runtime helpers, OpenMP::Environment for managing OMP_* variables, Inline::C for embedding C code, and Alien::OpenMP to provide the OpenMP runtime. It exposes a minimal API with a constructor and an env accessor so you can set or validate the OpenMP environment from Perl and then call parallelized C functions via Inline::C while using macros like PerlOMP_GETENV_BASIC in your C. The module is mainly a bootstrap convenience for Perl+OpenMP development and documentation and has been tested with GCC's GOMP implementation.

Linux::Event is a Linux-only asynchronous I/O toolkit built around a native epoll-based event loop that gives Perl programs efficient nonblocking access to filehandles, sockets, timers, signals, and process lifecycle events. The public API is organized into two categories, IO and Kernel, with concrete leaf classes for pipes, terminals, stream sockets and listeners, datagram sockets, timers, signalfd-backed signal objects, eventfd notifications, and pidfd-based process handling. Applications normally subclass the appropriate leaf or attach objects to a Linux::Event::Loop to receive callback-driven I/O, while a raw loop->watch API remains available for low-level descriptor readiness. The distribution also provides declarative framing for byte streams, optional OpenSSL-based TLS support, structured error and address helpers, and facilities for spawning and supervising child processes, so you can implement framed protocols, secure streams, and async process I/O without managing epoll yourself. It requires a modern Linux runtime and recent OpenSSL headers. The recent 0.111 release completes a public-surface audit that finalizes the IO/Kernel taxonomy, stabilizes loop introspection type labels, and tightens benchmarks and documentation to make the API clearer and more robust.

Dist::Zilla is a build system for Perl authors that automates creating CPAN-ready distributions, focusing strictly on packaging rather than installation of downloaded modules. It is designed to run on a repository checkout and uses a rich plugin architecture to gather files, infer or set the distribution name and version, generate META files and licenses, record authors and prerequisites, and control release status and other metadata. You configure a dist with attributes such as name, main_module, license, files, and prereqs and then let Dist::Zilla and its plugins produce the finished archive, which makes repetitive packaging tasks much easier and more consistent. The tool favors power and flexibility and therefore expects a recent Perl and an author-side workflow, and it carries no formal stability guarantee across major releases. If you write or maintain CPAN distributions and want a highly extensible, community-driven system to automate packaging, Dist::Zilla is likely relevant, and learning resources are available at dzil.org and the #distzilla channel on irc.perl.org.

perlomp is a documentation-focused distribution that explains how to use OpenMP from Perl and ties together the small ecosystem that makes it practical. It describes OpenMP::Environment for managing and validating OpenMP-related environment variables, OpenMP::Simple for configuring Inline::C builds and supplying C helper macros, and the OpenMP metapackage that installs and exposes these pieces for convenient use. The modules do not implement OpenMP themselves but make it straightforward to launch existing OpenMP executables or embed OpenMP C code inside Perl with Inline::C while handling toolchain discovery, environment setup, and runtime updates. The docs emphasize important caveats such as the need to set some controls before a runtime initializes, portability requirements across compilers and runtimes, and the safety pattern of moving Perl data into native C storage before parallel work. This initial 0.01 release provides a perl-style manual page, quick start examples, and detailed guidance on initialization, validation, and portability to help you get started.

Sub::Exporter is a modern replacement for Perl's Exporter that makes it easy for a module to provide customized, per-user functions instead of just handing out copies of its own subs. Instead of only exporting exactly what is defined in the package, Sub::Exporter lets you define generators that build new coderefs on demand so importers can request preconfigured variants, rename imports, or apply prefixes and suffixes for groups of symbols. It also supports named groups and group generators for building multiple related routines that share lexical state, and collectors that gather shared import-time settings so callers can supply defaults without relying on global variables. You set it up with a simple configuration that installs an import routine into your package and then use familiar syntax like -as, -prefix, and -suffix when importing. Sub::Exporter only exports subroutines by design, so it does not handle non-code symbols, and it aims to work on a wide range of Perl versions. Use it when you want fine grained, per-import customization of exported functions and to avoid package-level configuration collisions.

Data::OptList is a tiny utility that normalizes and validates name/value option pairs so you can write and consume compact option lists without worrying about lots of undef placeholders or subtle map bugs. Its main routine mkopt accepts undef, a hashref, or an arrayref and returns a canonical array of [name, value] pairs where a defined non-reference is treated as a name and an immediately following reference becomes its value. You can ask mkopt to enforce unique names, constrain value types via a must_be spec, or provide a custom name_test coderef for special name rules. For callers that need a hash form, mkopt_hash converts valid input to a plain hash and will throw if a name appears more than once. The module is lightweight, Perl-version friendly and intended for use wherever you want simple, predictable option parsing. Recent releases updated internal type checking to use Params::SomeUtil and the distribution now requires Perl v5.12.0 or newer.

Device::SerialPort is a pure-Perl, POSIX-based implementation of the Win32::SerialPort API that lets you open, configure, and talk to serial ports on Unix-like systems with a familiar object interface. It handles common serial parameters such as baud rate, parity, data and stop bits, and flow control, and it provides read/write operations, status queries, modem line control, timed pulses for RTS/DTR/BREAK, and tied FileHandle support so you can print and read from ports like ordinary filehandles. The module also includes convenience wrappers for common stty settings, an Expect-like lookfor mechanism for pattern-driven reads, and support for saving and starting from configuration files to simplify scripts. A few features from the original Win32 API are intentionally not ported and some POSIX-specific behaviors are still experimental, for example lockfiles, certain ioctl-dependent functions, and read timing which can split large reads into 255-byte segments or hit platform limits; in those cases methods will return undef when not supported. If you need cross-platform code or are porting Win32::SerialPort scripts to Linux, BSD, or Solaris, this module gives you a practical, Perl-native way to manage serial communications while allowing you to tweak or extend behavior in pure Perl.

DBIx::Class::Async is an experimental adaptor that lets you use DBIx::Class in event-driven Perl programs without freezing your process by moving blocking DBI work into a pool of background worker processes and returning Future objects to your code. It gives you true parallelism for heavy queries, non-blocking CRUD and ResultSet operations, transaction support via txn_do, optional query caching with CHI, and optional metrics reporting, while remaining loop-agnostic so you can plug it into IO::Async, Mojo or other reactors. The module has been tested with SQLite, PostgreSQL, MySQL and Oracle and provides a familiar DBIC-style API via a virtual schema returned from connect or create_async_db so most existing DBIC code can be adapted to async workflows without a full rewrite. It also includes utilities for debugging generated SQL and for running batches or parallel tasks across the worker pool, and exposes clean shutdown via disconnect to avoid worker leaks. Recent releases fix stability issues on shutdown and change clone behavior so clones share the parent worker pool by default to avoid segfaults during global destruction, and the latest patch level cleans up test coverage. If you are building a web server or other evented application and need responsive, concurrent database access while keeping DBIx::Class semantics, this module is worth trying, but note it is still labeled experimental and feedback is encouraged.

Mojolicious::Plugin::BarefootJS plugs the BarefootJS server runtime into a Mojolicious app and exposes a per-request "bf" helper that gives you a BarefootJS runtime backed by BarefootJS::Backend::Mojo, so you can server-render BarefootJS templates directly from your Mojolicious controllers and templates. It also understands compiled marked templates and integrates with the usual Mojolicious rendering flow, making it a drop-in choice if you want server-side rendering of a BarefootJS front end inside a Perl web app. If you do not use Mojolicious there is a sibling backend using Text::Xslate. A recent improvement switched the build manifest to be loaded lazily and cached by mtime and size so booting before the first build finishes no longer leaves the server with stale SSR defaults and manifest changes are picked up without restarting.

BarefootJS is a lightweight server-side runtime that lets Perl apps render templates compiled from JSX/TSX into marked templates plus client JavaScript. It intentionally avoids tying you to any particular template engine or web framework by delegating framework-specific work such as JSON marshalling, raw-string marking, JSX-children materialization, and named-template rendering to pluggable backends. Compiled templates call the runtime as a bf object to produce scoped attributes, JSON output, and spread attributes at render time. Shipping backends include BarefootJS::Backend::Xslate for Text::Xslate and a Mojolicious plugin, and the core module only uses Perl core modules unless a chosen backend requires other libraries. The project is actively maintained and distributed under the MIT license, making it a practical choice if you want to integrate JSX/TSX-style templates into PSGI, Mojolicious, or other Perl web stacks.

AmberDB is a high-performance flat-file NoSQL engine for Perl that sits on top of Berkeley DB (DB_File) and gives you schema-driven records, precomputed inverted indexes, columnar facet indexes, and full ACID transactions with undo journaling and strict two-phase locking for safe multi-table updates. You can use it like a document store with nested repeating blocks or in a lightweight simple mode as an ultra-fast schemaless key-value store that supports RAM-disk caching, full-text search with multilingual normalization, slug maps, and a rich set of helpers for inserts, updates, deletes, reads, filtering and pagination. Schemas live on disk or can be changed at runtime, indexes are built automatically from schema definitions, and the API exposes both high-level operations (field_fetch, search_table, read_all) and low-level DB_File access for bulk or recovery tasks. Recent releases hardened ID validation and simple-mode key sanitization, standardized slug handling and .slg files, and strengthened concurrency and cross-platform flocking; note that a previous release introduced an important migration: your schema directory must be named schema/ rather than scheme/.