CPANscan

MIDI::RtController::Filter::CC is a collection of ready-made control-change filters that plug into MIDI::RtController to generate and manipulate MIDI CC messages in real time. You bind a filter to a controller, set simple attributes such as the CC number, channel, min and max range, step sizes and time_step, then add the filter to your controller either one at a time or in bulk with add_filters. The module provides common modulation patterns out of the box including a single static CC, clocked messages, breathing sweeps, random scatter, stair-step increments, ramp up and ramp down, and an on/off flicker, and each filter can be gated by note or value triggers and stopped with a halt flag. It is a practical choice for live performance or programmatic CC automation when you want configurable, reusable MIDI behaviors without implementing low-level MIDI handling yourself.

Object::Configure is a small utility that makes it easy to inject runtime configuration and logging behavior into Perl objects so you can tune modules without editing their code. It plugs into Config::Abstraction for file- or env-var-based settings and Log::Abstraction for flexible logger setup, merges configuration along a class inheritance chain (including an optional universal.yml for app-wide defaults), and provides an instantiate() wrapper so you can configure third‑party classes you do not control. It also supports a Unix-only hot‑reload feature that watches registered objects and reloads configuration on change, plus helper functions to register objects, trigger manual reloads, and manage the watcher. The author documents known tradeoffs such as global singleton state for the hot‑reload registry, lack of Windows signal support for hot reload, and a few implementation limits around deep merging and API consistency. The recent 0.23 release refactors inheritance handling to use mro::get_linear_isa and cleans up logger construction and several bug fixes around logger and env-var merge ordering.

MIDI::RtController::Filter::Drums is a small, practical module that plugs into MIDI::RtController to turn incoming MIDI events into playable drum phrases using MIDI::Drummer::Tiny. You create the filter with a controller, set how many bars and the bpm, provide a phrase callback that receives a drummer object plus any custom arguments, and optionally set a trigger note or CC value so the filter only runs on specific note_on or control_change messages. When the condition matches the module invokes your phrase and plays the drum pattern, making it easy to attach rhythm routines to hardware controllers or live MIDI streams. Recent updates include fixes for potential failing code and documentation cleanup in the 0.0402 release.

MIDI::RtController::Filter::Tonal is a toolbox of musical filters you can attach to a MIDI::RtController to transform live MIDI events into harmonies, arpeggios, delayed echoes and other tonal effects. It provides ready-made filters such as pedal_tone, chord_tone, delay_tone, offset_tone, walk_tone, arp_tone and single_tone, and exposes simple attributes like pedal, delay, factor, velocity, feedback, key and scale so you can tune how the filters behave. You can add groups of filters to controllers with the add_filters helper, or curry individual filter methods into controller event handlers for live performance or algorithmic composition. This module is aimed at developers who want musical preprocessing on real-time MIDI streams rather than low level MIDI plumbing. Recent updates added a single_tone filter and fixed some potential code failures to improve robustness.

MIDI::RtController::Filter is a lightweight base class for creating real‑time MIDI event filters that plug into MIDI::RtController. It defines the required filter method signature that receives the filter object, device name, delta time and a MIDI event arrayref and expects a boolean return value to indicate whether other filters should run. The class provides simple, usable attributes such as channel, value, trigger, running, halt and continue to hold filter state and control behavior, plus a verbose flag for progress output. Filters are attached to a controller with add_filter and can be bound to specific event types or to all events, making this module a convenient starting point for building reusable MIDI response logic.

Apophis is a Perl content-addressable storage library that deterministically turns any blob into a UUID v5 identifier so identical content always yields the same id while different namespaces keep ids distinct. It stores data on disk in a two-level hex-sharded layout for filesystem scalability, performs atomic writes via temp-and-rename, and provides natural content-addressable deduplication so re-storing existing data is a no-op. The API supports in-memory identification and streaming identification of large files with constant memory, plus simple store, fetch, exists, remove, verify, bulk operations and metadata sidecars, making it easy to build reliable blob stores. For extension authors Apophis now exposes a public C ABI (ap_abi.h) so other XS modules can call its primitives without a Perl frame, a capability added in version 0.05.

DBIx::Fast is a compact database helper for Perl that sits between raw DBI and a full ORM so you can keep writing SQL while offloading connection handling, transactions, caching and profiling to a single consistent API across SQLite, MariaDB/MySQL and PostgreSQL. It gives simple methods for common query shapes and CRUD operations, supports lazy and resilient connections, transactional blocks with automatic deadlock retry and savepoints, optional in-process or CHI-backed result caching with TTL and tag invalidation, and a query tracker and profiler for timing and slow-query analysis. Security is a focus with mandatory placeholders for values, identifier validation and quoting, and careful whitelisting for operators, and the module is implemented with Object::Pad so it requires Perl 5.38 or later. It is not an ORM so there are no object mappings or migrations, making it a good fit when you want direct SQL control but do not want to reimplement robust plumbing.

Cron::Toolkit is a thoroughly tested Perl library for parsing and evaluating Quartz-style cron expressions, including the optional seconds and year fields, while adding practical extensions like AND logic for day-of-month and day-of-week, wrapped day-of-week ranges, and a Monday-based internal DOW indexing. It performs all calculations in a configured time zone with correct DST semantics, can parse full crontab files with environment expansion, and provides next/previous occurrence queries, match checks, human-readable English descriptions, a dumpable abstract syntax tree for debugging, and JSON/normalized string output. The distribution includes over 400 focused tests that cover leap years, DST transitions and every supported time zone so you can rely on its results in edge cases. The latest maintenance release fixed a test-data issue that could emit conflicting timezone and utc_offset data and added regression cases to ensure step-expression behavior near hour boundaries remains correct.

PAGI::FastAPI::Security provides compact, reusable components for extracting authentication credentials in PAGI::FastAPI applications so you can declare route dependencies that pull out bearer tokens, HTTP Basic credentials, API keys (from header, query, or cookie), or OAuth2 password-bearer tokens without wiring that logic yourself. Each class knows how to produce the appropriate challenge or error response codes and headers so failed auth behaves consistently with HTTP conventions, but they intentionally stop short of validating credentials or verifying token signatures so you can plug in whatever JWT, crypto, or database checks your app requires. The modules support optional authentication flows via an auto_error toggle and include helpers for generating WWW-Authenticate challenges; recent updates added a configurable realm (default "Restricted") and improved WWW-Authenticate header generation for RFC-compliant behavior. Use this collection when you want standard, well-formed credential extraction and challenge handling integrated with PAGI::FastAPI while keeping verification logic in your application code.

Protocol::Tus is a framework-agnostic Perl implementation of the Tus resumable upload protocol that lets you handle client upload requests and assemble correct HTTP responses without tying your code to a specific web framework. You create a Protocol::Tus instance with a pluggable storage model (for example Protocol::Tus::LocalDir) and then feed incoming requests to the single entry point HTTP_request, or call the verb-specific helpers like HTTP_POST, HTTP_PATCH, HTTP_HEAD and HTTP_OPTIONS; each call accepts method, headers, id and body parameters and returns a Protocol::Tus::Response object. The module honors details of the Tus spec such as X-HTTP-Method-Override and offers hooks to generate the Location header and to run your callbacks on upload creation and completion so you can integrate custom behavior like logging or publishing upload URLs. It is designed to work with minimal framework code and includes a Mojolicious example, requires Perl 5.24 or newer, and is maintained on Codeberg where bugs and patches can be reported.

Variable::Magic lets you attach small custom callbacks to any Perl variable so you can watch or augment operations such as reads, writes, length queries, clearing, destruction and even per-key hash actions without writing XS code. You define a wizard that describes the callbacks and optional per-variable private data, then cast that wizard onto a variable and later getdata or dispell the magic as needed. Unlike tie it attaches to variables not values so magic is not copied on assignment, it does not replace Perl semantics but runs alongside them, it supports multiple independent magics on the same variable, and it works across scalars, arrays, hashes, coderefs and globs which makes it a lightweight and often faster way to implement tracers, defaults, lazy transforms or cleanup hooks. Note that some features such as hash uvar callbacks require a newer perl, free callbacks are not invoked during global destruction, and the module is an XS extension so it needs a C compiler to build. In the current 0.65 release a bug affecting hash delete callbacks in void context was fixed so delete uvar magic now fires reliably.

WebDyne is the core runtime and rendering engine for the WebDyne framework that turns ".psp" pages into complete HTML either inside a web runtime like Apache/mod_perl, PSGI, or PAGI or from standalone scripts and tooling. It exposes simple script-facing helpers (html and html_sr) for rendering templates with parameters or writing directly to a filehandle, and it integrates features useful for web apps such as embedded Perl in HTML, compile-time parsing and caching, templating, filters, CGI-style parameter access, and a request abstraction that unifies standalone, PSGI, and PAGI execution. The module is suitable both for running full WebDyne applications under a server and for offline generation, diagnostics, or test utilities via the bundled wdrender helper. Recent maintenance has focused on stability and testing, including normalizing boolean wrapper options so diagnostic dumps are consistent across environments and improving PAGI test diagnostics and wrapper test resilience.

Math::Histo is a high-performance Perl XS wrapper around the libhisto C library that brings production-grade histogramming and statistical tools to Perl programs. It provides fast, memory-safe 1D and 2D histograms with uniform or variable-width bins, weighted and bulk fills from Perl arrays or packed double buffers, and online moments so you can get mean, variance, quantiles, skewness, kurtosis and robust summaries without storing all samples. The module includes SIMD-accelerated ingestion for very high throughput, non-linear curve fitting, two-sample distance metrics and hypothesis tests, and convenient operations like rebinning, arithmetic, and zero-loss binary or JSON serialization for storage and transport. If you need efficient, scalable summary statistics, streaming quantiles or histogram-based fitting in Perl, Math::Histo is aimed squarely at that use case.

Alien::libhisto is a lightweight "Alien" wrapper that makes the C library libhisto available to Perl code by either locating a system installation via pkg-config or building and installing libhisto from source with CMake into Perl's shared distribution area. It is intended for Perl modules that need libhisto's histogramming, curve fitting, and streaming quantile sketch routines and works with both XS and FFI workflows, integrating easily into Makefile.PL via Alien::Base::Wrapper and into runtime code via FFI::Platypus->lib( Alien::libhisto->dynamic_libs ). The module removes the pain of managing the native dependency for Perl authors and is released under the MIT License; this initial CPAN release packages libhisto for Perl use.

Punk::OpenTelemetry provides OpenTelemetry instrumentation for the Punk web framework, giving you traces, metrics and correlated logs and exporting them to an OTLP collector over HTTP or gRPC. Add the plugin or set the OTEL_* environment variables and each incoming request becomes a server span named by the route pattern, outbound HTTP calls become client spans with trace context injected, and database queries are captured without leaking bound values. Telemetry is batched and sent asynchronously on the worker event loop so a downed collector does not block requests, and both protobuf and JSON OTLP encoders are supported for size or readability tradeoffs. The module also handles context propagation for W3C Trace Context, Baggage, B3 and Jaeger, offers configuration via punk.yml and environment variables, and includes an example app and collector for demonstration. You can disable the SDK completely by setting OTEL_SDK_DISABLED to true, making this a practical, production-oriented choice for adding standardized observability to Punk applications.

Open::API is a Perl toolkit for driving both sides of an HTTP API from a single OpenAPI 3.0 or 3.1 document. It loads and compiles the spec at startup into fast, C-backed validators so routing and parameter/schema checks run on a hot path, and it exposes that compiled core to a PSGI server adapter and to a spec-driven HTTP client so one document can produce a server, a client, mocks and docs. The module normalises 3.0 Schema Objects to 3.1 shape at load and expands OpenAPI discriminators so validation and mock generation pick the intended branch, and it offers direct match and validate_request methods for other frameworks, response checking and per-operation coverage counters, and a deterministic response synthesizer useful for predictable mocks. Open::API also publishes a C ABI for embedding the router and validator into native dispatchers and integrates features needed for real deployments such as security scheme enforcement, CSRF and CORS support when used with the Plack adapter. Recent notable work added acceptance of OpenAPI 3.0 documents by converting them to the 3.1/JSON Schema 2020-12 dialect at load so the rest of the toolchain can operate against a single, consistent schema form.

JSON::Schema::Fast is a high-performance JSON Schema (draft 2020-12) validator for Perl that compiles a schema once into a compact intermediate form and then validates live Perl data through a tight C interpreter, making repeated validations extremely fast. You create a compiled validator from a hashref, boolean schema, or JSON text and then call is_valid for a cheap boolean check or validate to collect detailed error hashes that include JSON Pointer locations, failing keywords, schema pointers, and human messages. It implements the full 2020-12 keyword set including references and remote documents, and it offers options to coerce common string representations into numbers or booleans and to apply declared defaults into the data before validation. Remote $ref resolution uses a pluggable resolver and by default will fetch documents via Fetch's C ABI, so you can supply your own resolver or disable remote lookups to avoid outbound requests. The distribution is fully conformant to the official test suite and exposes a small C ABI so XS authors can perform schema compilation and validation entirely in C for ultra-low-overhead use cases such as high-volume OpenAPI request validation.

MojoX::MojoDbWrap is a lightweight adapter that standardizes database access for Mojo::Pg, Mojo::SQLite and similar Mojo-style drivers so you can query, insert and retrieve record ids without worrying about driver-specific differences in how new row identifiers are returned. It provides direct access to the wrapped instance and its db handle and adds convenience methods such as select, id_of, id_or_insert, insert and upsert, plus a simple init hook to run migrations supplied via a migrations_for mapping. The module is extensible by supplying custom wrapper definitions for creating driver objects and for insertion logic, which makes it easy to integrate other database classes with minimal glue code. Note that upsert assumes a single conflicting column when generating conflict handling and the module requires Perl 5.24 or newer.

MojoX::Authentication is a batteries-included, moderately opinionated helper for adding authentication to Mojolicious web applications. It supports local authentication with in-memory hashes or an SQLite database and remote authentication via SAML 2.0, and it provides startup hooks to install and initialize the authentication plugin and to inject the current user into the stash for templates. The module supplies opinionated controller helpers for credential login, SAML initiation and single sign-on response handling, and logout, plus simple accessors for the backing model, provider name and the stash key for the user which defaults to "user". It assumes a single identity provider and is intended to get a working auth flow up quickly rather than act as a highly pluggable framework. Requires Perl 5.24 or later and includes an example application demonstrating the supported modes.

Lingua::TokiPona::Word is a lightweight Perl class for representing and working with words from the minimalist constructed language Toki Pona. It normalizes and deduplicates entries so each lexical form lives as a single in-memory object, supports construction from strings, other identifiers, ISE values or UCSUR code points, and offers simple operations to get the string form, Unicode code point, equality and ordering, and the list of all known words or stopwords. The module treats synonyms as distinct entries so you always get the exact word you asked for and exposes convenience no-op methods for registration and stemming because Toki Pona words are treated as stems by design. This is useful if you need a canonical, programmatic lexicon for parsing, comparison or small-scale NLP work with Toki Pona, but note the bundled vocabulary was not fully complete as of the referenced release.

SNMP::Info gives Perl programs an object oriented front end for querying and managing network devices via SNMP. It wraps the Net SNMP Perl bindings and exposes device neutral methods for common information such as interfaces, addresses, routes and layer two topology while including many vendor and device subclasses so it can auto detect and adapt to Cisco, Juniper, Arista and many others. The module caches table results for efficiency, supports SNMP v1, v2c and v3, handles bulk walks and 64 bit counters, and can perform set operations when you have read write access. It is easy to extend by adding small subclass mappings from MIB leaves to methods which makes it useful for inventory, discovery and automation tasks. Note that SNMP::Info depends on the Net SNMP Perl module from the net snmp distribution and on having the appropriate MIB files installed and available.

Punk::Queue is a durable, multi-process job queue for Perl with a C-based core that moves SQL, JSON and the claim state machine into XS for speed and minimal per-call overhead. You register named task handlers in your process and enqueue jobs into a database-backed queue (SQLite and PostgreSQL backends ship, and custom backends are supported), then worker processes atomically claim, run and record job results while the system handles retries with jittered backoff, timeouts, logging, priorities, dependencies, uniqueness and retention. The module also provides schema migration, job inspection and logs, worker and lock management, broadcast commands and a repair routine to recover crashed workers and stale state. It guarantees at-least-once delivery, so task bodies must be written idempotently to tolerate repeated runs.

App::PDFLibrarian is a command-line toolkit for managing collections of academic PDFs that carry embedded BibTeX metadata. It gives you utilities to import PDFs, edit and export their BibTeX entries, generate citation keys, replace or remove files, rebuild links between PDFs and metadata, and produce ISO4 journal abbreviations. Installation requires a few common system utilities such as Ghostscript and Poppler and the module is installed from CPAN. The tool is aimed at researchers who prefer a file-centric, metadata-aware workflow for papers and citations and is distributed under the GPLv3.

CallBackery is a Mojolicious application class that provides ready-made scaffolding for building appliance-style web frontends, wiring together configuration, a pluggable database backend, RPC service controller and namespace, documentation entry point, and security-related HTTP headers so you can focus on your application logic instead of boilerplate. It reads configuration by default from etc/callbackery.cfg or from the CALLBACKERY_CONF environment variable and expects a CallBackery::Database-compatible module for data access. CallBackery integrates with Mojolicious startup semantics so incoming web requests are routed to your application code and is useful when you want a quick, consistent way to expose REST or RPC services for appliance-style web interfaces.

Imager::File::PNG is the PNG read/write plugin for the Imager image toolkit in Perl, providing PNG support when you call Imager->read or ->write and also exposing low-level read/write methods useful for APNG or formats that encapsulate PNG such as ICO. It handles paletted images, transparency (tRNS), 1-bit and 16-bit per sample images, interlacing, metadata and configurable zlib compression and is designed to work across different libpng versions. The module has had many robustness and compatibility fixes over time and the recent 1.004 release addresses a serious bug that could cause a buffer overflow and image corruption when reading PNGs with tRNS transparency, resolving CVE-2026-73639.

Imager is a mature Perl image toolkit for creating, transforming and exporting full color images inside Perl programs. It lets you read and write common formats such as PNG, JPEG, GIF and TIFF, draw primitives and text, scale and crop, compose and alpha-blend images, apply filters and convolution effects, work with palettes and multiple bit depths, and build more complex affine or programmable transforms. The API is object oriented and simple to pick up for tasks like thumbnails, watermarks, text rendering or image pipelines while offering extension points for custom readers, writers and filter plugins and a C API for deeper integration. Error reporting follows a predictable errstr interface and the project is actively maintained on GitHub with a mailing list and bug tracker for support. If you need robust image manipulation from Perl without leaving the language, Imager is a solid option.

Data::Displaycolour is a Perl utility for choosing and working with display colours for arbitrary subjects such as usernames, email addresses, display names or any object you can identify. You create an instance with Data::Displaycolour->new and can either derive a colour from input text or an explicit colour value, pick a named palette or provide a custom list of hex colours, and control language preferences and fallback behavior. The API exposes methods to get the origin, abstract and specific colours, a single hex RGB output, and tools to enumerate palette colours or known colour names, and it can tag other userdata objects with a chosen colour via mark. The module is still somewhat experimental so palette contents and matching may evolve, but recent releases have focused on performance with significant speedups in v0.08 and the addition of object marking and palette registration features in earlier v0.06–v0.07 updates.

Params::Get supplies a single helper, get_params, that turns any of the common Perl calling styles into a single hash reference so your methods can accept hashrefs, named key/value pairs, a lone scalar under a default key, an arrayref shorthand for @_ passthrough, scalar refs (automatically dereferenced), blessed objects or code refs, or the frequent positional-plus-options pattern and always get a unified hash back. That lets library authors write one normalization line at the top of public methods and then run formal validation with tools like Params::Validate::Strict and produce validated returns with Return::Set. The function croaks on bad calling conventions and confesses with a full stack trace when a defined default is expected but no arguments were passed. There are a few documented caveats to know before adopting it: a single hashref always takes the fast path and will not be wrapped under a default key, a lone empty arrayref can be mistaken for an empty @_ passthrough, duplicate keys in flat lists silently overwrite earlier values, positional-name modes discard extra arguments, and you cannot mark a string default as optional. If you want simple, consistent argument handling across diverse Perl call sites, Params::Get is a compact, pragmatic solution.