CPANscan

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.

LLM::SimpleClient is a lightweight Perl wrapper for sending single, stateless text prompts to large language model providers over their REST APIs. It handles API authentication, request formatting, response parsing, and can automatically fail over to configured backup providers if a request fails. The module supports Mistral, HuggingFace Router, and OpenRouter and accepts simple options such as api_key, model, temperature, max_tokens, top_p, timeout, and an arrayref of fallback provider configurations. Its interface is minimal: create a client with new(...) and call ask($text) to receive a hashref containing success, content, error, and provider. Because each call is independent and no conversation history is stored, this module is best suited for single-shot queries from scripts, web services, or tools that need quick one-off LLM calls without session management.

MIDI::Drummer::Tiny is a lightweight toolkit for programmatically building drum parts as MIDI files rather than a live drum machine. It gives you convenient defaults and high-level helpers for common drummer actions such as metronomes in many time signatures, count-ins, pattern-based grooves, synced multi-voice patterns, fills, flams, rolls and crescendo rolls, accented or ghost notes, tempo and channel control, and optional soundfont support for rendering. You work with musical durations and named percussion patches or numeric MIDI notes and the module accumulates beat counts so you can compose phrases and fills reliably across bars. If you write scripts to generate backing tracks, algorithmic rhythms or example grooves for DAW import this module will save time and avoid low-level MIDI fiddling. Recent updates improved the documentation and added an eg/groove-patterns.pl example and tighter integration with a new Grooves helper so pattern libraries can either return raw data or be applied directly to a drummer object. If you need real-time GUI tools or a full drum sampler this is not the right fit, but for automated MIDI drum score generation it is a practical, well-documented choice.

PDF::Imposition is a Perl tool for preparing PDFs for print by rearranging logical pages onto physical sheets so they fold and bind correctly, for example creating booklets or multi-up layouts. It reads page size from the source PDF and offers many common imposition schemas such as 2up and 4up plus signature-based arrangements borrowed from ConTeXt, while letting you specify output filename or suffix, signature size, whether the last page should act as a cover, paper size for cropmarks and basic PDF metadata. Cropmark generation is handled via PDF::Cropmarks so imposed sheets can be trimmed accurately. You call the impose method to produce the new PDF and get the output filename back. The module assumes pages share the same dimensions and is aimed at printing workflows where you need reliable, configurable page reordering.

App::Bin::Search is a minimal base class for a command line utility that searches a hexadecimal data stream for a given pattern across all bit offsets. It accepts a hex stream and a search token and scans each bit-aligned shift, reporting matches and the bit offset where a match was found, with options to show binary output or verbose per-offset listings. The API is intentionally tiny: construct with new and call run, which returns 0 for success and 1 for error. It depends on Bit::Vector and Getopt::Std and is handy when you need to locate sequences that may not be byte-aligned. Recent 0.03 updates improved option validation and added a test for a non-existent option.

NBI::Slurm is a Perl library and command-line toolkit that makes it easy to define, configure and submit SLURM jobs on HPC clusters. Its core classes let you build a job object (NBI::Job) and an options object (NBI::Opts), set names, commands, output paths, threads, memory and runtimes, generate the SLURM header and submit with a single call that returns the job id. The distribution includes utilities for listing, viewing and launching jobs and provides helpers to check SLURM availability and run system commands while capturing stdout, stderr and exit codes. It supports common workflow needs like job arrays, GPU queues and interactive sessions and adds higher‑level features such as an optional energy‑aware scheduler. A recent release harmonized the session CLI so it accepts a -t time string in addition to the older -h hours flag, making interactive session invocation more flexible.

Image::ExifTool is a mature Perl library for reading, writing and creating metadata across a very large range of file types, from JPEG/TIFF and RAW camera formats to PDFs, MP4, audio and many others, including vendor maker notes. It provides both a simple procedural interface and a full object-oriented API so you can extract tag hashes, query or format individual tags, set new values, copy metadata between files and write changes back to disk. The module handles tricky details such as EXIF/IPTC/XMP encodings, embedded documents, geolocation lookups and structured tags, and lets you add user-defined tags through a configuration file or at runtime. A rich set of options controls filtering, conversion, grouping and write behavior and you can queue, save and restore batches of changes for scripted workflows. The code is actively maintained and widely used; note that the API methods are not thread safe.

File::Raw is a Perl module that speeds up common file tasks by calling the operating system directly rather than using PerlIO, making reads, writes and metadata operations much faster. It gives simple, familiar helpers such as slurp, spew, append and atomic_spew, as well as line-oriented tools like each_line, lines_iter, head and tail, memory-mapped access for zero-copy reading, and fast copy/move/unlink and directory utilities. The module also provides a cached stat facility to cut down on repeated syscalls, predicate-based line filtering, hooks for transforming data on read or write, and platform-tuned optimizations such as sendfile and copyfile for native performance. If you work with large files, do a lot of file metadata checks, need memory-efficient line processing, or want atomic writes, File::Raw is a practical way to get noticeably better IO performance in Perl.

OpenAPI::Modern is a Perl library that validates HTTP requests and responses against OpenAPI v3.0, v3.1 and v3.2 specifications, returning detailed JSON::Schema::Modern::Result objects to tell you exactly which parts of a message do not match the spec. It is built on a fully spec-compliant JSON Schema evaluator and can load your OpenAPI document, follow $ref chains, infer parameter types, and locate the correct path and operation for a given request so you can validate parameters, headers, request bodies and responses at runtime or in tests. The module works natively with Mojolicious message objects and will best-effort convert common request/response types from other frameworks, and it bundles up-to-date OpenAPI metaschemas so you can validate or extend schema dialects. There are a few unsupported corners of the spec to be aware of, for example multipart messages, application/x-www-form-urlencoded encodings and automated verification of Authorization headers are not implemented, and querystring handling depends on preserving the raw query string. Recent releases notably added full parsing of OpenAPI 3.2 query parameter styles and much improved cookie header parsing so complex query and cookie encodings are now handled correctly.

PDF::Sign is a Perl toolkit for adding CMS/CAdES digital signatures and RFC3161 timestamps to PDF files, producing PAdES‑compatible output and integrating with PDF::API2 or PDF::Builder. It lets you configure key paths and tools via a single config call or package variables and then prepare and apply signatures with prepare_file and sign_file, including options for visible or invisible signature widgets, and add DocTimeStamps with prepare_ts and ts_file. Verification is supported through verify_signatures which reports signer, timestamps and validity and can perform full chain checks when given a CA bundle. The module calls an external openssl binary for cryptographic operations and uses curl if available to contact timestamp authorities, falling back to LWP::UserAgent, so you will need those tools available on your system. Low level helpers such as cms_sign, ts_query and tsa_fetch are provided for advanced use. Recent changes in 0.06 include safer handling when a produced signature exceeds the reserved space by returning the original PDF with a warning instead of corrupting it, and a fix to PDF date timezone formatting plus added tests for date compliance.

JSON::Schema::Modern is a robust Perl validator that evaluates data against JSON Schema up to the 2020-12 draft, letting you check Perl data structures or JSON strings for conformity to complex schemas and OpenAPI documents. It is extensible so you can register additional schemas, custom format validators, media type decoders and encodings, and it offers options for short-circuiting, annotation collection, default value handling and loose number or boolean handling to suit different inputs. The module includes caching and serialization helpers for reuse in long-running or preforked apps and is designed to be specification-compliant while still allowing practical tweaks for real-world data. Note that it will not automatically fetch schema documents from disk or the network and custom format or media handlers are not serialized, and the author recommends using a reliable JSON decoder such as Cpanel::JSON::XS for best typing. A recent enhancement in version 0.635 makes default values returned by schemas directly available in the evaluator result, so missing properties can be reported or injected into instance data when the with_defaults option is used.

Bot::IRC::X::WwwShorten is a lightweight plugin for the Perl Bot::IRC framework that gives your IRC bot the ability to shorten URLs on demand. It leverages WWW::Shorten with TinyURL as the backend so users can type a command like "tiny http://example.com" and the bot will reply with a compact TinyURL link, keeping channel conversation tidy and links easy to share. The plugin is simple to enable in a Bot::IRC configuration and is useful for anyone running a Perl-based IRC bot who wants quick, automatic link shortening. Source, documentation, and tests are available on GitHub and MetaCPAN, and the module is distributed under the Artistic License 2.0.

Bot::IRC::X::UriTitle is a small plugin for Bot::IRC that watches conversation for posted URLs, fetches the linked resource, extracts the page title and posts that title back into the chat so users can see what a link points to without leaving IRC. It plugs directly into Bot::IRC for simple installation and is designed to skip or gracefully handle links that do not resolve to HTML or do not contain a title. The distribution is maintained and has had recent updates including a security policy and a bump of the minimum Perl requirement because a dependency changed, and it is released under the Artistic License 2.0.