CPANscan

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.

Business::ISBN::Data is a data-only companion for Business::ISBN that bundles the ISBN Agency’s RangeMessage.xml information so the main module can recognize group and publisher ranges, validate ISBNs, and split ISBNs into their components. Business::ISBN will load this module automatically and requires version 3.005 or later because the data structure changed to fix ISBN‑13 handling. You can point it at a different RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable before loading Business::ISBN and if no external file is found it falls back to the bundled default data or looks in the current directory. The data are updated frequently and the project is maintained on GitHub so you can grab the latest range file or contribute changes; the distributed package includes the RangeMessage.xml so you can package or deploy it with your app.

XML::Parser is a mature Perl wrapper around the Expat XML library that gives you a fast, event-driven way to read and process XML documents. You can use it in several built-in styles to suit your task: event callbacks for streaming processing, a Tree or Objects style that builds an in-memory representation, a Subs style that dispatches element names to package subs, or a Debug style for quick inspection. It supports incremental (non-blocking) parsing, namespace handling, custom external-entity resolution (file or optional LWP-based fetching), and multiple encodings, and it reports parse errors as exceptions with optional contextual lines. If you need reliable, low-level control over how XML is consumed or want a simple path to build trees or stream output without pulling in heavyweight DOM libraries, this module is a good fit. Recent maintenance continues to improve robustness and compatibility, with the latest fixes restoring correct parameter-entity handling in DTDs and expanding test coverage to prevent regressions.

AnyEvent::I3X::Workspace::OnDemand is a Perl helper for the i3 window manager that loads and swaps workspace layouts on demand, letting you define named groups with JSON layouts and switch between them via i3 tick events like "group:name". It automates renaming and restoring workspaces, can launch or "swallow" applications into the newly created layouts, and lets you attach custom handlers to workspace events so you can run commands or modify layouts programmatically. Configuration is simple and lives alongside your i3 config, so you can map keys to group switches and have different activity contexts (for example browsing or coding) loaded as needed. Recent updates include a fix to reliably set the active workspace on any non-empty event to avoid incorrect workspace detection during switches, along with improved X11 property handling and integration helpers for showing group information in the status bar.

Getopt::Yath is the command line option framework that drives the yath test harness and can be used standalone to define, parse and document complex CLI options for modular applications. You declare options in groups with rich types such as booleans, scalars, counters, lists and maps, attach defaults, environment variable bindings and triggers, and include option sets from other modules so plugins can provide their own flags. The parser offers flexible behavior for skipping or stopping at non-options, handling grouped tokens and invalid options, and returns a clear structured result with parsed settings, skipped items, remaining arguments and any environment changes. It also auto-generates user-facing help and POD output, making it a good fit when you need composable, well documented and extensible option handling for command line tools.

Module::CheckLatestVersion is a small utility for module authors that lets a module check at runtime whether the installed copy is the latest release and warn or die if it is not. It exports a single helper, check_latest_version, which defaults to checking the caller's package against an authority such as CPAN via Module::CheckVersion. You can make the failure fatal by passing the die option or by setting PERL_MODULE_CHECKLATESTVERSION_DIE and the check is skipped automatically when common automated testing environment variables are present so it will not interfere with CI. This first release is a lightweight way to surface out-of-date deployments and is available on CPAN and GitHub.

Apophis is a compact, high-performance content-addressable storage library for Perl that assigns deterministic UUID v5 identifiers to data by hashing content into a namespace, so identical content always yields the same stable ID and different namespaces isolate datasets. It stores objects in a two-level hex shard layout for filesystem scale and provides streaming identification and storage for large files with O(1) memory, atomic temp-then-rename writes, built-in deduplication, and simple API calls to identify, store, fetch, verify, remove and batch-process items plus metadata sidecars and a configurable store directory. The core is implemented in C via XS for maximum speed and uses the Horus UUID library, making the Perl layer a thin binding. Recent updates focused on build portability and fixed Windows threaded-Perl build issues to improve cross-platform reliability.

Cache::File::Simple provides a single exported cache() function that makes it trivial to store Perl scalars, arrayrefs, and hashrefs on disk with optional expiration times. You call cache($key) to fetch a value, cache($key, $value) to store one, pass a third unix-time argument to set an expiry, and delete an entry by storing undef. A manual Cache::File::Simple::cache_clean() routine removes expired entries, and two package variables let you change the on-disk location and the default expiry time. This module is aimed at simple, file-backed caching needs and requires no additional setup to get started.

CPAN::Meta::X is a concise reference that catalogs the nonstandard metadata keys that authors put into CPAN distribution META files using the x_ prefix, plus the custom prereq phases, relationships, and resource keys people actually use. It helps module authors and tooling authors see common conventions such as x_authority (who maintains a release), x_provides_scripts (what scripts a distribution installs), x_examples, x_lists and x_benchmarks phases, and relationships like x_alt_for or x_features_from so you can understand or adopt established practices instead of inventing your own. The catalog is practical rather than prescriptive and is intended to improve interoperability and discoverability of community conventions. In the latest release it also documents the various x_authority schemes seen in the wild.

Langertha is a Perl framework that gives you a single, consistent API for talking to many large language models and local inference servers so you can swap providers without rewriting your code. It wraps chat, streaming, embeddings, transcription and image generation APIs, normalizes response metadata and rate limits, and adds higher-level features like automatic multi-round tool calling, a stateful autonomous agent called Raider, a plugin system, and optional Langfuse observability. You can use it synchronously or with async/await and it supports a wide range of engines from OpenAI, Anthropic and Ollama to Gemini, HuggingFace, vLLM and many self-hosted adapters. The project is still a work in progress but already provides streaming callbacks, iterator and Future-based APIs, model discovery, and helpers to resolve and construct engines for runtime flexibility. In the latest 0.307 release it added an OpenAI-compatible SGLang self-hosted engine and improved module discovery and a Langertha->new_engine helper to make finding and instantiating engine implementations easier.

Test::Mockingbird is an advanced Perl testing utility that makes it easy to replace, observe, and inject dependencies during tests so you can isolate behavior and validate interactions. It offers both shorthand and longhand ways to install mocks, scoped mocks that auto-restore when they go out of scope, spies that record calls while leaving the original method running, and dependency injection for swapping collaborators. Convenience helpers such as mock_return, mock_exception, mock_sequence, and mock_once cover common test scenarios and you can stack, selectively restore, or globally restore mock layers with restore and restore_all. Built-in diagnostic routines give structured and human readable views of active mock layers to help debug complex test suites without changing behavior. The module is provided as-is without warranty and ships under licence terms that grant GPL2 for personal single user use while other uses require a licence from the author.