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.

Alien::libwebsockets helps Perl distributions find or build the libwebsockets C library so you can link it into XS or other compiled code. The module will use a system installation if one is available or download and compile libwebsockets from source with libev, SSL, zlib, and permessage-deflate extension support, and it exposes compiler flags and linker flags for use with ExtUtils::MakeMaker. It also provides a has_extensions method to detect permessage-deflate support, though that detection uses symbol inspection and is reliable only for the module's own shared installs and may return false for untracked system libraries. The initial release bundles libwebsockets 4.3.3 and is intended to make it easier to consume libwebsockets from Perl distributions.

NBI::Slurm is a Perl toolkit for preparing and submitting jobs to SLURM-based HPC clusters. It gives you NBI::Job to model a job and NBI::Opts to build SLURM options such as queue, threads, memory, runtime and output file paths, and to generate the job script header. You can submit jobs programmatically, inspect queues and squeue availability, run system commands while capturing stdout and stderr, and use the accompanying command-line utilities for common workflows. Recent releases added an energy-aware scheduler module NBI::EcoScheduler, support for SLURM --begin via start_time and start_date, and --eco/--no-eco flags with configurable eco windows, making it easy to defer work to low-energy slots by default. The package is actively maintained and distributed under the MIT license.

Log::Any is a tiny, dependency-light logging façade for Perl that lets CPAN modules produce log messages without forcing applications to pick a logging backend. Module authors use a simple logger object (for example via use Log::Any '$log') and call familiar methods like debug, info, warn, and error or their printf-style variants, and applications choose where those messages go by configuring Log::Any::Adapter to route logs to Log::Log4perl, Log::Dispatch, files, syslog, or other consumers. It supports structured and contextual logging, standard log levels and aliases, level checks for efficiency, and a null default so libraries can safely emit logs even when an application has not configured a consumer. The project is deliberately minimal to encourage wide adoption and avoid adding heavy dependencies, and recent maintenance releases fixed test issues on Windows and cleaned up documentation and a few adapter-related bugs. If you write libraries that should be polite about logging or build applications that want flexible control over where logs end up, Log::Any is a relevant, low-friction choice.

Syntax::Feature::With provides a lightweight way to emulate Pascal's with statement in Perl by temporarily aliasing hash entries to lexical variables inside a coderef, so you can read and write %hash entries simply by using lexicals declared in the outer scope. It uses PadWalker and requires no XS, parser hooks, or syntax changes, and supports nested with() calls and a small convenience wrapper with_hash for cleaner call sites. Built-in modes let you enforce correctness with -strict where every hash key must have a matching declared lexical, debug to print which keys were aliased or ignored, and trace to show entry and exit with nesting depth. Limitations include the need for outer-scope lexicals, only hashrefs are supported, and only keys matching /^[A-Za-z_]\w*$/ are eligible. The distribution is hosted on GitHub and this 0.01 release is the initial draft, and licensing is GPL2 for personal single-user use while other uses should contact the author for licensing.

Plack::App::DirectoryIndex is a small PSGI/Plack application that serves static files from a document root and provides Apache-style directory listings while automatically serving a default index file such as index.html. It is configured with a root directory and an optional dir_index filename, and can render directory listings with optional Font Awesome icons and an enhanced CSS theme for a prettier appearance. Use it when you need a simple standalone static file server for development or lightweight hosting that falls back to an index file before showing a listing. If you do not want automatic index files you can use Plack::App::Directory or Plack::App::File instead.

WebServer::DirIndex reads a filesystem directory and builds the data needed to render a web server directory listing, and it can also produce a ready-to-serve HTML index page. You create an object with the directory path and its URL and control presentation with the pretty and icons options, then inspect entries via files (each a WebServer::DirIndex::File) or call to_html to get a complete HTML page. The module can add MIME-aware Font Awesome icons and an enhanced CSS theme for a more attractive listing, or produce a plain listing if you disable icons. Note that as of 0.1.0 the pretty option is set when constructing the object rather than when calling to_html and enabling pretty now also turns on icons unless you explicitly pass icons => 0; the distribution targets modern Perls (Perl 5.26+). This is a lightweight, easy way to generate customizable directory indexes for static sites or simple web applications.

MetaCPAN::API is a now-deprecated Perl client that wraps the MetaCPAN REST API and gave Perl programs simple, DWIM-style methods to look up authors, releases, modules and other CPAN metadata while also exposing low-level fetch and post helpers. It uses HTTP::Tiny as its user agent by default, lets you point it at a custom base_url (defaulting to https://fastapi.metacpan.org/v1) and pass ua arguments, and can be used with cached user agents for offline or faster access. This module has been superseded and rewritten as MetaCPAN::Client, so you should not start new code with MetaCPAN::API; use MetaCPAN::Client instead. For historical users, the recent 2026 update fixed tests against the current MetaCPAN API, improved error messages by including response content, and updated author tooling.

App::CPAN::Dependents is a lightweight tool and library for finding which CPAN distributions depend on a given module or distribution. It provides the find_all_dependents function and a cpan-dependents command line wrapper that query the MetaCPAN API recursively to build a list of reverse dependencies, with options to include recommends, suggests, or develop-phase prerequisites and to supply a custom MetaCPAN::Client or HTTP::Tiny object for network control. Because it relies on live MetaCPAN queries it needs internet access and can take some time to complete, it will die on HTTP errors, and it only finds prerequisites explicitly listed in distribution metadata so dynamic or unindexed modules are not captured. A recent fix updates the MetaCPAN search filtering to work with newer Elasticsearch backends.

Async::Redis is an asynchronous Redis client for Perl built on Future::IO that gives you a modern non-blocking API with async/await support via Future::AsyncAwait. It works with multiple event loop backends, supports TLS, automatic reconnect with backoff, connection pooling, pipelining and auto-pipelining, transactions, PubSub with replay on reconnect, and efficient Lua scripting with automatic EVALSHA optimizations. The module is fork-safe and includes OpenTelemetry hooks for tracing and metrics, plus safe concurrent command handling on a single connection to avoid response-matching races. Note that Async::Redis no longer configures Future::IO itself so your application must choose and load the event loop implementation at startup. Recent updates fixed socket close ordering and concurrency issues to make disconnects and parallel command handling more robust. This module is a good fit if you need a fully asynchronous, production-ready Redis client that integrates with existing Perl event loops and high-throughput services.

SPVM is a statically typed language with Perl-like syntax that aims to give Perl developers a familiar feel together with compiled, high-performance execution. You can run SPVM scripts directly or compile them ahead-of-time or via JIT to produce standalone executables, and the runtime supports native threads and goroutine-style concurrency. The project offers C and C++ bindings and an exchange API so Perl programs can call SPVM methods and SPVM code can leverage Perl standard functions and modules. Tooling covers building, distribution and dependency analysis, and the project includes extensive tutorials and examples. SPVM is still pre-1.0 and does not yet guarantee backward compatibility, so expect the language and tooling to evolve.

Lilith is a lightweight Perl tool for ingesting and querying EVE JSON alerts from Suricata, Sagan, and CAPE into a PostgreSQL database using DBI. It can create the required tables, import multiple EVE files by instance, and run as a long‑running processor that feeds alerts into the database while letting you ignore selected SIDs or classes. The module also exposes a convenient search API with many filters for IPs, ports, signatures, hashes and other fields, plus helper routines for producing short SNMP class names, so you can build dashboards or forensic queries without writing raw SQL. Configuration is simple and scriptable via DSN, user/password and TOML files. In the 1.0.0 release the author cleaned up the codebase, removed changeable table names and some legacy "baphomet" features, and added a Lilith_color_enable environment flag to control colored output.

POSIX::RT::SharedMem gives Perl programs a straightforward way to use POSIX named shared memory by mapping a shared memory object into a Perl variable so you can read and write it with normal string operations as long as you do not change its length. You call shared_open to attach to or create a named object such as "/somename" using familiar open-style modes and optional parameters like size, permissions, offset and extra flags, and you get back a filehandle suitable for stat, chmod and chown while using File::Map to access the contents as a scalar. shared_unlink removes the name from the namespace but the data remains until all processes close the object. This module is a simple, portable choice for exchanging data between unrelated processes and is generally preferable to SysV shared memory unless you need SysV compatibility.

Dist::Build is a modern, extensible Build.PL framework for packaging and building Perl distributions that focuses on building and installation rather than authoring tools. It uses an internal build graph so you can combine customizations cleanly and add features by dropping small planner scripts and calling load_extension, for example to install sharedir data or to compile XS code with add_xs. A rich plugin set supports common needs such as compiling XS modules, linking to Alien libraries, importing/exporting headers and flags, reading pkg-config, writing constants, and evaluating dynamic prerequisites. The planner exposes useful delegates for metadata, install paths and platform checks so build scripts can make informed decisions without low-level plumbing. Recent updates continue to improve XS support, most notably adding support for try_find_standard_for in the XS::Conf component to better handle language standard detection during compilation.

ExtUtils::Builder::Compiler is a small compatibility layer that presents a uniform interface to different C and C++ compilers so Perl extensions and native helpers can be built consistently across platforms. It is normally consumed by higher-level portability code such as ExtUtils::Builder::Autodetect::C rather than invoked directly, and provides methods to add include directories and preprocessor defines and to compile source files into object or executable targets. The module hides platform and compiler differences (MSVC, GCC, etc.) and integrates with the ExtUtils::Builder toolchain so XS authors and build tools can drive compilation without hand-coding many platform-specific flags. Recent maintenance work improves C++ support and module loading order, and the author has marked the ParseXS helper functions as deprecated.

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.