CPANscan

WWW::Garden::Design is a Perl toolkit for creating, publishing and searching a flower database and garden layouts. It ingests CSV files to bootstrap an SQLite-backed flower database, provides import and export scripts to generate a clickable HTML catalog and individual flower pages with names, aliases, images and notes, and produces SVG garden-layout files. A Mojolicious-based search engine with included command scripts lets you run a web UI and serve it with hypnotoad. The distribution bundles command-line tools to regenerate CSVs and thumbnails and is installable via cpanm or the usual Makefile.PL process. The project is open source on GitHub and recent updates removed uses of warnings.FATAL and moved tile generation into the database component so tiles are available online.

Poker::Eval is a Perl rules engine for dealing, scoring, and evaluating poker hands. It powers a family of Poker::Game::* modules for popular variants such as Hold'em, Omaha, draw, stud and Badugi, and it also lets you compose your own evaluator by pairing the engine with a Poker::Score implementation to define high or low ranking systems. The module exposes a Dealer-backed deck with optional joker support, utilities to compute the best hand for given hole and community cards, and a Monte Carlo equity calculator that estimates expected win rates across players with configurable simulation counts. Recent releases added a rich named-game API covering many variants and improved equity handling so ties split fairly and simulations use the residual deck, and a follow-up update restored version metadata for CPAN indexing. Pick Poker::Eval when you need to simulate outcomes, compute hand rankings, or build game-specific poker logic in Perl.

Hyperman is a high-performance PSGI server for running Perl web apps that pairs a prefork supervisor with a per-worker, XS/C event loop to deliver low-latency, high-throughput serving and native async support. It runs any Plack app, lets handlers return Hyperman::Future objects to await asynchronous work without blocking, and exposes timers and io-ready primitives for in-app scheduling. Production features include graceful worker respawn and zero-downtime reloads, multiple listeners (plain and TLS) with SNI and optional client-cert verification, HTTP/2 support, a fast C implemented access log, and a shared forked arena for denylists and fixed-window rate limiting enforced at accept. The module also offers a C ABI so other XS extensions can use its loop and futures directly, and an explicit detach facility for handing live HTTP/1 sockets to an application for protocol upgrades. Recent releases notably added tls_reload to swap certificates per worker and, in the latest update, an attempt to build and serve on native Windows with a WSAPoll backend while keeping existing platform behavior unchanged.

GraphQL::Houtou is an XS-first GraphQL parser and runtime for Perl that compiles schemas and queries into a native VM to deliver very high throughput. It lets you build executable schemas from SDL or Perl type objects, serve GraphQL over PSGI, return UTF-8 JSON bytes directly from the native lane to avoid constructing Perl response trees, and use persisted compiled bundles or cached programs for minimal per-request overhead. The toolkit includes a bundled DataLoader and an on_stall-driven batching model to collapse N+1 SQL patterns, supports Promise::XS-based async execution when declared, and keeps resolvers as normal Perl coderefs while offering faster resolver ABIs and zero-argument accessors to reduce call overhead. Note that subscription streaming and some web transport features are not supported in the initial profile, only Promise::XS promises are recognized, native bundles cannot accept GraphQL variables, and Perl ithreads are not supported. The recent 0.06 release adds declarative DataLoader field support with native executor integration and an executor-owned batch plan to optimize cacheless loader paths.

MCE (Many-Core Engine) is a Perl toolkit for running work in parallel across multiple CPU cores by maintaining a pool of workers that pull chunks of input rather than forking per item, which makes it efficient for processing large files, long sequences, or other data-parallel tasks. It offers higher-level "models" such as Flow, Loop, Map, Grep, Step and Stream so you can express common parallel patterns with minimal boilerplate, and it includes supporting components for interprocess/thread communication, queuing, mutexes, ordered output, and a child-like async API so you can pick the right level of control for your problem. MCE is cross-platform with many Windows and Cygwin fixes, works with threads or forked processes, and supports Perl 5.8 and later, making it useful for speeding up I/O-heavy and CPU-bound Perl scripts while preserving familiar idioms like map and grep. Recent maintenance work added support for Iterator classes and introduced a dedicated MCE::Core package to improve the core API and future development, plus smaller fixes to model import behavior.

Module::CoreList is a reference library and command line tool that tells you which modules and module versions shipped with each Perl release, so you can quickly answer questions like when a module first became part of core, whether a specific module version is bundled with a given Perl, or which modules were added, changed, deprecated or removed between releases. It offers a simple programmatic API (examples include first_release, first_release_by_date, is_core, find_modules, find_version, removed_from, deprecated_in and changes_between) and exposes ready-made data hashes such as %Module::CoreList::version, %delta, %released and %families for direct inspection. The package is maintained by the Perl 5 Porters, includes the corelist utility for quick command-line queries, and is actively updated to track new Perl releases, most recently refreshed for Perl v5.45.2.

CPAN::Perl::Releases is a lightweight data module that maps every Perl release uploaded to CPAN to the actual authors/id path where its tarball lives, so scripts and tools can look up where to download perl-5.x tar.gz, tar.bz2 or tar.xz files without crawling CPAN. It exposes a simple perl_tarballs function that returns a hashref of available tarball formats and their relative CPAN paths, plus perl_versions to enumerate supported release versions and perl_pumpkins to list PAUSE IDs of the Perl maintainers. The information is static data packaged with the module but is regularly updated as new Perl releases appear on CPAN, and the distribution is kept current with recent releases including updates for v5.45.2.

Filename::KeyValue extracts structured metadata from filenames that use a trailing key=value naming scheme by parsing the prefix, file extension and key/value pairs that are separated by dashes. It understands multiple keys, comma-separated multi-values, and percent-encoded characters and returns an enveloped result containing an HTTP-like status code, a message, the parsed payload and optional metadata. The main routine parse_keyvalue_filename accepts options to control whether values are returned as arrays or as joined strings and whether to URI-decode values. This module is handy when you organize media or other assets by encoding attributes into filenames and need a reliable, exportable helper to read or normalize that information for indexing, routing or processing.

Sys::OsRelease::Lite is a lightweight Perl helper for reading the freedesktop.org /etc/os-release file and exposing the system identity and metadata through a simple singleton API. It gives you ready-made, read-only accessors for common fields such as ID, NAME, VERSION and ID_LIKE and can be used either as a class or an object, while keeping dependencies minimal so it works well in containers and on minimal system installs. The module searches the standard locations for an os-release file and falls back to Perl's Config osname when none is found, and it lets you adjust the search path or recognized common platform names for ID_LIKE handling. Sys::OsRelease::Lite is the compatibility packaging of Sys::OsRelease for older Perl versions, and recent updates improved attribute coverage and tests, including adding and documenting the FANCY_NAME attribute and tightening packaging and manifest details.

Sys::OsRelease reads the standard /etc/os-release file and makes the operating system identity and metadata easily available to Perl programs, so scripts and installers can detect distribution, version, and related fields without bespoke parsing. It exposes a simple singleton API with auto-generated accessors for standard attributes like id, id_like, pretty_name and version, and provides utility methods such as platform to normalize IDs, osrelease_path to report where the file was found, found_attrs, get and has_attr for nonstandard data, plus a small config accessor. The module intentionally keeps minimal prerequisites so it is suitable for containers and bootstrapping environments, and for older Perls the identical Sys::OsRelease::Lite build is provided. Recent updates improved packaging and tests, fixed a missing FANCY_NAME doc entry, and cleaned up the Lite packaging and manifest.

MIDI::RtController is a small Perl framework for building real time MIDI controllers by attaching plug in filters to incoming MIDI messages. It opens MIDI inputs and an output and dispatches events to user supplied callback filters that can transform, duplicate, delay, or drop messages before sending them on. Filters can target specific event types like note_on or note_off or apply to all events. You can schedule delayed sends and share the same async event loop and output across multiple input devices. It is useful for live performance scripting, custom mappings, arpeggiators, drum remapping, and other controller customizations and it integrates with IO::Async and MIDI::RtMidi::FFI. Example filter modules and sample scripts are included to help you get started.

OpenTelemetry provides a Perl implementation of the OpenTelemetry API and a single entrypoint to access global tracing, logging, context and propagation components so you can instrument Perl code to produce observability data. It exposes class methods and optional imported functions with an otel_ prefix to get or set the global tracer_provider, logger_provider, propagator and error handler, with sensible defaults that are no-op or non-recording so instrumentation is safe by default. The module includes convenience helpers for working with contexts and spans and uses lvalue accessors so providers can be reassigned globally when you want to plug in an SDK or exporter, while recommending localization techniques for per-thread or per-request overrides. If you want those generated traces and logs to be exported or processed you should pair this API with OpenTelemetry::SDK, and the package integrates with Log::Any for its default error reporting.

Gnuplot::Builder is a lightweight, object-oriented Perl helper for building gnuplot scripts and driving gnuplot processes from your code. It models scripts and datasets as Script and Dataset objects so you avoid global gnuplot state, and it provides convenient exported helpers such as gscript, gfile, gfunc and gwait for quick interactive use. The module deliberately keeps a thin layer over gnuplot by streaming plain script text to the gnuplot process, which makes behavior predictable and easy to debug, and it supports prototype-style inheritance for hierarchical configuration and a one-process-per-plot policy so you can run plots in parallel. It works well in both batch scripts and interactive REPLs, but plot windows can be platform dependent so Windows users may prefer Gnuplot::Builder::Wgnuplot and you should be prepared to inspect the generated script if gnuplot reports errors.

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.

Punk::OAuth2 provides client-side OAuth2 and OpenID Connect support for Punk web applications, letting you add "Log in with" flows for Google, GitHub, or any OIDC provider. It implements the authorization code flow with PKCE, signed state parameters, and id_token verification via Crypt::JWS so authentication is secure and tokens are validated. The real behavior and helpers are exposed through Punk::Plugin::OAuth2, while this distribution module serves as the version anchor and documentation entry point. Use it to plug OAuth2 login endpoints into a Punk app and configure providers with client id, secret, scopes, and callback settings.