CPANscan

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.

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.

PDL::IO::IDL is a Perl module for reading IDL .sav files into the Perl Data Language so you can access IDL data from Perl. It handles scalar and array numeric types (BYTE, SHORT, LONG, FLOAT, DOUBLE), strings, structures and common blocks and returns a hash reference keyed by the original IDL variable names which are converted to upper case. Numeric arrays come back as PDL objects, strings and string arrays as Perl list references, and structures as Perl hashes with named structure types recorded in the file metadata. Arrays are byte-swapped as needed and preserve IDL indexing order. The module is read only, so writing is not implemented, and complex numbers, pointer types, compiled code and IDL objects are not supported. This code is independent of the makers of IDL and is provided without warranty, making it a practical choice when you need to extract numeric and structured data from IDL save files into Perl.

PDL::IO::HDF is a Perl Data Language adapter for the HDF4 library that lets Perl/PDL programs open, read, write and inspect HDF4 files through the SD, VS and V interfaces so you can move datasets, attributes and fields directly into PDL piddles for numeric and image processing. It exposes the common HDF access modes and data-type constants and supports HDF chunking and compression (configurable via a Chunking() member) so large scientific arrays can be stored and retrieved efficiently. If you work with legacy HDF4 scientific data and want to manipulate it from Perl using PDL, this module provides a thin, convenient bridge. Recent maintenance has split the module out of the main PDL distribution and improved packaging, licensing and documentation to make installation and upkeep easier.

PDL::IO::ENVI is a small Perl Data Language helper that reads ENVI-format raster images into PDL ndarrays. It offers readenvi to load image data and optionally return the parsed header as a hashref, and readenvi_hdr to parse a standalone .hdr file. The routine looks for a header file next to the data file and will try a filename suffix change if needed. It currently handles raw binary ENVI files only and returns header fields as a hashref but does not yet validate all required fields or fully parse geolocation and some sensor keywords. The author notes planned enhancements such as write support and additional data-type handling, so use this module when you need a straightforward way to import ENVI imagery into PDL for analysis.

PDL::Graphics::Limits computes tidy axis limits for plotting PDL data sets so you do not have to pick bounds by hand. It accepts one or more data sets given as scalars, ndarrays, arrayrefs or hashrefs and understands symmetric and asymmetric error bars. You can apply transformations either globally or per vector so ranges end up correct for log or other scaled plots. The module offers several bounding and cleaning modes including raw MinMax, a Zscale option for 2D data, and cleaning schemes like a fractional padding default or a round-to-1-2-5 power-of-ten option. You can also supply explicit limits or use VecKeys to map hash columns, and KeyCroak lets you suppress missing-key errors. Results come back as a flat list of min/max pairs or as a hashref of axis names, making this handy for preparing data for plotting routines.

PDL::IO::Dicom is a small extension for the Perl Data Language that lets you read 16-bit grayscale DICOM medical images into PDL data structures for analysis and processing. It exposes a simple rdcm("file.dcm") call that returns a PDL image ready for manipulation with the rest of the PDL toolset. Because the DICOM standard covers many variations, this module focuses on common 16-bit gray formats and cannot handle every DICOM variant. For example the Papyrus format is not supported, so use this module when you need straightforward importing of standard DICOM images into Perl for numerical work.

PDL::Graphics::Simple is a lightweight, backend‑independent plotting layer for the Perl Data Language that makes it easy to draw common 2D plots and display images without learning each engine's API. You can use quick global functions like imag, line, and points for immediate on‑screen results or create a PDL::Graphics::Simple window object to control size, multi‑panel layouts, and file output. The module translates a small, consistent set of plot and curve options into calls to available backends such as Gnuplot, PGPLOT, PLplot, or Prima so the plot you request is produced regardless of which engine you have installed. Supported plot types include lines, points, bins, error bars, circles and images and newer versions also add contours, FITS image display, and polylines, while legend support remains experimental and only 2D plotting is supported. File plots may not be finalized until the plot object is destroyed and environment variables such as PDL_SIMPLE_ENGINE, PDL_SIMPLE_DEVICE, and PDL_SIMPLE_OUTPUT let you control backend selection and output behavior. If you want a simple, portable way to get publication‑quality or quick exploratory plots from PDL without learning each backend, this module is a convenient choice.

PDL::Graphics::Gnuplot lets you plot PDL ndarrays by driving the external Gnuplot program from Perl, so you can produce interactive windows, publication-quality files, 2D and 3D plots, and image displays without learning Gnuplot syntax. It provides a simple functional interface (gplot) and a persistent object interface (gpwin/new) so you can set global plot options, replot, or build complex multiplot layouts from Perl. You pass data as PDLs or array refs and select familiar plot styles such as lines, points, errorbars, histograms, rgb/rgbalpha images, pm3d surfaces and many others, with support for threaded curves, palette and perceptual color maps, FITS WCS-aware images with resampling, and interactive input like read_mouse and read_polygon. Output targets are any Gnuplot terminal, so you can display on screen, write PDFs or PNGs, and control terminal-specific options from Perl. Most Gnuplot features are exposed through plot and curve option hashes and advanced users can inject raw Gnuplot commands when needed. The authors note a few remaining rough edges around complex label parsing and some newer plot styles, but overall the module gives a powerful, well integrated bridge between PDL data and Gnuplot rendering.

Mojo::ATProto::OAuth is a Perl client that implements the ATproto/Bluesky style OAuth flow so you can add PAR, DPoP sender-constrained requests, authorization-code exchange, token refresh, and scoped upgrades to your app. It provides high level helpers for starting login, handling callbacks, refreshing tokens, and requesting extra scopes, and it works both asynchronously inside Mojolicious with Promise-returning "_p" methods and synchronously in standalone scripts. The module is framework-decoupled and deals in plain hashrefs, supports confidential clients via an ECC private key or a loopback localhost mode for local testing, and persists auth requests and sessions through a pluggable store with built-in Memory, SQLite, and Pg drivers. It uses Mojo::UserAgent for HTTP, Mojo::Promise for async, logs debug output under MOJO_LOG_LEVEL plus MOJO_OAUTH_DEBUG, and signals errors by dying in sync calls or rejecting promises in async calls. If you need to integrate Bluesky/ATproto authentication into a Perl application this module provides a complete, production-oriented implementation.

LedgerSMB::Installer is the automated installer for LedgerSMB, the open source Perl-based accounting web application, designed to set up the application and its runtime environment for you. It automates installation of required Perl modules and system packages, configures local::lib where needed, generates a server-start script, and can verify GPG signatures to ensure downloaded artifacts are authentic. The installer integrates with CPAN and MetaCPAN to resolve dependency trees and now includes robust handling for Red Hat Enterprise Linux and derivatives as well as Fedora and Debian families, with improved executable resolution so bundled tools are found before system ones. If you are deploying or upgrading LedgerSMB on a Linux server and want a repeatable, dependency-aware installation process, this module is directly relevant.

PDL::Fit is a compact collection of curve‑fitting tools for the Perl Data Language that provide ready-made routines for common fitting tasks, including Gaussian fitting, Levenberg‑Marquardt non‑linear optimization, linear least squares and polynomial fits via the PDL::Fit::Gaussian, PDL::Fit::LM, PDL::Fit::Linfit and PDL::Fit::Polynomial modules. It is intended for people working with numeric arrays in Perl who need straightforward, array-oriented fitting utilities that return fitted parameters and basic diagnostics without requiring you to reimplement common solvers yourself. The distribution was split out from the main PDL release in late 2024 and recent updates have clarified return values for the 1D Gaussian fit routines, added license information and improved installation packaging and documentation to ease use and distribution.

PDL::LinearAlgebra is a PDL extension that brings a broad, LAPACK-backed suite of matrix tools into Perl Data Language so you can compute SVDs, eigen- and generalized-eigen problems, Schur forms, QR/LQ/QL/RQ factorizations, LU/Cholesky decompositions, inverses and pseudo‑inverses, determinants, norms, ranks, condition numbers and many related solvers and utilities from within PDL arrays. Most routines are thin wrappers around LAPACK/BLAS so they integrate with PDL’s broadcasting and inplace conventions and handle real and native-complex data, though some operations transpose data under the hood to match Fortran column-major layout. If you need the absolute lowest-level performance you can call PDL::LinearAlgebra::Real or ::Complex directly, but for most users this module provides convenient, high-level access to industrial-strength linear algebra. Recent maintenance fixes (Aug 2026) corrected the pseudo-inverse and null-space routines to use conjugate-transpose, improved support for non-square inputs and broadcasting, and fixed some SVD and rank edge cases so numerical behavior is more robust.

PDL::FFTW3 gives PDL users direct access to the FFTW3 library so you can compute fast multi dimensional Fourier transforms on Perl Data Language ndarrays. It supports complex-to-complex and real-to-complex forward transforms and their inverses with named functions like fftN, ifftN, rfftN and irfftN or the generic fftn/rfftn forms, and it understands PDL broadcasting so you can transform batches of arrays at once. Complex transforms may be done in-place while real transforms require separate output arrays and the real-to-complex layout uses the reduced-spectrum convention where the first dimension becomes int(N/2)+1, so inverse transforms can be ambiguous for odd lengths unless you supply the desired output buffer. The module uses native complex types (cfloat, cdouble) and preserves single or double precision when possible, and it normalizes only the inverse transform to match common analysis conventions. You must install the FFTW3 library separately before installing this module, and it is a solid choice if you need high performance FFTs within the PDL ecosystem.

PDL is the Perl Data Language, a mature toolkit that brings fast, MATLAB- and IDL-like numeric power to Perl by providing memory-efficient, N-dimensional arrays and fully vectorized arithmetic and indexing so you can manipulate large images, spectra and other bulk numeric data without writing loops. It includes a broad core of modules for math, linear algebra, special functions, IO (FITS, common image formats, Storable), and device-independent graphics, an interactive shell (perldl) and convenience variants like PDL::Lite for faster startup and PDL::NiceSlice for nicer indexing syntax. PDL supports most native C numeric types including native complex numbers and 64-bit indexing where available, it offers broadcasting, inplace operations and dataflow features, and it is actively maintained with frequent fixes and enhancements. The recent 2.105 release added a few math utilities and constants, improved bad-value handling and documentation hooks, and fixed some IO quirks, so PDL remains a solid choice if you need high-performance numerical array processing from Perl.

Socket is a low‑level Perl module that supplies the constants and small helper routines you need to build and manipulate network sockets and socket addresses; it gives protocol and address family names like AF_INET and PF_INET, socket types and option names such as SOCK_STREAM and SO_RCVBUF, message flags and IPv4/IPv6/TCP option constants, and routines to pack and unpack sockaddr structures, convert textual and binary addresses (inet_pton/inet_ntop, with legacy inet_aton/inet_ntoa), and perform modern name/address resolution with getaddrinfo and getnameinfo. It is the plumbing used by higher level modules such as IO::Socket and IO::Socket::IP, and supports IPv6 and Unix domain sockets where the platform provides them, though many constants are OS dependent so you should explicitly import the symbols you need. The module also provides convenient CR, LF and CRLF constants and helpers for multicast and membership structures. If you want simple socket code you will normally prefer IO::Socket or IO::Socket::IP, but if you need direct control over sockaddr layouts, socket options, or address conversions Socket is the right tool, and the recent 2.041 release modernized the documentation and fixed a bug in the IPv4 source‑membership packing helper.

App::LinkSite is the core driver for the linksite application that builds a simple website cataloguing your links. It exposes a run method as the main entry point and calls do_this for each file it finds in a src directory so you can turn those source files into pages or entries. Debugging is available by setting the LINKSITE_DEBUG environment variable, making it easy to trace what the tool is doing. The module is lightweight and intended to be used via the linksite command to automate generating a link index from a collection of files.

OcToolkit is a Perl library that helps you manage OpenShift and Kubernetes projects by turning Template Toolkit templates into YAML and driving the cluster with oc or kubectl commands, making it easy to install, validate, update, back up, and delete resources across multiple clusters. It includes built‑in secret handling, workspace and template organization, and extensible hooks so you can inject custom URL generation, component filters, configuration flags, and cleanup routines without rewriting core logic. The module is aimed at CI/CD use and small teams who want a repeatable, template-driven workflow and it also powers the ocToolkit command line tool; you will still need a working oc or kubectl binary and Template Toolkit to use it. Recent updates cleaned up packaging, added examples and contribution and security documentation, and integrated quality tests to improve reliability.