CPANscan

Google::Ads::GoogleAds::Client is the central Perl client for the Google Ads API that manages credentials, configuration, and access to every API service. It reads settings from a googleads.properties file or environment variables and lets you override values when creating the client. It includes handlers for OAuth2 web/desktop flows and for service accounts so you can set refresh tokens, JSON key files, or impersonated emails programmatically. Each Google Ads service is exposed as a method on the client, simplifying requests like search or mutate and returning service-specific objects for the API version you choose. You can control HTTP behavior with proxy, timeout, retry timing, and user agent options, inspect the last request and response, and toggle error handling with a die_on_faults flag which by default returns rich GoogleAdsException objects instead of immediately dying. The module should be loaded before other Google::Ads::* modules. Recent releases continue to add support for new Google Ads API versions and the latest change adds support for v23_2.

Config::Model::Itself is a companion to Config::Model that provides a read/write handler and a small editor for the meta-model files that describe configuration schemas, so you can inspect, modify and persist the very model that Config::Model uses to validate and edit configuration data. It exposes a simple API to load all model files from a directory, write them back while preserving directory structure, read and write model plugins, produce Graphviz dot diagrams of class relationships, and integrate with the cme UI tool or curses/Tk front ends for interactive editing and testing. The module is mature and actively maintained, and recent updates include dropping model annotations to align with upstream Config::Model changes. One known limitation is that test menu entries built from the application model cannot be updated dynamically so the cme tool must be restarted to pick up menu changes.

PGPLOTx::Constants supplies readable, named constants for the PGPLOT plotting library so you can use names like GREEN, SOLID, or NORMAL instead of numeric codes for colors, line and fill styles, fonts, symbols, axis options and plot units. It uses Exporter::Tiny so you can import individual constants, groups by tag (for example colors or fonts), or rename imports with an -as option to fit your coding style. Two helper routines, coerce_constant and list_constants, make it easy to build user-friendly interfaces by validating and normalizing user-supplied names and listing accepted names, including lower-case and hyphen/underscore aliases. The module is lightweight and focused on making PGPLOT-based code clearer and less error-prone. Recent releases added those UI helpers and fixed build issues while bumping the minimum Perl requirement to 5.22.

TOON is a small pure-Perl encoder and decoder for Token-Oriented Object Notation that exposes a simple, JSON-like API so you can convert Perl data structures to and from a compact text form. It supports scalars including null, true, false, numbers and quoted strings with JSON-style escapes, arrays, and objects with quoted or bareword keys that match [A-Za-z_][A-Za-z0-9_-]*. You can use it either as an object with methods to enable pretty printing, canonical (sorted-key) output and configurable indentation or via functional helpers like encode_toon and decode_toon, and parsing errors raise TOON::Error. This starter implementation is minimal and pragmatic and recent updates added parsing and encoding for tabular hashes plus documentation, a license file and a version flag in the included tooling.

Sietima is a lightweight, modern-Perl mailing list manager that reads a message from standard input, re-envelopes it using a configured return address, and delivers copies to a list of subscribers. It intentionally implements a small core and lets you add common mailing-list behaviors by composing roles, so you can enable features like avoiding duplicate deliveries, soft moderation for non-subscribers, List-* headers, reply-to handling, subject tagging, DMARC-aware no-spoofing, per-subscriber preferences, and header stripping without pulling in a monolithic framework. You configure it by constructing a Sietima object or by using the included command-line helper, and it sends mail using Email::Sender transports so it plugs into normal MTA workflows or .qmail-style piping. The module is a good fit if you need a simple, composable list manager for self-hosted lists or lightweight gatewaying, and the latest release adds a StripHeaders role to remove unwanted headers before delivery.

Module::Starter::PBP is a plugin for Module::Starter that generates a ready-to-use Perl distribution skeleton following the recommendations in Damian Conway's book Perl Best Practices. It uses a simple directory of plain-file templates for Build.PL, Makefile.PL, README, Changes, the main Module.pm and test files under t/, and automatically substitutes placeholders such as author, email, module name, year and build instructions. Setup is quick: run perl -MModule::Starter::PBP=setup to create your template directory and config entries, then run module-starter --module=Your::New::Module to produce a new module. The plugin integrates with your existing ~/.module-starter/config so you keep control of author, license and builder choices while getting a consistent, best-practice project layout. It requires Module::Starter, ships default templates based on Perl Best Practices, and is useful for anyone who wants to avoid handcrafting boilerplate and follow a recommended structure.

Dist::Zilla::PluginBundle::Author::GETTY is an opinionated, ready-made Dist::Zilla bundle that packages the tools and sensible defaults the CPAN author GETTY uses to build, document and release Perl distributions. It wires together versioning (Git::VersionManager or AutoVersion for task releases), PodWeaver, metadata helpers, Git checks and a post-release installer so you can release to CPAN with minimal configuration while still overriding details like author/authority, release_branch, or disabling CPAN uploads. The bundle also adds conveniences for XS and Alien-based modules, supports running scripts at various build and release points, and exposes flags such as no_install, no_makemaker, include_readme and adoptme plus IRC/contact metadata for generated SUPPORT sections. Recent updates made README.md excluded from release tarballs by default with an opt-in include_readme option and forward the commit_files_after_release setting to the version manager so files modified during run_before_release actually end up in the release commit. If you use Dist::Zilla and want a tested, configurable shortcut for packaging and releasing Perl distributions, this bundle is a practical starting point.

Music::Interval::Barycentric implements barycentric chord analysis for Perl, mapping chords expressed as pitch-class vectors into a geometric interval space so you can compare, transform and quantify them. It gives straightforward functions to compute a chord barycenter for a given chord size and scale, measure Euclidean-style distances between chords as well as cyclic and inversion-aware variants (orbit_distance and forte_distance), generate cyclic permutations, compute an evenness (consonance) index, and produce chord inversions. The API works with array references of pitch classes and defaults to three-note chords on a 12‑note scale, making the module useful for music theorists, algorithmic composers, visualization tools and any project that needs programmatic measures of chord similarity and balance. The recent 0.0402 release improves documentation and tests and updates the example evolve program.

Async::Redis is an asynchronous Redis client for Perl that uses Future::IO and Future::AsyncAwait to provide a modern non-blocking, async/await API. It is event loop agnostic so it will run with IO::Async, AnyEvent, UV or the built-in poll implementation in recent Future::IO, and it supports pipelining, auto-pipelining, connection pooling, automatic reconnection with exponential backoff, Pub/Sub with automatic subscription replay, transactions, TLS, Lua scripting with EVALSHA optimization, and OpenTelemetry tracing and metrics. The module safely handles concurrent commands on a single connection, is fork safe for pre-fork servers, and exposes convenient helpers like pipeline, subscribe, multi, watch, script registration and scan iterators. Errors are raised as typed exception classes so you can distinguish timeouts, connection failures and Redis errors, and the library leaves event loop selection to the application entry point rather than forcing a backend. Use Async::Redis when you need high throughput, low latency, non-blocking Redis access from Perl applications that integrate with an async event loop.

Unicode::Japanese is a Perl library for converting Japanese text among a wide range of encodings and for normalizing common Japanese forms. It keeps text internally as UTF-8 and can read and emit legacy encodings such as Shift_JIS (using Microsoft CP932 mappings), EUC-JP, ISO-2022-JP, various UTF-16/32 forms, and many mobile carrier variants including DoCoMo, au and J-SKY. The module also handles character transformations like zenkaku to hankaku, hiragana to katakana, splitting by display width, and special handling and mapping of mobile emoji into the Unicode Private Use Area so they survive round trips through Unicode-aware software. You can run the faster XS implementation when you have a C compiler or fall back to a pure Perl implementation without compilation. It can try to auto-detect input encodings but the guesser has known pitfalls such as confusing some UTF-8 sequences for Shift_JIS and limitations when converting to EUC-JP or ISO-2022-JP because those conversions go via Shift_JIS which can force unrepresentable characters into numeric references or question marks. This module is a practical choice if you need robust, carrier-aware Japanese text transcoding and normalization in Perl.

Music::SimpleDrumMachine is a lightweight Perl module that drives a MIDI output in real time to play simple 16th‑note drum phrases. You program parts and optional fills as Perl code references that return the next part name plus a hash of 16-step patterns keyed by drum name, and the module maps those names to General MIDI percussion numbers or accepts user-added drums. It exposes tempo, phrase length, divisions, MIDI channel or multi‑timbral mode, and simple velocity controls, and it includes handy example scripts to list devices and build grooves, though triplet timing is not supported. If you want an easy way to prototype or perform programmable drum grooves over a MIDI device this module is practical and mature, and recent updates expanded the included percussion set and added example programs including a no-fills demo while fixing a few edge cases.

App::Test::Generator is a toolkit that automatically produces robust test harnesses for Perl modules from concise input/output schemas, letting you add extensive black‑box fuzzing and property tests without hand writing every case. You describe a routine in a YAML or Perl-backed schema and the tool emits Test::Most-based .t files that combine randomized fuzz inputs, deterministic edge cases derived from min/max/len constraints, static corpus tests, and optional property-based transforms powered by Test::LectroTest. It understands common types and semantic generators like emails, UUIDs and timestamps, supports functional and OO calls, can seed runs for reproducibility and control iteration counts, and validates inputs and outputs with Params::Validate::Strict and Return::Set. The distribution also includes a mutation-guided pipeline that links mutation testing, schema extraction and fuzz generation so surviving mutants can be used to create TODO stubs or runnable augmented schemas written into t/conf for subsequent fuzz runs, and it ships a test dashboard with LCSAJ/TER metrics to help prioritize gaps. Command line tools integrate with make test and GitHub Actions for scheduled fuzzing, and generated tests aim to be safe and reproducible for CI. In the 0.33 release a numeric mutation bug that produced invalid mutants was fixed and several dashboard, extraction and template improvements were added, including better handling of relationship metadata and additional edge cases for floating values.

ChordPro is a mature tool for turning plain-text song files marked up with lyrics and chord annotations into professional, print-ready song sheets and songbooks, typically producing PDFs but also textual and ChordPro-format outputs. It reads the ChordPro markup used to label titles, verses, choruses, chords and images and can generate chord diagrams, CSV indexes for apps like MobileSheets, transposed copies for capos or different keys, and cover or front/back matter pages while supporting custom TrueType/OpenType fonts and Unicode. The program is highly configurable via JSON-style config files and offers a GUI for building and previewing songbooks, plus experimental backends for HTML, LilyPond and LaTeX. Recent releases improved key and transposition handling, added options to prefer common keys and sharps, expanded the built-in chord library with many new and jazzy chord names, and introduced configurable automatic line wrapping and transposable chords in defines, along with better image file handling. If you maintain collections of songs or need to produce neat, customizable chord-and-lyric sheets with flexible transposition and diagram support, ChordPro is directly relevant.

MARC::Leader::Print is a small formatter for turning a Data::MARC::Leader object into a readable, line-oriented report of MARC leader fields. It returns either a single string or a list of lines depending on context and supports localized labels via an ISO 639-1 lang option, descriptive text vs raw values via mode_desc, and optional ANSI color output controlled by mode_ansi or environment variables when Term::ANSIColor is available. You can set the scalar output separator and the module is aimed at simple diagnostics, logging, or human-friendly display of MARC leader metadata. It relies on a few utility modules, validates parameters, and will raise errors for unknown options, invalid language codes, or missing color support when requested.

XML::Chain gives you a concise, chainable API for building and editing XML in Perl so you can create documents with readable, jQuery-like calls instead of wrestling the raw DOM. You start with the xc() factory to create a document or wrap existing XML, then chain methods to add elements, attributes, text, traverse up and down, run XPath queries, and read or write files via IO::Any, which makes tasks like generating sitemaps or simple XML transforms very straightforward. The module integrates XML::LibXML under the hood and includes conveniences such as a "-" attribute shortcut for element text, safe default parsing, namespace support, and selector-style methods for filtering and mapping nodes. Recent updates improved namespace handling, added functional helpers (map_selection and grep_selection) and per-element metadata storage with data(), made formatting non-destructive, and sped up internals for much better performance, so it is a good fit when you want expressive, easy XML construction and light DOM manipulation without low-level boilerplate.

App::DrivePlayer is a GTK3 desktop music player that streams audio files directly from your Google Drive while keeping a local SQLite library of scanned folders and tracks for fast browsing and playback. It can sync and share track metadata across devices using a Google Spreadsheet, fetch metadata automatically from services like AcoustID, MusicBrainz and iTunes, and optionally read embedded FLAC tags, all while performing long-running metadata work in the background so the UI stays responsive. Playback is handled via mpv and the interface offers folder-scoped browsing, live row updates as metadata arrives, editable metadata that can auto-sync to the sheet, and conveniences like an A–Z sidebar and a Year column with a new convention that extracts year prefixes from filenames or folders. Recent updates focus on safer, unified two-way sheet sync and merge behavior to avoid overwriting useful data, fixes to playback auto-advance and list scrolling, and other UI improvements that make syncing and streaming more reliable across intermittent network conditions.

Music::Drummer is a tiny, friendly alias for the MIDI::Drummer::Tiny module that exposes the same simple MIDI drum utilities under a more discoverable name and with drum-related keywords. It provides the same object-oriented interface for creating a drummer instance, doing a count-in and playing simple drum patterns, but does not add new functionality beyond the underlying MIDI::Drummer::Tiny implementation. Use this module if you want an easy-to-find package name on CPAN or prefer its wording in your code; otherwise install MIDI::Drummer::Tiny directly. Recent releases mainly keep the alias in sync with upstream changes and update prerequisites.

MIDI::Drummer::Tiny is a lightweight Perl toolkit for programmatically building drum parts and exporting them as MIDI files. It provides ready-made metronomes for common and odd meters, named percussion patches, a rich set of musical durations, and helpers for common drum gestures like flams, rolls, crescendo rolls and fills, plus pattern and sync facilities to combine multiple voices. You control tempo, volume, time signature, bars and soundfont support and then write a standard MIDI file for playback or further editing. It is not a realtime drum machine but rather a composer-friendly API for constructing drum scores, generating practice tracks, algorithmic patterns or backing parts in code. The module is actively maintained and recent updates include groove handling improvements and, in 0.7014, a small API rename changing references from "cymbal" to "crash".

Check::Term::Color is a tiny, single-purpose Perl module that decides whether your program should emit colored terminal output by examining environment variables. It provides check_term_color($env_hr) which returns true or false based on the current %ENV or on a hashref you pass for testing, honoring the NO_COLOR convention from no-color.org and recognizing COLOR settings like GNU's --color option. Use it to gate colored output in scripts and to make color behavior easy to test. The module is dependency-light and straightforward to drop into existing code. This is the initial 0.01 release.

Hash::Util::Pick is a tiny Perl utility for non-destructively extracting or removing entries from a hash reference and returning a new hash reference. It gives a simple API: pick and omit to copy or drop specific keys, and pick_by and omit_by to select or exclude entries using a user-supplied predicate. The module is useful when you need to create trimmed or sanitized versions of data structures without mutating the original, and its minimal, Lodash-inspired interface makes it easy to drop into scripts or larger applications. The code is lightweight, MIT licensed, and aimed at straightforward, readable hash transformations.

Text::Names::Abbreviate is a lightweight Perl module for turning full personal names into concise, configurable abbreviations. It understands both "First Middle Last" and "Last, First Middle" input forms and can emit several styles such as initials, compact (no punctuation), shortlast (initials followed by the full last name) and last-first ordering, with a customizable separator between initials. Single-word names are left unchanged and the routine will croak on missing, empty, or invalid parameters. Be aware that formats like compact and initials are lossy and initials are taken verbatim so punctuation or digits will be preserved. The 0.02 release tightens argument handling by using Params::Get, fixes edge cases (including correctly handling "0"), and adds fuzz testing and a more complete test suite.

Langertha is a Perl toolkit that gives you a single, consistent API for talking to many large language models and local inference servers, so you can switch between providers like OpenAI, Anthropic, Google Gemini, Ollama and others without rewriting your code. It supports chat, streaming, embeddings, transcription and image generation, exposes rich response metadata and rate limit info, and offers both synchronous and async usage patterns. Built-in features include automatic tool calling, a stateful autonomous agent called Raider with plugin support, dynamic model discovery and optional Langfuse observability. If you need a unified Perl layer to prototype or deploy LLM-driven features and agents across multiple providers this module is likely relevant, but be aware the API is a work in progress.

JSON::LINQ provides a LINQ-style, method-chained query API for working with JSON and JSONL files in Perl, letting you filter, project, group, sort and aggregate JSON data in a readable, fluent way. It brings the 60-method LINQ surface from LTSV::LINQ plus JSON-specific I/O helpers (FromJSON, FromJSONL, FromJSONString, ToJSON, ToJSONL) and boolean singletons JSON::LINQ::true and ::false, and supports streaming JSONL with O(1) memory while FromJSON loads a top-level array once and then iterates lazily. The module includes a pure-Perl built-in JSON encoder/decoder so no CPAN JSON module or XS is required and it even runs on very old Perls back to 5.005_03. The bundled parser has a few documented limitations such as no surrogate pair support, possible infinite recursion on circular references during encoding, and stringification of non-ARRAY/HASH references. This initial release is a convenient choice for querying, transforming and streaming JSON data in Perl, especially for log processing, ETL and quick data analysis without adding external dependencies.

LMDB_File is a Perl interface to the Lightning Memory-Mapped Database (LMDB) that lets Perl programs use a tiny, extremely fast embedded B-tree key/value store with full transactional semantics. It exposes LMDB concepts as Perl classes such as LMDB::Env to open an environment, LMDB::Txn for transactions, LMDB::Cursor for iteration and a convenience LMDB_File object that pairs a transaction with a database so you can use familiar put, get and delete calls or even tie a hash to a database for simple use. The module supports LMDB features like named databases, duplicate keys, custom key comparators, and a zero-copy read mode to avoid memory copies when you need maximum throughput. It also provides UTF-8 mode to automatically encode and decode text, configurable error handling, and a rich set of flags to tune durability and performance. Recent updates keep compatibility with modern Perl releases and add support for transaction identifiers and other maintenance fixes, so this module is a good choice if you need a lightweight, high-performance embedded database from Perl.

App::Raider is a compact CLI wrapper around Langertha::Raider that gives you an autonomous coding and system agent able to inspect a project tree, read and edit files, run bash commands, and fetch web content while being confined to a configurable project root. It ships with filesystem and shell tools, web search and fetch, automatic engine selection from *_API_KEY environment variables with sensible per-engine defaults, and flexible skill loading from Claude/OpenAI-style skill files or plain markdown directories. Configuration is straightforward via a .raider.yml file plus command line overrides and engine options, and the tool includes a REPL with persistent history, live trace and situation-injection plugins, on-the-fly skill documentation export, and session token reporting. The initial release emphasizes a small, practical toolbox and an almost unlimited tool-calling loop by default while exposing safety caps and tuning parameters for developers who want an interactive autonomous agent to explore, summarize, and modify repositories from the command line.

Mojolicious::Plugin::OpenAPI::Modern makes it easy to wire an OpenAPI::Modern document into a Mojolicious app so you can validate requests and responses against your OpenAPI schema. You register the plugin with a schema, a filename or URI for the document, or pass an existing OpenAPI::Modern object, and the plugin provides a shared openapi helper plus validate_request and validate_response helpers that return JSON::Schema::Modern::Result objects. You can also supply an after_response callback for post‑response checks or logging, and the plugin stores useful operation metadata under stash->{openapi} for controllers and templates. Matching is done from the request URI itself rather than Mojolicious route objects and the shared OpenAPI::Modern instance is reused across requests. Recent updates keep the plugin compatible with changes in the OpenAPI::Modern error handling and test behaviors.

SQL::Wizard is a Perl library for programmatically building SQL using composable expression trees so you can construct SELECT, INSERT, UPDATE, DELETE and compound queries as nested, immutable objects and only render SQL with placeholders and bind values when you call ->to_sql. It treats everything as an expression so columns, functions, CASE, subqueries, joins, window functions, CTEs and arithmetic can be nested naturally, it defaults to safe bind-parameterization and automatic identifier quoting to reduce injection risk, and it produces ANSI SQL by default with optional MySQL quoting. The API is designed for developers who want fine-grained control without hand-crafting SQL strings and it integrates with DBI by returning a SQL string and ordered bind values ready for execute. Note that recent releases introduced an important behavior change: as of 0.10 a hashref value that is an arrayref now generates OR conditions for each element rather than an IN list, so use the explicit -in form for IN clauses; 0.11 relaxed alias validation to allow dotted aliases in ->as().

LRU::Cache is a compact, C-backed Least Recently Used cache for Perl that delivers constant-time operations for common cache tasks. It stores key/value pairs up to a fixed capacity and automatically evicts the least recently used entry when space is needed. The module provides a simple object-oriented API for set, get, peek, exists, delete, size, capacity, clear, keys, oldest, and newest operations and also offers a function-style API you can import for even lower call overhead. The function-style calls avoid method dispatch and yield substantially higher throughput for get and set, making this a good choice when you need a fast in-memory LRU cache with minimal latency.

DBIx::Wizard is a lightweight, chainable database toolkit for Perl that sits between raw DBI and heavy ORMs like DBIx::Class. Point it at a DSN and table and you can build queries with a fluent API like ->find->sort->limit->all without defining schemas or result classes. It uses SQL::Wizard to generate safe, composable SQL expressions so you can use column and function expressions, joins, subqueries, window functions and arithmetic in queries. Rows come back as plain hashrefs and the module supports inserts, updates, deletes, aggregates, streaming cursors, automatic DateTime inflation with configurable classes, transactions with nested savepoints, and environment-driven database registration for twelve-factor style deployments. Debug logging is available via environment variables. If you want an ergonomic, minimal ORM for straightforward SQL work in Perl, DBIx::Wizard gives you fast, zero-configuration access to powerful SQL features.