CPANscan

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.

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.

App::Test::Generator is a toolkit for automatically adding robust black‑box tests to Perl modules by turning formal input/output schemas or extracted signatures into runnable Test::Most test harnesses. You give it a YAML or inferred schema describing parameter types, constraints and transforms and it emits fuzzing cases, deterministic boundary tests, optional static corpora and property‑based checks using Test::LectroTest, with support for semantic generators like email, UUID and timestamps, reproducible runs via seeded RNG, and corpus minimization to keep inputs small. It also integrates mutation testing and LCSAJ path metrics to drive a feedback loop that can generate mutant-driven schemas and TODO stubs, produces a Mutant/Coverage/CPAN Testers dashboard, and supplies command line helpers to extract schemas, generate benchmarks, test POD examples and deploy GitHub workflow files. If you maintain CPAN modules and want automated stress, boundary and property testing plus mutation‑guided test discovery and a web dashboard for results, this module is directly relevant. Recent releases have beefed up the dashboard UI with per‑file duplication (CPD) drilldowns, sortable and drag‑reorderable tables and persistent table state, plus numerous fixes to schema extraction, corpus minimization and mutation handling.

PDL::DSP::Fir is a small Perl/PDL helper for building one dimensional finite impulse response filter kernels that you can convolve with your data to implement lowpass, highpass, bandpass, and bandstop filters, or simply use window shapes directly. Its main routine firwin returns a windowed-sinc kernel given the number of taps and cutoff frequencies expressed as fractions of the Nyquist rate and accepts the same window options used by PDL::DSP::Windows, and a simple filtering front end is provided in PDL::DSP::Fir::Simple. The module also offers utility routines such as ir_sinc to generate an N-point sinc lowpass response and spectral_inverse and spectral_reverse to produce kernels whose spectra are the inverse or mirror of an existing kernel. If you work in Perl with PDL and need to prototype or apply classic FIR designs quickly, this module gives a compact, interoperable toolkit for creating practical filter kernels.

PDL::Filter provides a compact set of linear filtering tools for the Perl Data Language so you can apply convolution-style filters, smoothing and simple predictive filters directly to PDL arrays. It splits into PDL::Filter::Linear for standard linear-filter operations on multi dimensional data and PDL::Filter::LinPred for linear prediction tasks such as basic forecasting or autoregressive-style modeling. If you work with numerical arrays in Perl and need efficient, built-in routines for denoising, smoothing or simple prediction, this module gives a straightforward, PDL-native solution.

PAGI::FastAPI::Queue::Driver::Redis is a Redis-backed storage plugin for PAGI::FastAPI::Queue that keeps queues shared across processes and hosts by storing each topic as a Redis list (RPUSH to enqueue, LPOP to dequeue). It JSON::PP-serialises payloads so Perl scalars, arrayrefs and hashrefs that are JSON-representable survive round trips, and it can either create an Async::Redis client for you or accept a pre-built client if you need TLS, auth or want to share a connection. The driver is built on Async::Redis to match PAGI::FastAPI’s Future::IO-focused approach and connects lazily on first use to avoid work in constructors. Asking for an aggregate size without a topic walks the keyspace with non-blocking SCAN and sums LLEN per matching key, so totals are a best-effort snapshot rather than atomic, and a driver-specific disconnect method is provided for clean shutdowns. This initial release focuses on correctness, testability and compatibility with PAGI::FastAPI’s event-loop philosophy.

PAGI::FastAPI is a FastAPI-inspired micro-framework for modern Perl (5.38+) that brings non-blocking async routing, Type::Tiny request validation, dependency injection and automatic OpenAPI 3.1 plus a hosted Swagger UI to Perl web apps. It lets you write async handlers with Future::AsyncAwait, mount sub-apps, add middleware, serve WebSocket endpoints, stream Server-Sent Events, and handle CORS, CSRF, rate limiting and cryptographic proof-of-work bot protection with built-in helpers and pluggable drivers. Authentication is left to middleware or per-route dependencies and a companion PAGI::FastAPI::Security distribution supplies common extraction schemes while letting you perform verification with your own logic. The framework compiles to a PAGI-compliant async app for servers and tests and recommends using Future::IO for loop-agnostic timers while documenting how to bridge Mojo-style loops when necessary. Notable in the 1.1.0 release is PAGI::FastAPI::Queue, an async-first message queue facade with a pluggable driver API and a built-in in-memory driver for simple topic-based push, pop and size operations.

EV::YACurl is an asynchronous HTTP client that binds libcurl's "multi" interface into the EV event loop so you can drive many concurrent transfers alongside other EV-driven work. It manages libcurl sockets and timers directly via EV's C API from XS, avoiding per-socket Perl callbacks and keeping per-request callbacks fast and synchronous with EV watchers. The module exposes the full set of CURLOPT_/CURLINFO_* options translated to Perl-friendly values, gives you per-request read/write/header/debug hooks and a Response object for post-request info, and it reuses a connection pool to enable keep-alive and HTTP/2 multiplexing. You must use libcurl 7.64.0 or newer built with AsynchDNS to avoid blocking DNS lookups, and clients and responses belong to the creating interpreter so they do not survive threads or forks. This first release is a fork of AnyEvent::YACurl that replaces AnyEvent watcher creation with ev_io and ev_timer watchers built from XS, adds client priority controls via priority() and default_priority(), and builds against Alien::curl.

Amazon::S3::Lite is a compact Perl client that implements the common S3 operations you need in lightweight scripts and AWS Lambda functions, including listing buckets and objects, reading and streaming objects to disk, uploading and copying objects, deleting, bucket creation and deletion, website and policy management, and configuring Lambda or SQS notifications. It deliberately keeps dependencies minimal by using HTTP::Tiny and Amazon::Signature4::Lite so it loads fast in Lambda and supports credential discovery from environment variables or IAM roles, streaming large bodies to files, and automatic pagination helpers that return convenient parsed hashrefs. This module is not a full replacement for Amazon::S3 or Net::Amazon::S3 if you require advanced features like multipart upload, presigned URLs, ACLs, or raw HTTP responses, but it is an efficient, easy-to-use choice when you only need the most common S3 tasks.

MooX::PDL::Role::Proxy is a Moo role that lets an object containing PDL ndarrays act like a single ndarray by forwarding common PDL operations to a group of attributes you mark with the ndarray (or legacy piddle) tag. Instead of applying masks, slices or sorts to each array field manually you can call methods such as where, index, slice, qsort, clip_on, copy and sever on the object and have the operation applied across the tagged attributes either in-place or on a cloned object, with APIs to control how in-place updates and cloning are performed and hooks for classes that need custom clone behavior. It supports nested proxy objects and offers both accessor-based and direct in-place update modes, but it expects the grouped ndarrays to be structurally compatible and the host class to provide writable accessors for in-place work and a clone method for non-inplace operations. Recent updates fixed a bug that could list an attribute twice when it was tagged as both piddle and ndarray and formally introduced the new ndarray terminology while remaining backward compatible with piddle.

CPAN::Maker::Bootstrapper is a command line tool that scaffolds a complete, ready-to-build Perl CPAN distribution so you can go from new module name to a distributable tarball with a single make. It installs a managed Makefile and .includes build system, generates a .pm.in or .pl.in stub and test skeleton, wires in dependency scanning and a hermetic local library for reliable syntax checks, and provides built-in quality gates like perl -wc, perltidy, and perlcritic that you can turn off during rapid development. You can import existing projects or choose CLI or custom stubs, add modulino wrappers and CI builder scripts, and extend the project safely via an always-writable project.mk while keeping the managed files upgrade-safe. It also bundles AI-assisted tooling that integrates with Anthropic Claude to run structured code and POD reviews, generate release notes, and support an iterative annotate-and-resubmit review workflow with prompt profiles and cost controls. Be aware that imported files become .in sources and generated .pm/.pl files are read-only so you must edit the .in files, and import and stub modes are mutually exclusive, but overall this tool is ideal for Perl developers who want a reproducible, portable, and opinionated build system without relying on external CI services.

CPAN::Maker is a command-line tool that packages Perl modules into CPAN-ready tarballs from a declarative YAML buildspec. It stages your library, scripts, tests and extra files, generates a Makefile.PL, resolves and embeds dependencies, runs the standard perl Makefile.PL and make dist workflow and can optionally run tests before producing a distributable tarball. The tool also provides commands to validate buildspecs against a JSON Schema for CI use, to emit a cpanfile from dependency lists, and to print the generated Makefile.PL for inspection. The buildspec lets you declare author, abstract, license, module paths, dependency categories, minimum Perl version and where outputs are written, and the implementation is pure Perl so no external shell scripts are required. Note that including a directory in the extra-files section will package every file in that directory, so it is usually safer to list files explicitly.