CPANscan

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.

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.

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.

CLI::Simple is a lightweight, object-oriented base class for writing Perl command-line tools that follow the modulino pattern so a single file can be used as both a reusable module and an executable script. It gives you familiar Getopt::Long-style option parsing, automatic getter/setter accessors, simple dispatch for subcommands and positional arguments, optional Log::Log4perl-based logging, and conveniences like bash-completion generation, pager-backed help output, and YAML-driven role composition for larger projects. The module is intentionally minimal rather than a full application framework so it is a good fit for internal tools, admin scripts, or projects that want an easy migration path from a monolithic script into role-based components using its built-in -dump-spec and -scaffold helpers. Recent 2.2.2 updates focus on polish and ergonomics, adding a set_args method, improving logging error messages and init behavior, and tightening validation for extra options.

Lucy is a Perl library that provides a fast, modular full-text search engine you can embed in applications to index and query large document collections. It handles creating and updating indexes, incremental and near-real-time updates, boolean and phrase queries, stemming, stoplists, relevance scoring and excerpt highlighting, and can be extended for distributed searching. You can get started quickly with the simplified Lucy::Simple interface or dive into its Schema, FieldType, Indexer, Searcher and Analyzer classes for fine-grained control. Lucy is designed for high throughput and can scale to millions of documents, and it is released under the Apache 2.0 license with community support via the project website and mailing lists. Note that the main Lucy namespace is an unstable 0.x development branch, it is not thread safe, and some exceptions have been reported to leak memory, so use the stable fork "Lucy1" if you need strong backward compatibility.

App::OpenHAP is an OpenBSD-focused HomeKit Accessory Protocol bridge that lets you expose local devices to Apple HomeKit. The distribution provides the openhapd daemon to serve configured accessories and the hapctl command-line tool to control it, with man pages and a sample configuration for operation. It also includes adapters for Tasmota devices and a full, sans-IO Protocol::HAP implementation covering pairing, SRP, HTTP framing, TLV encoding, characteristics, services and session crypto, so you can run a ready-made bridge or embed the protocol engine in other software. The project and development documentation are available on GitHub.

DBIx::Loop is a minimal, practical layer that lets event-driven Perl programs run DBI database work without stalling their event loop by turning queries and writes into futures that settle asynchronously. You supply your own event loop adapter and DBIx::Loop picks one of two execution modes automatically: a universal worker pool that runs blocking drivers in forked workers, or a native nonblocking path for drivers that expose a socket and async execute (currently DBD::Pg). Queries return simple result structures and the familiar DBI select helpers are available as async versions so most code needs only small changes. It also supports transactions pinned to a single connection, process-global observers for monitoring each statement, and a C ABI so XS modules can call into the same async engine with no Perl frame. Note the module is about keeping your loop responsive and isolating latency rather than making individual queries faster, you must provide a loop implementation, and SQLite users should be aware of writer contention with multiple worker processes and may prefer a single worker or longer busy timeouts for heavy writes.

Fetch is a high-performance, Future-based HTTP client for Perl that packs the socket, TLS, HTTP/1.1 and HTTP/2 hot path into C for speed while exposing a simple async API in Perl. It supports HTTP/1.1 and HTTP/2 (cleartext and TLS), keep-alive connection pooling, redirects, per-request timeouts, streaming bodies, cookie jars, JSON helpers and native WebSockets, and every request returns a Fetch::Future you can await with ->get which pumps either a provided event loop or Fetch's built-in standalone loop so the same code works for single synchronous calls and thousands of concurrent requests. It interoperates with IO::Async, AnyEvent and Hyperman or runs with no framework, provides clone for lightweight per-request isolation of headers and cookie jars without losing the connection pool, and even exposes a C ABI so other XS modules can drive requests with no per-request Perl round trip. Streaming consumers can use on_headers and on_body callbacks and there is an option to resolve responses as plain hashrefs for minimal overhead. The recent 0.13 release fixes a class of event-loop hangs by unifying the implicit loop behavior so agents that do not pass an explicit loop no longer interfere with each other and awaiting a loop with no watchers now dies with a diagnostic instead of blocking forever.

Fugu is a focused collection of Perl modules that supplies the common plumbing used by OpenBSD-style daemons, making it easier to build single-process, event-driven system services in Perl. The distribution breaks out functionality into small modules for daemonization, a simple event loop, logging, OpenBSD-style configuration parsing, control sockets and interprocess messaging (including a Protocol::Imsg sans-IO codec), JSON-over-UNIX-socket, PID files, privilege dropping, signal handling, child process management and helpers like an MQTT subscriber, a tiny HTTP proxy, SSH runner, mdnsd control, random utilities and a compact JSON state file. It needs only core Perl (v5.36) and loads optional CPAN features lazily so you avoid heavy dependencies unless you want them. If you are writing Perl daemons or tools that should follow OpenBSD conventions, Fugu supplies ready-made, well-scoped building blocks and its source and docs are on the project GitHub.

Mail::DWIM is a compact Perl helper for sending simple, casual email from scripts with minimal fuss: call mail(...) with the recipient, subject and text and the module fills sensible defaults and delivers via the local sendmail by default. It supports alternate transports including SMTP (with SASL auth and mandatory SSL when you supply credentials) and the traditional Unix mail program, lets you add attachments and send HTML with an automatic plain‑text fallback, and reads optional YAML configuration files in /etc/maildwim and ~/.maildwim so common settings need not be repeated. It offers a test mode that writes prepared messages to a file instead of sending them and flexible error handling that either dies or returns false with Mail::DWIM::error. Mail::DWIM is aimed at casual, low‑volume use rather than bulk mailing, and recent maintenance replaced File::MMagic with MIME::Types for more reliable attachment MIME detection.

App::FuguWeb is a small toolkit for turning a Perl project's existing documentation into a single static website by running standard renderers for mdoc, POD and Markdown and wrapping their output in a simple shared chrome. It uses a single .fuguwebrc at the project root to declare pages, navigation, manuals and where to copy assets so you do not need a separate build recipe, and the build produces a flat output directory with one stylesheet and no JavaScript or templating language. The distribution splits responsibilities into focused modules for configuration, page framing, rendering, manual discovery, indexing, site assembly and post-build checks, and it also exposes a few handy utilities for escaping HTML and attributes, listing directories and testing path containment. Run fuguweb build to produce the site and fuguweb check to validate it. This is useful if you want a minimal, dependency-light way to publish readable documentation for a Perl project directly from the docs you already maintain.

App::FuguVM provides a simple command line workflow to install and manage OpenBSD virtual machines under QEMU, performing unattended installs, keeping guest disks in a reusable cache, and driving common lifecycle tasks like booting, waiting for readiness, SSH access, snapshotting, and shutdown. Projects declare their VM setup in a single .fuguvmrc file at the project root and the fuguvm tool exposes subcommands such as up, wait, ssh, and down to operate the guests. The distribution is split into focused components that handle the CLI, configuration, disk images, console automation, QMP control, mirror policy, and state tracking, while the top-level App::FuguVM package itself contains no runtime code. This is a good fit if you need reproducible, scriptable OpenBSD VMs for development, testing, or CI workflows and want a tool that automates installation and lifecycle management.

Data::Checks provides a compact, efficient collection of reusable runtime value constraints for Perl that you can import into your code or use from other CPAN modules to enforce argument and field validation. It implements common checks like Defined, Str, Num and Object, parameterised checks such as Isa and Can, reference checks including ArrayRef and HashRef, Callable, string and numeric equality and range checks (StrEq, StrMatch, NumGT/GE/LE/LT, NumRange) and combinators Maybe, Any and All for composing complex rules. The distribution also exposes an XS API so implementors can build checker objects, generate assertion optrees and call check_value or assert_value from compiled extensions, which makes it easy to integrate these constraints into attribute-based signatures, object field validators or syntax extensions. Recent releases added the Can() constraint and improved compatibility with newer Perls, and since 0.09 constraint objects support a ->check method while plain CODE refs are deprecated. If you need straightforward, interoperable runtime validation or a foundation for adding checked attributes and assertion generation to other modules, Data::Checks is a practical choice.

This module is only a placeholder included so CPAN will index the distribution and does not provide runtime functionality or get installed on a user system in normal circumstances. It is essentially a packaging shim and can be ignored unless you are maintaining or publishing the distribution itself. The distribution around it is actively maintained and recent notable changes include improved handling of category-prefixed package names versus working-tree paths in version 1.9.0 and added working-tree package support with a -W option in 1.8.0.

Avro is the official Perl interface to Apache Avro, a compact, fast binary data serialization and RPC system, and this module lets Perl programs define Avro schemas, validate data, and read and write Avro binary data and object container files for interoperability with other Avro implementations. It handles encoding and decoding of Avro types, reports encoding errors via dedicated exceptions, and supports the common codecs and boolean, integer and binary encoding behaviors expected by the Avro spec. Recent maintenance updates include switching to JSON::MaybeXS to allow multiple JSON backends, removing an unnecessary IO::String dependency, defaulting unspecified object container codecs to "null", and fixing several corner cases around numeric ranges, boolean parsing and Unicode handling when encoding byte and fixed fields. The module is maintained by the Apache Avro project and is available under the Apache License 2.0.

Data::IconText is a small Perl utility for producing and managing single-character "icon text" such as Unicode code points or single-character ASCII icons. You can create an icon from a numeric Unicode value like 0x1F981, from a raw one-character string, from a file or media object, from a mimetype or media type, or from a two-letter country flag code, and the module will pick a suitable character according to built-in rules. It builds on Data::Identifier and can attach supporting objects for lookups so it integrates with file, tag, URI and identifier objects and can return either the numeric code point or the Perl string. The API also proxies Data::Identifier style conversions and tests via as and ise, offers an experimental mark method to assign icons to identifier-like objects, supports versioned lookup rules and an option to suppress defaults, and exposes a registry of known mappings. This is useful when you need compact, consistent single-character icons for UIs, file lists, metadata displays, or any system that wants a portable text icon.

App::Netdisco is the upstream package for Netdisco, an open source, web-based network management tool that collects SNMP data into PostgreSQL and gives network teams an easy way to find devices by MAC or IP, see the switch port they are on, change port properties like VLAN or PoE, and build searchable inventory and topology maps. It runs a web frontend and backend daemon, ships a DBIx::Class database API for integrations, and supports plugins so you can extend or automate actions from the web or command line. Deployment can be self-contained under a dedicated user or via containers and requires Perl and PostgreSQL along with standard SNMP and OS libraries. The project is well documented, actively maintained by a community with demos and install guides, and is a good fit if you manage switches, campus or datacenter networks and need automated discovery, port control, and inventory.

PlackX::Framework is a compact, opinionated framework for building PSGI/Plack web applications in Perl that focuses on a small footprint and fast startup. It supplies a simple app() entry point and automatically loads or generates the common pieces you need under your application namespace, such as Handler, Request, Response and Router, while offering a minimal DSL for defining routes and before/after filters. Request and Response extend Plack::Request and Plack::Response with conveniences like a per-request stash, a one-cycle flash cookie, rerouting and easier streaming, and optional submodules provide Template Toolkit integration and enhanced URI handling if you want them. You can also inject middleware by defining an apply_middleware hook and choose any model or database layer since the framework is ORM agnostic. The project is intentionally lightweight compared with larger frameworks and claims faster load times and lower memory usage, but it is currently experimental and described by the author as alpha.