CPANscan

MIDI::RtController::Filter::Tonal is a collection of ready-made tonal filters you can plug into MIDI::RtController to turn incoming note events into musical material like pedal tones, diatonic chords, delayed echoes, offset notes, arpeggios and walking melodies. Each filter is configurable with musical parameters such as pedal note, delay time, feedback, velocity, key, scale, intervals and arpeggiation type so you can shape behavior for live performance or generative accompaniment without writing low-level MIDI handling. Filters are used as callbacks on a controller instance and return a boolean to control further processing, and a helper function lets you declaratively add lists of filters to controllers. The recent 0.0500 release adds a simple single_tone filter for triggering individual notes. This module is handy if you want quick, musically informed MIDI processing for performance, composition experiments or automated backing parts.

SQL::Wizard is a Perl library for building SQL programmatically by composing expression trees and rendering them only when you call to_sql, which returns a SQL string with "?" placeholders and the correct bind values for DBI. It treats everything as an expression so columns, functions, CASEs, subqueries, joins, window functions, CTEs, unions and more can be nested freely, and its modifier methods are immutable so you can build a base query and derive many variants without side effects. Plain Perl values become bound parameters by default to reduce injection risk while val, col and raw let you control binding or inject literal SQL when necessary. The API follows familiar SQL::Abstract-style WHERE syntax and adds conveniences like operator overloading for arithmetic, ON CONFLICT and ON DUPLICATE handling for upserts, RETURNING, and both inline and named window specifications. Output is currently standard ANSI SQL with a reserved dialect option for future tweaks. Use SQL::Wizard when you want readable, composable, and testable SQL generation in Perl with no non-core dependencies.

Term::TablePrint is a small utility for printing and interactively browsing tabular data in a terminal, taking a reference to an array of arrays where the first row holds column names and the rest are data rows. It displays a movable cursor for row selection, supports keyboard navigation like arrows, page up/down, home/end, and a regex search prompt with Ctrl-F, and can either jump to the header or "expand" a row so each column is shown on its own line. The module automatically paginates and adapts column widths to the terminal, offers options for color, column selection, whitespace squashing, binary-data handling, numeric formatting and truncation, and a progress indicator for large datasets. You can call it procedurally via print_table or instantiate an object for repeated use. It requires decoded strings, a matching STDOUT encoding layer and Perl 5.16.0 or newer. Recent releases focus on code refactoring and stability with the latest v0.177 fixing an undefined-value bug in single-row printing and updating dependency version requirements.

DBIx::Class::Async wraps DBIx::Class in a non-blocking, multi-worker bridge that turns normal DBIC calls into Futures so your event loop stays responsive while database work runs in background processes. It maintains a pool of worker processes that each hold a persistent DB connection, accepts resultset and row operations on the main process, sends them to workers over pipes, serialises results back and resolves Futures so your app can do true parallel queries, batch transactions and modern async/await styles with IO::Async or frameworks like Mojolicious. The module also provides features useful for production use such as optional CHI-based caching, deterministic SQL generation for reliable caching and debugging, query-preview helpers, metrics integration, and convenience methods like run_parallel and await_all. You should be aware it is described as experimental, custom result objects must be serialisable across processes, and caching is disabled by default because stale results can be dangerous for nondeterministic SQL. A recent 0.64 fix improves handling of InflateColumn::DateTime by correctly re-inflating datetime columns in the parent process so stringification matches the database format. If you need responsive, high-concurrency DBIC access without blocking an event loop, this module is directly relevant.

CPANSA::DB exposes the CPAN Security Advisory reports as a ready-to-use Perl data structure, primarily consumed by CPAN::Audit but useful to any Perl code that needs programmatic access to CPAN security advisories. Its single subroutine, db(), returns a hashref containing all advisory entries so you can easily query or process the data in your own tools. Releases are published on GitHub and include a .gpg signature and a GitHub attestation so you can verify the archive and ensure the data has not been tampered with. A JSON file with the same dataset is also provided for non-Perl consumers. Use this if you need an authoritative, verifiable source of CPAN security advisory data for auditing, monitoring, or automation.

Test::Expander is a helper for writing Perl test scripts that reduces boilerplate around Test2::V1 by auto-detecting the module and method under test, exporting handy read-only variables like $CLASS, $METHOD and $METHOD_REF, and providing quick support for temporary directories and files. It includes a test_table function that makes table-driven testing easy either from a separate .tdt file or from inline data, brings in select Path::Tiny and File::Temp helpers, and exports several Test::More and Test::Exception routines for smoother migration of older tests. You can configure a clean, cascading test environment with simple .env files, override builtins or @INC entries, select subtests to run by name or number when invoking prove, and opt to bail out immediately on the first failure. The module is aimed at Perl developers who want clearer, more maintainable tests with less repetitive setup and is best used as the first module loaded in a test file.

Data::NestedKey is a lightweight, object-oriented Perl utility for working with deeply nested hash structures using simple dot-separated key paths, so you can set, get, delete and check values without writing manual traversal code. You instantiate it with an existing hash or key/value pairs and then use set and get with paths like foo.bar.baz to update or retrieve values; set also supports a + prefix to append or merge and a - prefix to remove elements. The object can serialize itself to JSON, YAML, Data::Dumper or Storable with pretty JSON by the default and is especially useful for programmatic edits of structured configuration files. The recent 0.06 release added the +/- append/remove syntax, stringification so the object interpolates to its serialized form, and the ability to construct an empty object.

Bored is a tiny, tongue-in-cheek Perl module that provides a handful of no‑op routines and an object interface to express boredom or serve as playful placeholders in scripts. You can import the simple procedural function bored_one or create a Bored object and call methods such as pointless(), waiting(), and tortured() to get trivial, humorous behavior suitable for demos, tests, or adding comedic fluff to code. The module is intentionally lightweight and not meant for production functionality, and it is released under the Artistic License 2.0. The distribution is an early, minimalist release that mainly supplies these basic stubs for amusement or illustrative use.

Mooish::Base is a simple importer that gives you a ready-made, consistent starting point for building classes or roles with the Moose family of object systems. By default it pulls in Moo, Mooish::AttributeBuilder, Types::Common and namespace::autoclean so you avoid repetitive boilerplate, and you can request role behaviour with the -role flag to import Moo::Role instead. A pair of environment variables let you substitute different flavour implementations before the module is loaded and an extra-variable lets you opt into additional performance add-ons if they are installed such as Type::Tiny helpers or faster constructor/accessor backends, though XSConstructor support is disabled by default because it is not yet stable. The module only loads extras that do not change runtime behavior, it will try to make Moose classes immutable when appropriate and it provides a $Mooish::Base::DEBUG hook that records what was loaded for each class to help debugging. Module authors are encouraged to use the -standard flag to avoid leaking caller-specific customizations and to ensure stable, predictable imports for downstream users.

Testcontainers for Perl is a simple library for running disposable Docker containers as part of automated integration and smoke tests, letting you programmatically start services, wait until they are ready, and clean them up when tests finish. Its tidy API exposes a run function that returns a container object you can query for host and mapped ports and a terminate method to remove the container, and it supports environment variables, labels, custom commands, network settings, and startup timeouts. The module includes built-in wait strategies such as waiting for a listening port, an HTTP endpoint, log output, or a health check, plus convenience modules for common services like PostgreSQL, MySQL, Redis, and Nginx. It uses WWW::Docker as the Docker client and handles port mapping and host resolution for you, with optional overrides via DOCKER_HOST and a flag to disable the Ryuk resource reaper. If you need reliable, short-lived containerized dependencies for test suites, this module gives a straightforward, test-friendly way to manage them.

Langertha::Skeid is a control-plane and lightweight proxy for routing requests across many LLM backends while collecting normalized token and cost metrics for consistent billing and observability. It keeps a live node table and chooses targets by model, health and capacity so you can front cloud and local engines from one API edge, and it records usage in a single ledger so tenant billing and cost reports are straightforward. The usage storage layer is pluggable and the release adds a recommended jsonlog backend that writes one JSON file per event or a JSON-lines file to avoid DBI dependencies, while also supporting SQLite and PostgreSQL or user-provided callbacks or subclass overrides. Admin routes are protected by a configurable API key and can be hidden entirely when no key is set. The module includes helpers for pricing and cost estimation, non-blocking proxy handling for higher concurrency, a CLI for usage reporting, and example configs to get started. Noteworthy in this initial release is the move to make usage storage swappable and DBI optional so you can deploy without a database, and the extraction of the control-plane from the Knarr project as a standalone package.

App::uniprint is a small command-line utility that prints every Unicode character from its input together with that character's codepoint and official Unicode name, making it easy to inspect text at the character level. It is useful for finding invisible or unexpected characters, debugging encoding problems, and learning what specific glyphs actually are without digging through Unicode tables. The tool is distributed as the uniprint script and the project is hosted on MetaCPAN and GitHub. This is the initial release of the module.

Data::HashMap::Shared provides file-backed, type-specialized hash maps in shared memory so multiple Linux processes can read and update the same table efficiently. It ships ten prebuilt variants for integer and string keys and values, uses a futex-backed seqlock design to enable lock-free fast reads, and provides lock-free atomic increments, optional LRU eviction and per-key TTL for cache-style use, elastic resizing, and an arena allocator for stored strings. You can use a compact keyword XS API for maximum speed or the regular method API, and the module supports safe iteration, independent cursors, and diagnostics for capacity and eviction statistics. The implementation detects and recovers from writers that die while holding the write lock by checking PIDs, but this assumes a shared PID namespace so cross-container sharing is not supported, and clearing the map after a recovery is recommended for safety-critical cases. The initial 0.01 release brings the ten type-specialized variants, bundled xxHash, eviction and TTL features, and the performance primitives that make this well suited for high-throughput interprocess caches and counters on 64-bit Linux.

XML::PugiXML is a Perl interface to the fast pugixml C++ parser that gives you quick, memory-safe XML parsing, XPath queries, and a familiar DOM-style API for inspecting and modifying documents. It automatically handles UTF-8 for inputs and outputs, provides compiled XPath support for repeated queries, and exposes convenient methods for navigating nodes and attributes, creating or cloning elements, and serializing with configurable formatting and parse options. The module uses reference counting so node handles keep their parent document alive, avoids processing external entities by default, and reports parse errors via return values while throwing on XPath syntax errors. The recent 0.02 update added stale-handle detection to prevent segfaults after a reset or reload, enabled XPath attribute selection and an Attr::element() parent accessor, upgraded all string inputs to UTF-8, and improved 64-bit integer handling on 32-bit Perls, making it a robust choice when you need high-performance XML work from Perl.

EV::ClickHouse is an asynchronous ClickHouse client for Perl that integrates with the EV event loop and lets you issue queries and inserts without blocking your application. It speaks both the HTTP and native TCP protocols, supports optional TLS, gzip and LZ4 compression, per-query and connection-level settings, streamed results via an on_data callback, INSERTs from TSV or arrayrefs, query timeouts, cancellation and automatic reconnect with exponential backoff. The native protocol returns typed columns and provides opt-in decoding for Date/DateTime, Decimal and Enum types and an option to return named rows as hashrefs, while accessors expose metadata like column names, server version and query profiling info. Note that DNS resolution is currently blocking so use IP addresses or a local caching resolver for fully asynchronous behavior. The initial 0.01 release delivers the core feature set including async HTTP queries, native binary protocol support, compression, streaming, parameterized queries and useful metadata and control hooks.

EV::Etcd is a high-performance asynchronous etcd v3 client for Perl that uses the native gRPC Core C API and integrates with the EV/libev event loop. It exposes the full etcd surface in a non-blocking way, including key/value operations, watches with automatic reconnect, leases and keepalives, distributed locks, leader election, transactions, cluster membership and maintenance commands, plus full authentication and role management. Callbacks receive structured error hashrefs with gRPC status and a retryable flag so you can implement sensible retry logic, and streaming operations return handle objects you can cancel or configure with options like auto_reconnect and max_retries. The client also offers health monitoring and multi-endpoint failover for resilient deployments, but note that EV::Etcd objects are not fork safe and you should create a new client in child processes. Recent maintenance releases fixed load-order and edge-case bugs and improved error and watch handling for greater robustness.

Regexp::Common is a convenience library of ready-made, reusable regular expressions exposed as a tied hash %RE or as exported RE_* subroutines so you can quickly match things like balanced delimiters, many comment syntaxes, delimited and quoted strings, numbers, IP and MAC addresses, whitespace trims, postal codes, profanity and more without writing the regex yourself. Patterns are customizable with flags such as -keep to turn on captures and -i for case insensitive matching, and they are returned as objects so you can call matches() or subs() for inline matching and substitutions; if you need speed you can use the functional RE_* interface which returns qr// regexes. You can also register your own pattern generators at runtime with pattern(), choose which pattern sets to load, and combine flags to curry specialized matchers. Be aware that patterns are deliberately unanchored so they match substrings unless you anchor them, and some advanced patterns require a modern Perl because they use newer regex features. The module is actively maintained and the latest release removed legacy use vars and updated the MySQL comment pattern.

DBD::Pg is the standard Perl DBI driver for talking to PostgreSQL databases, letting you open connections, run queries, manage transactions, and fetch results from Perl programs. It supports server-side prepared statements, a rich set of placeholder styles, and explicit control over AutoCommit and transactions including savepoints. The driver also handles PostgreSQL-specific features such as array types, bytea and geometric types, large objects, fast COPY-based bulk import/export, asynchronous queries and connects, and helpers for quoting, encoding, and last-insert-id retrieval. You can import PostgreSQL type constants and limits for precise bind_param use, and there are many driver-specific attributes to tune behavior like UTF8 handling and when to switch to server-side prepared statements. DBD::Pg is actively maintained with source and issue tracking on GitHub, and the documentation warns to explicitly set AutoCommit and to be aware that server-side prepares can change how some statements behave. If you need reliable, full-featured PostgreSQL access from Perl, DBD::Pg is the relevant module.

Thrift::XS is a drop-in, faster implementation of the Perl Thrift binary and compact protocols and the in-memory transport, implemented in XS to accelerate encoding and decoding of Thrift RPC payloads. If you already use Perl Thrift clients you can usually switch by replacing the standard BinaryProtocol or MemoryBuffer classes with Thrift::XS::BinaryProtocol or Thrift::XS::CompactProtocol and Thrift::XS::MemoryBuffer to get substantial throughput and latency improvements, especially for many small reads and writes. For the biggest gains use it with an optimized socket layer and the XS memory buffer because standard transports such as BufferedTransport, FramedTransport, or HttpClient may limit the benefit and HttpClient is known to make many tiny syscalls. Recent releases moved the build and release process to Dist::Zilla, added a security policy, and made Thrift a declared dependency after removing the previously embedded copy, so installation now relies on the upstream Thrift distribution.

Masscan::Client is a simple object-oriented Perl wrapper around the Masscan network scanner that makes it easy to assemble, run, and parse high-speed port scans from Perl programs. You build a client by adding hosts, ports or port ranges and any extra masscan arguments, optionally set the binary path, verbosity or DNS servers, then call scan and receive the results as a native Perl data structure containing per-host timestamps and open-port details. The module handles command-line construction, JSON output parsing and logging via Log::Log4perl and will try to find the masscan binary on your PATH if you do not provide one. It relies on common CPAN modules such as Moose and Net::DNS and requires the external masscan program plus the necessary execution privileges, so it is a good fit for scripts and tools that need to orchestrate automated network scans from Perl.

Graph::Easy is a Perl library for building, parsing and rendering node and edge graphs into readable diagrams and portable formats. You can create graphs programmatically or from a simple text syntax, attach attributes to nodes, edges and groups, and then render the result as ASCII art, Unicode box drawing, HTML with CSS, SVG (with an optional helper module), Graphviz DOT, GraphML or legacy GDL/VCG. Its built in Manhattan grid layouter is geared toward flow charts, network diagrams and hierarchical trees and makes it easy to produce compact, human friendly diagrams or to pipe DOT output to Graphviz when you need more advanced rendering. The module supports anonymous nodes, groups, multi edges and basic animation steps for describing state flows though animations are not yet exported to output. There are a few known layouter limits such as imperfect group nesting and missing group-to-node link handling and there is no internal scoring or second stage optimizer, but for quickly creating and exporting diagrams in many formats Graph::Easy is a practical, easy to use choice.

Getopt::Guided is a Perl library for parsing short command-line options with POSIX utility behavior. It offers an iterator-style getopts that parses @ARGV or a supplied array, fills a hash of option values including multi-value options, and supports flags that can be negated or incremented. The processopts helper maps parsed options to scalar or array references or to callback routines so you can attach semantics and control precedence, and it respects an end-of-options signal so callbacks can stop processing early. There is also readopts for loading default options from an rc file in XDG_CONFIG_HOME and print_version_info to implement a standard -V version display. Exports are opt-in and the module follows semantic versioning. A recent 3.1.0 release added readopts and a program_name helper and made some exit status constants exportable, while 3.1.1 focused on documentation and packaging fixes.

Data::HashMap is a family of ultra‑fast, type‑specialized hash maps implemented in C for Perl that give you compact, high‑throughput in‑memory maps with both a blazing keyword API that bypasses Perl method dispatch and a convenient method API. Each variant is tuned for a particular key/value combination (integers, strings, or Perl SV* values) and supports common map operations plus integer counters, iteration, bulk snapshotting, and cache features such as LRU eviction and TTL expiry with optional per‑key TTL. The implementation focuses on performance and low memory overhead compared with Perl hashes, uses open addressing and xxHash, and exposes useful extras like get_or_set and zero‑copy reads for string values. Note that some integer variants require 64‑bit Perl and that string zero‑copy results are read‑only and must not be retained past any map mutation; the iterator also resets if structural changes trigger rehash or compaction. Recent updates include switching to bundled xxHash v0.8.3 and a new get_direct keyword for zero‑copy string lookups, improving lookup speed and reducing allocations for read‑heavy workloads.

Net::Async::Zitadel is an asynchronous Perl client for the Zitadel identity platform that gives you non-blocking OIDC and management API access inside an IO::Async event loop. It uses Net::Async::HTTP and Future-based return values so you can verify tokens via JWKS, use discovery and userinfo endpoints, and perform CRUD operations on users, projects, applications and organizations without blocking your program. The module wraps the WWW::Zitadel API surface and lazily builds OIDC and management helpers; a Personal Access Token is optional unless you need the management API, which will die if no token is provided. If you need a lightweight, event-loop friendly interface to Zitadel from Perl, this module provides the common OIDC and management features in a familiar async style and points to a GitHub repo for issues and contributions.

WWW::Zitadel is a Perl client for the Zitadel identity platform that bundles an OpenID Connect helper and a Zitadel Management API client. It makes it easy to discover JWKS, verify and decode JWTs, and call userinfo endpoints, and it provides CRUD operations for users, projects, applications and organizations. The OIDC part works with any OIDC-compliant provider and uses Crypt::JWT for token validation. Administrative calls go through the management client and require a Personal Access Token. Both subclients are constructed lazily from a simple WWW::Zitadel object configured with the issuer URL.

POE::Component::ElasticSearch::Indexer is a ready-made POE session that lets event-driven Perl programs push documents into an Elasticsearch cluster without blocking your main loop. It batches records and uses Elasticsearch's bulk API for throughput, accepts simple hashes, prebuilt newline JSON, or objects that provide as_bulk, and understands per-document hints like _index, _id, _type and _epoch so you can route or name indices dynamically. The component handles connection pooling, timeouts, periodic flush-by-time or flush-by-size, optional HTTP basic auth, and can write failed batches to disk for later recovery while offering hooks for custom statistics and cleanup. Defaults are tuned for log-style indexing (logs-%Y.%m.%d and _doc), and the module will strip types for clusters newer than 7.x. Recent updates improved logging, changed the default protocol handling, and switched to using the wire compatibility version to improve compatibility with OpenSearch. If you build POE-based loggers or evented pipelines that need efficient, resilient indexing into Elasticsearch or OpenSearch, this module gives a compact, configurable solution.

Term::ReadLine::Repl is a lightweight framework for building interactive command shells in Perl that takes care of the terminal plumbing so you can focus on your commands. You register commands as a cmd_schema that maps names to exec coderefs and optional argument descriptions, and the module provides tab completion, in-session and optional persistent history, a built-in help and quit commands, and an optional "!" shell passthrough for one-off system commands. It also offers hooks for Getopt::Long-style parsing and a custom per-loop callback to alter behavior or swap command schemas at runtime, and a simple run() method drops the user into the REPL and saves history on exit. Use this when you need a ready-made, extensible interactive prompt without reimplementing completion, history, or basic REPL controls.

JSON::Schema::Modern is a mature, actively maintained Perl evaluator for JSON Schema that supports the current Draft 2020-12 and earlier drafts and lets you validate either Perl data structures or JSON strings and receive a structured Result object describing success, errors and annotations. It is highly configurable so you can select the specification version, control short‑circuiting, enable or supply custom format validators, register media type decoders and content encodings, add custom vocabularies, collect defaults that should be applied to missing data, and preload or cache parsed schema documents to speed startup in preforked environments. The module exposes high level APIs to add schemas or prebuilt document objects, to traverse schemas for analysis, and to run targeted evaluations with callback hooks. It does not automatically fetch schema files from disk or the network and some format checks depend on optional CPAN modules, so you should add any custom format, media type or encoding handlers you need and avoid using untrusted schemas because regular expressions and numeric operations in schema or data can be expensive or risky. A recent update fixed the hostname and duration format validators to more strictly reject IP addresses and disallow fractional duration units in cases where the specification does not allow them.