CPANscan

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.

WebService::Fastly is a Perl client for the Fastly REST API that lets developers and operators automate and script almost anything you can do in the Fastly control panel, from creating services, domains, backends and logging endpoints to uploading Compute code, managing WAF rules, fetching historical and real‑time metrics, and handling account tasks like user administration and billing. The client is generated from Fastly's OpenAPI spec and aims to provide broad, up‑to‑date coverage of service and observability endpoints so it is useful for DevOps, SREs, and backend developers who want to integrate Fastly operations into deployments and tooling. Recent releases continue to expand features and telemetry support, most notably adding NGWAF workspace and account search, WAF simulation, new Compute and bot metrics, domain routing configuration and event mapping APIs, and a change in default logging_message_type for several logging endpoints along with new notification integration types such as Datadog, Jira, OpsGenie and Splunk On‑Call.

RT-Extension-ExcelFeed is a plugin for Request Tracker that makes it easy to export query results and scheduled dashboard reports as Microsoft Excel XLSX files. It adds an MS Excel option to the Query Builder feeds menu and a checkbox on dashboard subscriptions so scheduled reports can be mailed as Excel attachments instead of inline HTML. The extension supports RT 6.0 and older RT 5 installs can use the 0.* series, and installation simply requires enabling the plugin in RT_SiteConfig and clearing the Mason cache. There are a few useful configuration options such as hiding the chart download button and controlling progressive row paging to reduce memory use when generating large workbooks; the recent 1.03 release added a configurable rows-per-page setting and now defaults to 1000 rows per page. Recent updates also improve memory use by paging results, suppress user avatars when creating workbooks, and mitigate formula injection by formatting formula-like strings as plain text.

Reverse::Proxy is a lightweight PSGI reverse proxy for Perl that forwards incoming requests to HTTP backends using the Fetch client and can operate non-blocking on evented servers such as Hyperman. It supports sending every request to one upstream, routing by PATH_INFO prefix, or resolving the target dynamically per request with a callback. The module performs standard proxy header hygiene, appends X-Forwarded headers, reuses a keep-alive connection pool per worker and can stream response bodies to avoid buffering large or infinite streams. It also tunnels Upgrade and WebSocket connections when the server provides psgix.io, though those tunnels are blocking and occupy a worker for their duration. A notable recent change fixes a security issue by re-encoding control bytes in PATH_INFO to prevent request smuggling while still delivering the path the client requested. Configuration knobs include preserve_host, timeout, tls_verify, via and pool_size so you can tune behavior for your deployment.

Mojo::UserAgent::CookieJar::ChromeMacOS is a read-only cookie jar for Mojo::UserAgent that lets your Perl HTTP client reuse cookies stored by Google Chrome so scripts can mimic an existing browser session for tricky logins or captchas. It plugs into Mojo::UserAgent as a cookie_jar and reads Chrome's cookie SQLite file and decrypts entries as needed. Recent updates broaden compatibility with modern Chrome formats and platforms by supporting newer cookie DB versions (DB v24+ with SHA256 prefix), PKCS7 padding and AES decryption, Linux keyring handling, and HttpOnly cookie flags. Use this module when you want automatic access to your Chrome cookies from Perl without manual cookie export, keeping in mind it is intended for local, read-only use and is distributed under the same terms as Perl.

Test::Load::Helper automates the common test-helper pattern by walking up the directory tree from the calling test to find and evaluate a helper file so you do not need hardcoded relative require paths. By default it looks for test-helper.pl and evaluates it into the caller's package with strict and warnings enabled, but you can supply a different relative path or target package using the file and into import options. Helpers can chain to parent helpers to build layered fixtures and the module avoids re-evaluating the same file into the same package more than once, while allowing the same helper to be loaded into different namespaces independently. You can limit how far upward it searches by setting TEST_LOAD_ROOT to an absolute directory, and if no helper is found the module simply does nothing. A recent 2026 patch resolved a dependency cycle with Test::YAFT.

Table::Readable offers a very small, human-editable UTF-8 table format and a compact set of Perl routines to read, write and manipulate those tables as arrays of hash references, making it easy to store simple records in a text file that a person can edit by hand. Each row is a series of "key: value" lines separated by a blank line, multiline values are delimited with lines starting with %% and comments begin with #, keys with spaces are turned into underscores, and leading or trailing whitespace can be preserved with a backslash. The module provides read_table and write_table for loading and emitting tables, read_table_hash for building a lookup by a chosen key, and utilities such as append_table, replace and sort_file for editing files in place. The format intentionally forbids nesting and keeps only a handful of special characters so it stays easy to read and robust against accidental complexity. Recent releases introduced append_table and a noslash option to control backslash handling and the current 0.07 release now requires Perl 5.36.

Advanced::Config is a flexible Perl library that treats configuration files as real objects so you can load, inspect, merge and manipulate settings in memory with a consistent API. It supports loading from files or strings, resolving variables and includes, dividing settings into named sections, detecting and refreshing when source files change, and exporting values to the environment. The module provides typed accessors so you can fetch values as integers, numbers, booleans, dates, filenames or directories and it also offers list and hash views, validation, and convenience date helpers like hundred-year dates, day-of-week and day-of-year. For tighter security it can encrypt or decrypt marked values in files or strings and it converts configs to strings or hashes for integration with other tools. Recent work in the 1.15 release added rule-based config parsing to let you define vendor or file-specific parsing rules and extended get_dow_date to return localized day names, making it easier to handle varied file formats and multilingual date needs.

PDL::Transform::Color is a collection of composable color-space transforms for PDL that centers on a linearized sRGB (lsRGB) working space so you can correctly decode, manipulate, and re-encode images. It provides ready-made transforms for common tasks like sRGB and byte-RGB import/export, gamma encoding/decoding, HSV/HSL and CMYK conversion, CIE XYZ/xyY and CIELAB conversions, whitepoint and RGB-primary shifts, and a suite of pseudocolor maps for visualizing single-channel data. Because each routine returns a PDL::Transform you can compose, invert, and apply the operations to image PDLs for proper linear interpolation, blending, and color-correct processing. Options let you control gamma, clipping, output type, input domains, and map variants, and the module documents pragmatic limitations such as the simplified CMYK conversion that does not model ink gamut or press behavior. Recent maintenance has moved core calculations to PDL::Graphics::ColorSpace for improved speed and correctness and fixed issues such as a t_brgb divide-by-zero bug.

PDL::Opt::Simplex is a small Perl module that provides a derivative-free optimizer based on the Nelder-Mead simplex method for PDL piddles, letting you minimize functions by moving an N+1 point simplex through parameter space. You give it an initial vector or an initial simplex, a size or convergence tolerance, and a callback that evaluates your objective on PDL vectors, and it returns the best parameter vector, a simple size estimate and the objective value at that point. It is handy for quick parameter tuning and problems where derivatives are unavailable, and it includes a helper to build an initial simplex from a single point, but it is not reliable on functions with local minima so use population-based or annealing methods for multimodal searches. The code works with PDL broadcasting and the distribution was recently split out from core PDL and received documentation and licensing updates.