CPANscan

Term::Choose::Util is a small helper library that supplies ready-made terminal user interface widgets for letting a script’s user interactively pick directories, files, numbers or subsets from a list. You can call its functions directly or use the object interface, and it exposes many options to tune appearance and behavior such as color and mouse support, layout and ordering, margins and prompt text, cursor hiding and filesystem encoding handling so it plugs into command-line tools with minimal code. It provides focused utilities for browsing and choosing a directory, picking a file, selecting multiple directories, composing an unsigned number, choosing a subset from an array and presenting a simple settings menu that edits a config hash in place. The module expects Term::Choose and Perl 5.10.1 or newer and defaults to no exports, and recent releases include stability fixes such as preserving the caller’s supplied 'mark' option instead of altering it.

Term::Choose is a terminal UI helper that lets Perl scripts present an interactive list of choices so users can pick a single item or mark multiple items from the keyboard or mouse; it offers both a simple functional interface and an object-oriented API, supports paging, column layouts, optional ANSI color, default selections, filtering via regex, and many layout and accessibility tweaks like margins, max width/height and index-based returns. It understands Unicode print widths, works on Unix and Windows (with Win32::Console support), and can use Term::ReadKey for better input handling and an optional XS line-folding module for speed, while requiring Perl 5.10.1 or newer. The module is highly configurable for scripts and command-line tools that need a polished interactive picker, with options to pre-mark items, skip or protect items from selection, show footers or info lines, and treat ambiguous-width characters according to environment variables. Recent updates fix sizing and marking bugs, tighten available-width/height handling, introduce a new truncate_long_tabs line-fold option, raise the minimum terminal size to 4×2, and include backward-incompatible changes to tabs_info, tabs_prompt and tabs_bottom_text, so review those options when upgrading.

Net::Nostr is a Perl library that implements the Nostr decentralized social protocol and gives you both client and relay functionality so you can connect to relays, run a relay server, and build Nostr-aware apps and bots. It includes helpers for key management and event creation, WebSocket client and relay classes, message parsing and storage, encryption and signing, and a large collection of modules that implement many official NIP extensions such as authentication, encrypted payloads, channels, long-form content, media attachments, wallets and more. You can start with Net::Nostr::Key to manage identities and Net::Nostr::Event to create and verify events, then pick from higher-level modules for features you need. The distribution targets a recent NIP snapshot and supports dozens of NIPs, and notes that the older NIP-04 encrypted direct messages are deprecated in favor of NIP-44. If you are a Perl developer wanting to interact with the Nostr network or run a relay, this module provides a comprehensive, ready-to-use toolkit.

Data::PubSub::Shared is a Linux-only, 64-bit-Perl pub/sub implementation that uses mmap'ed shared memory to broadcast messages between processes with extremely low latency. Publishers write into a ring buffer and each subscriber has its own read cursor so many readers can independently consume the stream without blocking publishers. There are two main flavors: Int variants that offer lock-free, multi-producer publish via atomic fetch-and-add for simple numeric signals, and a Str variant that stores variable-length byte strings in a circular arena with mutex-protected publishing and lock-free readers. The module supports file-backed, anonymous (fork-inherited) and memfd-backed sharing, futex-based blocking waits and eventfd integration for event loops, batch publish/poll operations, per-subscriber overflow counting, and automatic recovery when a subscriber falls behind; note that the ring buffer never applies backpressure and will overwrite old messages when full. This is the initial release and it bundles high-throughput primitives, keyword helpers, and crash-recovery behavior for the string mode.

EV::Kafka is a high-performance asynchronous Kafka client for Perl that implements the Kafka binary protocol in XS and plugs directly into the EV event loop for low-latency, pipelined I/O. It gives you a cluster-aware Client with automatic metadata discovery and broker routing, a full producer with batching, acks modes, idempotent and transactional (EOS) support, and a consumer with manual assignment or consumer-group join/sync/heartbeat, plus admin APIs and a low-level EV::Kafka::Conn when you need direct broker calls. The module is pure XS with no librdkafka dependency and works with AnyEvent applications, but it treats all payloads as raw bytes so you must encode UTF-8 yourself and some features are subject to build or protocol limits such as optional LZ4/gzip support, lack of GSSAPI/OAUTHBEARER, synchronous DNS resolution, and capped non-flexible API versions. This 0.01 initial release ships the core produce/consume, transactions, TLS and SASL, multi-partition fetch, and basic admin operations.

EV::Nats is a high-performance, event-driven NATS client for Perl that plugs into the EV event loop and implements the NATS protocol in XS so you do not need an external C library. It gives you low-latency publish/subscribe and request/reply primitives with automatic inbox management, queue-group load balancing, wildcard subjects, header support, automatic PING/PONG keepalive, reconnection with subscription restore, write coalescing and publish batching, plus higher-level APIs for JetStream, key-value and object stores. The interface is callback-driven and includes conveniences like graceful drain, per-connection stats, slow-consumer detection and optional TLS and NKey/JWT auth when built with OpenSSL. Note that DNS resolution uses blocking getaddrinfo so use numeric IPs for latency-sensitive deployments, and TLS or Ed25519 NKey support requires OpenSSL at build time, with all data treated as raw bytes so UTF-8 should be encoded before sending.

BZ::Client is a Perl library that lets you talk to a Bugzilla server using the legacy XML-RPC web service, providing a simple object interface to log in with username/password or an API key, manage session cookies, make API calls, and control HTTP behavior such as proxies, timeouts and SSL verification. It includes conveniences like autologin, pluggable logging callbacks and an option to dump raw HTTP traffic for debugging, so you can script queries, create or update bugs, and interact with attachments without dealing with low‑level HTTP details. Important: this module targets the XML-RPC API used by Bugzilla 5.0 and earlier and has been marked deprecated to match Bugzilla’s API changes, so it is appropriate if you must support older Bugzilla installations but you should plan to migrate to the newer WebService::Bugzilla API for modern servers; the recent 4.91 release documents that deprecation while prior updates focused on reliability, unified error handling and better logging.

Weather::Meteo is a Perl module for fetching historical weather from the Open-Meteo archive API (back to 1940) by latitude, longitude and date. It offers an object-oriented interface that accepts ISO date strings or DateTime-like objects, lets you plug in a custom HTTP user agent or proxy, and includes built-in caching (CHI or a user-supplied cache, with a default in-memory cache expiring after one hour) plus optional rate limiting to avoid excessive API requests. The module will try to resolve time zones automatically if you provide a TimeZoneDB key and otherwise falls back to Europe/London. It is a practical choice for scripts or services that need reliable programmatic access to archived meteorological data and is distributed under the GPL2 license.

Term::CLI is a Perl library for building interactive command line interfaces by wrapping Term::ReadLine and adding a higher level, declarative way to define commands, options, and typed arguments with callbacks, tab completion, history, a configurable prompt and pager, and safe signal handling. It is designed to let you quickly assemble a REPL-style tool that supports command lookup and completion, history read/write, custom word-splitting and quote/escape handling, and cleanup hooks for actions like saving history on exit. The module works best with Term::ReadLine::Gnu but also supports Term::ReadLine::Perl, and it lets you specify I/O handles to avoid surprising UTF-8 behavior when the underlying readline implementation opens the TTY separately. Use Term::CLI when you want a ready-made framework for interactive command parsing and user-friendly terminal behavior in a Perl program.

PDL::LinearAlgebra is a collection of high‑level linear algebra routines for PDL arrays that wraps LAPACK and BLAS so you can do SVDs, eigenvalue problems, Schur and generalized Schur decompositions, QR/LQ/QL/RQ factorizations, Cholesky and LU factorizations, inverses, condition numbers, solvers for linear systems and least squares, norms, rank and null/orthonormal basis computations all with PDL's ndarrays and broadcasting semantics. It handles real and native complex data, supports in‑place operations where possible, and transparently transposes arrays when calling Fortran routines so you do not have to worry about column‑major layout. You can control error behavior with setlaerror/getlaerror and most routines return informative info or auxiliary results in array context. If you need the absolute fastest inner loop you can call the more specific PDL::LinearAlgebra::Real or PDL::LinearAlgebra::Complex interfaces directly. Recent updates changed how certain control parameters are passed to improve broadcasting support and fixed SVD and generalized SVD output quirks.

Data::Table::Gherkin is a lightweight Perl module for parsing Gherkin-style data tables into simple Perl data structures. You call the class method parse with either the table text or a readable filehandle and an optional has_header flag; when has_header is true each row becomes a hashref keyed by the header names and when false each row is an arrayref. The module supports common escapes so you can include newlines as "\n", literal pipe characters as "\|" and backslashes as "\\" inside cells. On success parse returns an object whose rows method returns an array reference of the parsed rows, and on error it carps and returns undef. This is the initial v1.0.0 release.

XAO::Web is a modular Perl framework for building dynamic content as part of the XAO suite. It cleanly separates templates from application logic so designers can work with plain HTML while developers extend or override system objects for site specific behavior without rewriting templates. The system works with CGI, mod_perl and PSGI and gains performance from caching in persistent environments. It is integrated by default with XAO::FS for database access but can be adapted to other storage backends. You can use it not only to generate web pages but also to produce mail messages or reports. The distribution includes a sample site and a simple project layout where a site provides a templates directory and a small Config module to customize behavior. XAO::Web is a good fit when you want reusable, pluggable components and the ability to host multiple independently customized sites while keeping templates free of embedded Perl.

Data::HashMap supplies 14 C-implemented, type-specialized hash map variants for Perl that trade Perl hash convenience for much lower memory use and much higher throughput, especially when you use the provided keyword API that bypasses Perl method dispatch. Each variant targets a specific key/value combination (various integer widths, strings, or raw SV* values) and supports common map operations, fast counter ops for integer values, LRU eviction, default and per-key TTL expiry, iteration and bulk operations, zero-copy read-only lookups for string-value variants, and binary freeze/thaw for non-SV* maps. It is designed for high-performance caching and counting workloads with options for approximate LRU promotion to reduce contention and predictable memory characteristics reported in the docs. Note the usual caveats: get_direct returns a pointer into the map that becomes invalid after any mutation, frozen data is native-endian and not portable between different architectures, some integer sentinel values are reserved and 64-bit variants require a 64-bit Perl. Recent changes in 0.07 fix TTL off-by-one expiry, harden freeze/thaw behavior, and resolve compilation issues on threaded Perls so TTL handling and serialization are now more reliable.

PDL (Perl Data Language) is a Perl extension for efficient, vectorized numerical computing and multidimensional array handling, designed for scientific and bulk data tasks such as processing large images and spectra. It provides fast, memory-efficient N-dimensional arrays with broadcasting, supports most native C numeric types including C99 complex numbers, and includes device-independent graphics and input/output modules for formats like FITS and common image files. PDL comes with an interactive shell, extensive tutorials and reference documentation, and a modular design that lets you load the full feature set with use PDL or pick a lighter startup with PDL::Lite, though the PDL::NiceSlice extended slicing syntax must be enabled separately. If you want MATLAB or IDL style array operations inside Perl, PDL is a mature and performant choice.

Test2::Harness is the engine that runs and manages test suites for the Test2 ecosystem, handling execution, TAP/Test2 event collection and aggregation so your test files can be run in parallel, retried, rerun, or under a persistent runner. It is meant to be used through the App::Yath command-line UI rather than directly, and it offers features you expect from a modern harness such as plugin hooks, resource management for shared or exclusive test resources, coverage and timing support, interactive and persistent modes, and facilities for rerunning failed or changed tests. The project has matured over years with many stability and usability improvements, and recent releases include AI-assisted bug fixes (carefully reviewed by the author) plus a new --resource-timeout option to better control resource waits. If you need a flexible, production-ready test harness that integrates tightly with Test2 and supports advanced workflows like persistent runners and resource-aware scheduling, Test2::Harness is likely relevant for you.

Audio::Nama is a mature, Perl-based, terminal-oriented digital audio workstation that lets you record, edit, mix and manage multitrack projects from the command line. It focuses on non‑destructive track edits, versioning and undo/redo, flexible routing with buses and sends, effect chains and presets, scripted automation and project reproducibility with optional Git-backed project management. The tool integrates with JACK and common audio utilities, can export mixdowns to mp3/ogg, and can launch waveform editors like Audacity for visual editing while keeping control in a text interface. If you prefer a scriptable, terminal-friendly DAW for Linux that emphasizes automation, reproducible projects and tight integration with the JACK/ecasound ecosystem, Audio::Nama is worth a look. Recent development completed a conversion of the interactive terminal layer to the Tickit toolkit for a more capable text UI.

Chandra::Game::Tetris is a small Perl module that implements a playable Tetris game using the Chandra framework, aimed at giving developers a simple, ready-to-run demo or a starting point for customization. The API is minimal — create a new game object and call run — and it supports the usual keyboard controls such as the arrow keys for moving and rotating pieces and the space bar for hard drop. It is packaged as free software under the Artistic License 2.0 and version 0.01 is the initial release, so it is best suited for people looking for an example Chandra application or a lightweight Tetris implementation to extend.

Test::MixedScripts is a small testing helper for Perl projects that scans source and text files to ensure they only contain characters from allowed Unicode scripts, which helps prevent homograph or spoofing attacks where visually similar letters from other scripts sneak into code, strings, or documentation. It provides file_scripts_ok to check a single file and all_perl_files_scripts_ok to apply those checks across a distribution, defaults to allowing Common and Latin but can be configured per file, per line with a special comment, or for whole sections via POD directives, and as of v0.6.0 it can also enforce pure 7-bit ASCII. The module is intended to be run as part of your test suite, reports the offending character, its script and its location when a test fails, and requires Perl 5.16 or later because it relies on Unicode script data; be aware that some scripts are only supported in newer Perls, that Pod::Weaver may not always preserve POD directives exactly, and that it does not detect confusable characters within the same script. Recent updates focused on improving tests and tooling and on documentation and metadata fixes.

Music::SimpleDrumMachine is a lightweight Perl module for programmatically producing simple 16th-note MIDI drum phrases, useful if you want to sketch beats or drive a MIDI synth from Perl. It gives you a configurable phrase length, tempo, MIDI channel (with an option for multi‑timbral output), and division settings so the default 16th-note grid can be changed, and it ships with common drum mappings like kick, snare, hi-hat and crash. Patterns are supplied as code references called parts, so you can plug in custom beat logic and also provide half-bar fills, and it can send output to a named MIDI port with adjustable pulses‑per‑quarter settings. If you need a small, easy-to-use drum sequencer in Perl for quick prototyping or driving hardware, this module is a good fit.

Game::DijkstraMap builds Dijkstra-style numeric grids that represent how close or desirable each cell is to one or more goals, a pattern commonly used to drive simple AI in roguelike games so monsters can move toward or flee from the player. You feed it a character or object grid and a small cost function and it converts that into an internal weight map, offers several normalization strategies (4‑way, 8‑way and an approximate Euclidean variant), and provides helpers to pick the next move, trace a best path, update cells and either incrementally or fully recalculate the map. It also has utilities to create maps from text, export TSV, and to combine multiple maps with weights to influence decisions. The module is written for clarity and prototyping rather than raw speed and the author warns of some edge cases around diagonal movement and long narrow corridors, so it is a good fit when you want a straightforward, customizable Dijkstra map implementation for game logic or experimentation but not for high performance or heavily optimized pathfinding needs.

App::MARC::Validator is a Perl-based tool that helps you check MARC bibliographic records for common format and content problems so you can catch errors before import, migration, or indexing. It is primarily a command-line validator that integrates easily into scripts and data-processing pipelines, letting library technologists and developers scan batches of MARC files and produce readable reports on structural issues, malformed fields, and other conformance concerns. If you work with MARC data and need an automated way to verify record quality as part of ingestion or transformation workflows, this module gives a practical, scriptable way to validate your records.

MARC::Validator is a small, plugin-driven toolkit for checking MARC records and spotting common cataloging problems. It discovers validators via Module::Pluggable and MARC::Validator->plugins returns the list of installed plugin module names so you can see what checks are available. The distribution ships a set of field-specific plugins that look for issues in widely used MARC fields such as 008, 020 (ISBN), 035, 040, 300, 504, 655 and 080, making it useful for library systems, batch quality control and cataloging workflows. Recent updates expanded checks for measurement strings in 300 subfields and added proposed values for ISBN issues, and the codebase has been modernized with a new data model and a renamed reporting API.

Params::Filter is a lightweight Perl module that normalizes and filters incoming parameters by field name, keeping only required and accepted keys and stripping excluded or sensitive fields before they reach validation, logging, or storage. It accepts hashrefs, arrayrefs, or scalars and always returns a consistent hashref so you can separate field presence checks from value validation, which helps security and compliance when handling external data. You can use the simple functional API for one-off checks, create reusable OO filter objects for repeated use and dynamic configuration, or build ultra-fast immutable filters with make_filter that precompile exclusion lookups for high-volume or hot-path processing. The module deliberately does not validate field values, offers wildcard support and parsing rules for odd-length arrays and scalars, and recent releases added the high-performance closure interface and a number of performance and distribution fixes.

BeamerReveal is a small factory class used by the Beamer-to-Reveal conversion tool to turn chunks of a ".rvl" file into the objects that represent conversion units. It provides a simple constructor, a reset method to prepare for a second parsing pass, and a createFromChunk method that accepts a text chunk and its starting line for error reporting and object creation. If you are working on or extending the BeamerReveal pipeline this module is the place that centralizes creation of the basic parse units, otherwise it is a low-level helper used by the rest of the conversion system.

Developer::Dashboard is a Perl-based local developer home that bundles a lightweight web UI, a single CLI entrypoint and shell prompt integration so you can keep bookmarks, notes, repeatable actions, health checks, path aliases, file-open shortcuts, data-inspection helpers, and Docker Compose workflows behind one consistent surface instead of scattered scripts and tabs. It keeps runtime state under ~/.developer-dashboard with optional project-local ./.developer-dashboard overlays so projects can override home settings without losing shared defaults. Background collectors run commands or Perl snippets and cache stdout, stderr and exit codes to drive compact indicators used in the browser chrome and PS1 prompt, which makes prompt rendering fast and predictable. Saved pages use a bookmark-file style with Template Toolkit rendering and CODE blocks, support saved Ajax endpoints with incremental streaming, and can share nav fragments across pages for a persistent local dashboard. The system is extensible via per-command hook directories and a Git-backed skills system, stages built-in helper scripts privately to avoid polluting your PATH, and includes small CLI tools for jq/yq/tomq/propq-style querying plus smart open-file resolution for Perl modules and Java classes. The access model is local-first with loopback-admin trust, helper accounts for non-local access, and transient browser tokens disabled by default for safety while runtime files are hardened to owner-only permissions. Install from CPAN, run dashboard init to seed your runtime, and start the web UI with dashboard serve to evaluate whether it fits your daily workflow.

Func::Util is a compact toolbox of functional programming helpers for Perl implemented in XS/C to push common operations into C for much better performance. It gives zero-overhead, compile-time optimized ops for type, string and numeric predicates and direct array/hash accessors like array_len and array_first, while also providing memoization, lazy evaluation, pipelines and composition, safe dig navigation, null coalescing, and data utilities such as uniq, pick, pluck and partition. For heavy numeric and collection work it includes specialized C-only predicates and a callback registry so other XS modules can register C callbacks for maximum speed. Higher-level functions that call arbitrary Perl coderefs still pay Perl call overhead and created partials may be slower than hand-written closures in some hot loops, but overall this module is a good fit if you want concise functional helpers with C-speed primitives and lower runtime overhead.

Pod::Extract is a small Perl utility that scans a script or module and separates embedded POD documentation from the code so you can write the clean code and the documentation to different files or capture them programmatically. You can run it as the podextract command with options to set input, code output and pod output, or call extract_pod on a filehandle to get the pod text, the code with pod removed, and a sections hash. It can also emit Markdown instead of raw POD and supports a URL prefix for Pod::Markdown. The parser is intentionally simple and does not validate POD syntax, so it is most useful for standard or well-formed docs rather than complex edge cases; if you need robust POD parsing use Pod::Simple. The 1.0.0 release modernizes packaging and the command-line wrapper by refactoring to CLI::Simple, renaming the executable into a modulino, and adding tests and a generated Makefile.

Future::IO::Resolver provides asynchronous name-resolution routines for use with Future::IO, letting event-driven Perl programs convert host and service names into socket address structures or perform DNS queries without blocking. It offers getaddrinfo and getnameinfo for socket-level lookups and res_query and res_search for raw DNS queries. Each method returns a Future that resolves to the appropriate result, for example getaddrinfo yields hashrefs describing family, socktype, protocol and packed address structures while getnameinfo yields host and service strings and the res_* calls return packed DNS reply data. The module currently relies on Net::LibAsyncNS as its backend so that library must be available and some resolver capabilities are limited by that choice, and the author notes plans to add optional backends and direct DNS support in future releases. Use this when you need non-blocking name resolution integrated into Future::IO-based network code.

App::FzfUtils is a tiny toolkit that connects fzf to clipboard workflows by providing command line helpers for selecting and copying text. It ships cs-select and cs-select-helper for picking entries out of an Org-style template where each entry can be multi-line under level-2 headings, flattening entries for fzf and then restoring the original multi-line content into the clipboard, plus fzf2clip and fzf2clip-loop which pipe fzf selections into clipadd so you can quickly capture one-off lines or repeatedly add selections to the clipboard; fzf2clip also offers a tee option to echo selection to stdout. The module exposes functions that return HTTP-like enveloped results but you will normally interact with the supplied CLI tools. This is useful if you already use fzf and want a lightweight way to turn template entries or list selections into clipboard content and expect it to work with App::ClipboardUtils. The most recent release tweaks the exact clipboard content produced by cs-select.

SPVM::Sys is a comprehensive, cross-platform bridge to OS-level services for SPVM programs, exposing a wide set of system calls for file I/O, directory and file management, sockets, time, process control, signals and user/group operations so you can do low-level tasks from SPVM without writing C. It wraps standard things like open/read/write/close, opendir/readdir, sysopen/sysread/syswrite, socket/connect/accept/send/recv and stat/utime and also provides higher-level conveniences such as automatic UTF-8/UTF-16 filename handling on Windows and portable helpers like set_tcp_keepalive for consistent TCP keep-alive settings across platforms. The module is actively maintained with many platform fixes and enhancements, so it is a good fit if you need direct, portable system-call access from SPVM; if you mostly write high-level code you may prefer the standard IO and networking libraries instead.