CPANscan

Net::CalDAVTalk is a Perl client for talking to CalDAV servers that wraps the protocol into a JSON-friendly API so you can list, create, update, delete and sync calendars and events without wrestling with raw XML. It is the FastMail code used for their CalDAV backend and test suite and builds on Net::DAVTalk to discover user principals and calendar-home-sets, cache timezones, and offer high-level calls such as GetCalendars, NewCalendar, GetEvents, NewEvent, SyncEvents, SyncEventLinks, GetFreeBusy, GetICal and utilities for moving, annotating or deleting events and calendars. The module handles UID and sequence generation, supports scheduling suppression via a _no_schedule flag, produces and consumes JSCalendar/iCalendar using Text::JSCalendar, and exposes logging hooks for integration into test or debug workflows. It is especially useful if you need a scriptable CalDAV client or a test harness for calendar servers, and recent releases updated the JSCalendar schema and bumped Text::JSCalendar compatibility to 0.05 while adding explicit support for Schedule-Reply suppression.

IO::Compress is the top-level Perl distribution for compressing and uncompressing data that provides a family of IO::Compress::* and IO::Uncompress::* modules to read and write gzip, zip, bzip2, zstd, xz, lzma and raw deflate streams and zip archives in both streaming and one‑shot styles. The IO::Compress package itself is a stub and contains no code, but it bundles and documents the practical, filehandle-like interfaces and helpers used by the submodules for common tasks such as streaming I/O, archive member handling, Zip64 and extra‑field support, and transparent format detection. If you need to produce or consume compressed data from Perl programs or scripts this distribution is likely relevant to you because it aims to be a portable, feature‑rich toolkit for a wide range of compression formats. The recent 2.220 release (May 2026) includes maintenance fixes such as removing an eval from the globmapper, an update to the included zipdetails tool, and a bugfix for the rawdeflate option in the AnyInflate/AnyUncompress code.

App::karr is a Git-native kanban tool that provides the karr command line client and a small Perl API for repositories that want Git to remain the transport and source of truth. Board state is stored in refs/karr/* rather than checked-in files, task cards are Markdown with YAML frontmatter, and commands materialize a temporary board view, serialize changes back into Git refs, and push so you avoid a persistent karr/ tree and file-level merge conflicts. The CLI covers common workflow operations like create, list, move, pick, archive, backup, restore and can run in Docker for a predictable runtime, and the lower-level modules such as App::karr::Git and App::karr::BoardStore can be used from Perl for automation or inspection. The recent 0.200 release cleans up and centralizes configuration into Config and BoardStore, extracts activity log handling, and refactors board discovery and sync lifecycle to make ref-based operations and syncing more robust.

Term::ANSIEncode is a Perl module that provides a human readable markup language for generating ANSI terminal output so you can create colored, positioned and framed text without hand crafting escape codes. You embed tokens like [% RED %], [% B_RGB 255,0,0 %], [% LOCATE column,row %] or [% BOX ... %] to control foreground and background colors, cursor movement, horizontal rules, boxed frames, wrapped and justified text and simple macros. A UTF-8 capable terminal is required for special graphical or international characters and terminals with 256 color or truecolor support unlock the extra RGB colors while the basic 16 color tokens work on most consoles. The interface is minimal with new to instantiate and ansi_output to render the markup and there is a companion ansiencode executable and GitHub repo with examples. Use this module when you need readable markup to build colorful command line UIs, banners or dialog boxes without dealing with raw ANSI escape sequences.

ClearPress is a lightweight, pragmatic web application framework for quickly building CRUD-style sites and APIs in Perl using simple model, view and controller components and Template Toolkit for rendering. It encourages a clear on-disk layout with application-specific model and view modules, template files under data/templates and a central data/config.ini for configuration, and it provides easy model accessors, relationship helpers like belongs_to_through and conveniences for rendering XML or JSON from models. Views in ClearPress act more like traditional controllers so you get straightforward URL-to-action mapping, template helpers such as SCRIPT_NAME and model access in templates, and optional standalone server support for development. There is no heavy magic or automatic schema inspection so you explicitly define fields and relationships, and there is no built-in authentication by default although authentication hooks are supported. The project has seen steady bug fixes and HTTP improvements over time and recent releases focused on correct handling of POST/PUT data, JSON payloads and HTTP method semantics including HEAD and OPTIONS, making it a practical choice for small to medium Perl web apps where simplicity and rapid development matter.

Container::Builder is a Perl tool for assembling minimal container images as TAR archives that Podman or Docker can import, with a focus on composing images directly from Debian package files. It provides Dockerfile-like operations in Perl so you can add .deb packages as layers, drop in files or whole directories, create users and groups, set environment variables, workdir and entrypoint, and optionally cache downloaded packages for faster rebuilds. The module builds the actual layered archive only when you call build and can return the archive as a scalar or write it to disk, while get_digest exposes the image config digest used by container runtimes. It also includes experimental helpers to extract specific files from debs and options to compress layer tarballs. Note that the author marks the project as early stage and not production-ready, and the recent 0.11 update fixed diff ID calculations so config JSON uses the required uncompressed digests and improved compression-related tests.

App::zipdetails is a small utility for inspecting the internal layout of ZIP archives, letting you view entries, headers, central directory records, offsets, sizes and compression details so you can diagnose corruption, verify contents or understand archive structure. The CPAN package is essentially a stub module and the actual command line program is provided as bin/zipdetails, so install the distribution and run that script to use it. It is maintained by Paul Marquess and is free software distributed under the same terms as Perl.

Crypt::JWT is a Perl toolkit for creating and consuming JSON Web Tokens, covering both signed tokens (JWS) and encrypted tokens (JWE) and implementing the standard JWA algorithms. It provides simple encode_jwt and decode_jwt calls that produce compact or flattened JSON serializations and accepts keys in many forms including raw octet strings, PEM or DER blobs, JWK structures, and common Crypt::PK or OpenSSL key objects. decode_jwt includes flexible, per-claim verification and header checks plus support for JWK key lookup, while encode_jwt supports common conveniences like automatic iat, relative exp/nbf, compression and extra headers. The author built in security-minded defaults and tunable limits such as minimum RSA size, minimum HMAC key length, PBES2 iteration cap and maximum inflated payload size, and documents dangerous options like allowing alg "none", ignoring signatures, or trusting jwk header material. It does not support the general multi-recipient JSON serialization, but otherwise offers a full featured, production-ready JWT implementation for Perl.

Crypt::ScryptKDF provides a simple Perl interface to the scrypt password-based key derivation function so you can derive cryptographic keys from passwords or create and verify secure password hashes that are resistant to large-scale custom hardware attacks. The module offers functions to produce raw, hex or base64 encoded keys and a convenient scrypt_hash/scrypt_hash_verify pair for storing and checking password hashes, with sensible defaults for cost and output length while allowing you to tune N, r, p and output size when needed. It requires a cryptographically strong random number source and will try several common RNG providers, failing if none are available, and it can generate random salts for you when creating hashes. The most recent release fixes CVE-2026-8647 and adds a SECURITY.md file to document security considerations.

Net::DHCP (via Net::DHCP::Packet) provides a simple object representation of a DHCP message following the RFC 1533/2132 formats so you can build, inspect and emit DHCP packets from Perl code. It gives you high‑level methods to set common header fields, add or remove DHCP options in either human‑readable or raw binary form, pack and unpack packets for wire I/O, and work with suboptions and IPv4 address fields when you need finer control. The module is useful for writing DHCP clients, servers, testers or protocol analyzers and includes helpers and tests for working with real packets. The recent 0.8 release modernizes the constructor, tightens option handling and comparisons, adds suboption helpers and safer length checks, and cleans up tests and exports for more robust and maintainable use.

Conf::Libconfig is a Perl wrapper around the libconfig C library that lets Perl programs read, write and manipulate structured configuration files using familiar scalar, array and hash types. It supports loading configs from files or strings, fetching values or whole arrays and hashes, adding and modifying nodes, deleting entries, and writing back to disk, plus error reporting and source location info. Newer libconfig features are exposed too, including include directories, option flags, automatic type conversion, float precision and numeric output formats, as well as custom hooks and destructor callbacks. This module is a good fit if you want a compact, C style configuration format that is easy to share with C or C++ code or if you need typed config values rather than plain text only. You will need the libconfig library installed on your system and the module is BSD licensed.

Net::Statsd::Lite is a compact, easy-to-use StatsD client for Perl that implements the StatsD Metrics Export Specification v0.1 and can pack multiple metrics into a single UDP packet to reduce network overhead. It provides the usual metric types you expect from StatsD such as counters, gauges, meters, timings and histograms, plus a set operation for tracking uniques, and it supports sampling rates and client-side buffering with configurable autoflush and maximum buffer size. You can prefix metric names and configure host, port and protocol, and the design makes it simple to extend by subclassing if you need tagging or other vendor-specific extensions. The module expects integer values in most cases and offers an optional strict mode for type checks, but it does not enforce bit-size limits and some metric types or sampling features may not be supported by all StatsD servers. Development is on GitHub and the module requires Perl 5.20 or later.

JQ::Lite is a pure-Perl implementation of a jq-like JSON query engine that you can use as a library or via the bundled jq-lite command line, letting you run familiar dot-notation filters and pipe-style queries without installing the jq binary or any XS modules. It supports array and object traversal, optional key access, boolean selection, mapping and grouping, many of jq's built-in functions and helpers such as map, walk, group_by, sort_by, unique_by and statistical operations, and offers a REPL for interactive exploration plus decoder selection between JSON::PP and compatible backends. It is aimed at environments where external binaries cannot be installed, including minimal containers, restricted servers, CI systems and air-gapped or legacy machines, and returns native Perl scalars, arrayrefs and hashrefs so results are easy to consume in scripts.

Crypt::DSA is a Perl module that implements the Digital Signature Algorithm for generating keys, creating signatures, and verifying signatures, and it is primarily intended for working with legacy DSA data rather than new deployments. It provides a simple object interface similar to Crypt::RSA and can generate p, q, and g parameters, create DSA keypairs, sign messages or digests, and verify signatures, returning dedicated objects for keys and signatures. The heavy mathematical work is handled by the Math::Pari library while the module code itself is pure Perl. Message signing uses a SHA1 digest when you pass a plaintext message and accepts an explicit digest up to 20 bytes if you prefer. Note that q and g are 160 bits by design and you must supply the desired p size when generating keys. Because DSA and SHA1 are considered outdated for new cryptographic work, this module is best used for validating existing signatures and for interoperability with systems that still require DSA.

Crypt::Passphrase is a Perl library for managing password hashing and verification in a cryptographically flexible way. You configure one encoder to create new hashes and can register multiple validators to accept legacy or alternative hash formats so you can migrate users smoothly. The module can tell you when a stored hash should be rehashed because the algorithm or parameters are out of date and it provides tools to recode hashes when peppers change and to wrap a hash for use in frameworks or ORMs. It supports modern backends such as Argon2, bcrypt, yescrypt, scrypt and PBKDF2 as well as peppering and HSM options, but those backends are separate modules you must install. Crypt::Passphrase also handles Unicode normalization and encourages configurable, deployment-specific settings to balance security and resource use.

Dist::Zilla::PluginBundle::Author::GETTY is an opinionated, ready-made bundle that wires together the Dist::Zilla plugins Getty uses to build, version, document and release Perl distributions. It saves you from handcrafting common setup by providing sensible defaults for metadata, Git-based versioning and branch checks, PodWeaver, CPAN upload and install-after-release steps, plus conveniences for XS or Alien-backed C libraries, custom run hooks and metadata like IRC or an "adopt me" flag. The bundle is highly configurable so you can toggle CPAN uploads, include or exclude README.md, control changelog generation and tweak XS/Alien behavior without composing each plugin yourself. Recent releases add Docker build and release attributes so you can produce container images as part of your release workflow and remove some older deprecated release options.

MooX::Role::Parameterized is an experimental port of MooseX::Role::Parameterized that brings parameterized roles to Moo, letting you define reusable role templates that accept parameters and inject attributes and methods into target classes at composition time. You declare role parameters with parameter and provide a role block that receives the parameters and a simple "mop" proxy to install has, method and other role behaviors, and you can apply those roles directly with apply_roles_to_target or via the MooX::Role::Parameterized::With helper that overrides with to support applying roles (including applying the same role multiple times by passing an arrayref). The module is handy when you want to generate patterned attributes and accessors from a single role definition rather than writing repetitive code, and it interoperates with existing Moo and Role::Tiny setups while keeping the API lightweight. Recent updates added robust support for passing arrayrefs to apply a role multiple times, fixed several parameter-handling bugs, and cleaned up packaging and CI/release tooling.

Trog::TOTP is a fork of Authen::TOTP that provides a simple, RFC6238-compatible TOTP (time‑based one‑time password) implementation for Perl to add two‑factor authentication to your apps. It can generate and return binary secrets or base32 secrets for user setup, produce TOTP URIs suitable for QR codes, compute the expected code for any given timestamp, and validate user-supplied OTPs with configurable digits, period, algorithm (SHA1, SHA256, SHA512) and tolerance for clock drift. It includes debugging helpers such as a totp_debugger script and a time_for_code method to help diagnose clock or client issues, and accepts a logger callback for integration with your logging system. Note that many authenticator apps ignore custom periods and assume 30 seconds, so changing period can be problematic. Recent releases added the time_for_code and totp_debugger utilities, a return_when option for validate_otp, and in the latest update the module switched to Crypt::PRNG::rand for improved randomness.

OcToolkit is a Perl-based, Helm-like toolkit for generating, applying, validating, backing up, upgrading, and deleting OpenShift and Kubernetes resources using Template Toolkit driven YAML templates and the oc or kubectl CLI. It wraps template rendering, YAML/JSON handling and secret encoding into a configurable object that supports multi-cluster workflows, per-instance settings, and user-supplied hooks for things like URL generation, component filtering and clutter removal so you can adapt it to different environments and pipelines. The module is aimed at users who want a Perl-centric, highly customizable alternative to Helm that keeps templates under source control and can produce diffs against live clusters as part of a validate or upgrade flow. Built-in features include secret management from a directory, ordered template processing, and backup/export of live resources, and it is intended to be used via the provided ocToolkit command line wrapper. The latest 1.10 release consolidates earlier fixes and documentation improvements and adds example files, CONTRIBUTING and SECURITY guides and basic test quality tooling.

Log::Abstraction is a lightweight, flexible logging layer that lets Perl programs send messages to many kinds of back ends with a single API. It supports code references, array refs, file names or descriptors, objects, and syslog, and it can be driven from a config file or environment variables so you can change logging behavior at runtime. You control the minimum level, message format (with tokens like %level% and %timestamp%), and it provides the usual convenience methods such as debug, info, notice, trace, warn, error and fatal, plus the ability to forward high priority messages by email when mail modules are installed. If no logger is supplied it can fall back to Carp or croak depending on options, and only warnings and above are sent to syslog at the moment. The module is ideal when you need a consistent, configurable logging interface across different logging implementations.

App::DBBrowser is a terminal-based interactive database browser that lets you explore and manipulate SQLite, MySQL, PostgreSQL and many other databases via plugins without leaving the console. It provides guided menus and forms to view table schemas and rows, build SELECT/INSERT/UPDATE/DELETE statements, run joins, unions, CTEs and window functions, import and export CSV or spreadsheet data, apply filters and search-and-replace transformations, and save reusable subqueries and configuration. The tool is designed for quick, hands-on inspection and light editing of databases from the command line and integrates with Term::TablePrint, Term::Choose and Term::Form to present readable table output and interactive prompts. Recent releases made a backwards incompatible change by turning off automatic quoting of table and column names by default and moved saved subqueries to the plugin level, and also added SQL dialect support for MSSQL and DuckDB with ODBC dialect detection.

Term::TablePrint is a small Perl utility for displaying an array-of-arrays as an interactive, scrollable table in a terminal so you can browse, search and inspect rows without leaving your script. It highlights a cursored row and supports familiar navigation keys, incremental regex searching, optional per-row expansion that prints each column on its own line, and a configurable column-selection mode for narrow terminals. The module offers many display and formatting options such as trimming or truncating wide columns, handling undefined or binary fields, ANSI color support, and Windows codepage handling, and it works as a simple subroutine or as an object with overridable settings. You need Perl 5.16 or newer, decoded strings and a properly configured terminal encoding and monospaced font for correct output, making it a handy tool for quick data exploration and CLI front ends.

Sub::Middler is a lightweight Perl helper for composing middleware-style subroutine chains that lets you pre-link small stages into a single callable head with very low runtime overhead. You register maker routines that produce the actual work subroutines and then link them so each stage decides if and when to call the next stage, which makes it easy to build synchronous, asynchronous, or one-way filters and pipelines. The module avoids runtime iteration over a list of subs by weaving the chain at link time, and it exports a convenient linker helper for inline use. Recent releases added practical short cuts that let you use scalar, array, hash or simple code references to capture intermediate results and added callback-aware behaviour for easier asynchronous flows. Sub::Middler is a good fit when you want a fast, minimal, flexible middleware mechanism with custom argument semantics, and you may prefer Sub::Chain or Sub::Pipeline if you need named stages or richer runtime features.

Nobody::Util is a compact convenience toolkit of assorted helper functions from Rich Paul that gathers common conveniences and re-exports frequently used utilities so you can get a useful working environment with a single use statement. It bundles file descriptor helpers like open_fds, getcwd and nonblock, object and reference helpers such as class and safe_isa, string and list utilities like pad and lsort, version comparison with vcmp/vsort, a sortable timestamp generator serdate, file helpers including file_id and serial_maker, and simple introspection tools such as deparse and methods. Most functions are exported by default and the module also re-exports common symbols from Carp, List::Util, Scalar::Util, Sub::Util, POSIX, Fcntl, Path::Tiny and FindBin so it is convenient for quick scripts and small utilities. This is the initial 0.01 release.

Nobody::PP is a lightweight pretty-printer for Perl data structures that produces compact, readable output ideal for debugging and simple logging. It exports handy functions like pp to return a formatted string, dd and ee to print that output to STDOUT or STDERR, and ppx, ddx and eex to include the caller file and line number with the output. The loc helper builds a file:line prefix and quote and qquote produce single and double quoted Perl string literals. Derived from Data::Dump, this module is meant as an easy drop in for inspecting variables during development and is distributed under the same license as Perl.

Graphics::Framebuffer is a Perl library for drawing directly to a Linux console framebuffer, providing simple, immediate graphics without X or heavyweight toolkits. It exposes easy-to-use methods for pixels, lines, shapes, gradients, filled polygons, TrueType text, image loading, blitting and basic animation so you can build console UIs, media viewers or lightweight embedded displays. The module can run in emulation mode for offscreen testing, uses the Imager library and optional Inline::C acceleration for heavier tasks, and prefers 24/32 bit modes for best speed and compatibility. It is console only and requires a framebuffer driver and appropriate device permissions, it will not work under X/Wayland or with proprietary DRM drivers. Performance depends on CPU and whether acceleration is enabled, and the author warns that some accelerated routines and 16 bit mode conversions can behave differently so toggling acceleration may be necessary. If you need compact, software-driven graphics on headless or embedded Linux systems, this module gives a practical, well documented toolkit.

Debug::Easy is a lightweight Perl logging helper that makes it easy to add colorized, nicely formatted debug and log output to your scripts, offering multiple severity levels from ERR and WARN through INFO and VERBOSE to DEBUG and DEBUGMAX, automatic timestamps and simple benchmarking between messages, and highly customizable prefixes that can include date, time, PID, calling module, subroutine and line numbers. Messages can be single strings or arrays and the module will pretty print data structures using Data::Dumper or Data::Dumper::Simple when available, and you can direct output to STDERR or STDOUT or set per-level prefixes and a custom filehandle. It works with sensible defaults so you can get started quickly but also supports multiple independent Debug::Easy objects for different outputs. Be aware that if you fork or thread and inherit the same object you may see misaligned padding between processes so creating separate objects per child or logging to separate files is recommended. Recent updates focused on execution-speed optimizations and fixed timestamp and token formatting so the module now aims to add minimal overhead to your running code.

Imager::File::GIF is the Imager plugin that lets Perl programs read and write GIF images through the Imager framework. It provides GIF input and output support including proper handling of paletted images and transparency and works with a range of giflib versions so Imager can probe and use the system GIF library at build and runtime. Use it whenever you need GIF read/write capabilities integrated into Imager for image processing tasks. Recent releases address compatibility with newer giflib versions and include a security fix in 1.003 that closes a buffer overflow when reading images (CVE-2026-8454).

Imager is a mature Perl module for creating and manipulating full color images that makes common graphics tasks simple from scripts and web apps. It can read and write many popular formats, draw shapes and text, apply filters and blends, scale, crop and rotate, work with palettes and alpha channels, compose images together and access low level pixel samples when you need them. The functionality is split into focused Imager:: modules for files, drawing, fonts, transformations, filters and more so you can pick the parts you need while retaining a consistent API and error reporting via errstr. Imager is suitable for automating thumbnails, on-the-fly image edits, batch processing and lightweight graphics work where you want a Perl-native solution rather than calling out to external tools. The project is actively maintained and recent releases include security fixes and format updates, most recently a fix for a GIF heap buffer overflow addressed in Imager 1.031 (CVE-2026-8454).

This module is part of the AsposeCellsCloud Perl client and provides a simple Perl-facing interface to the Aspose.Cells Cloud REST API. It centralizes configuration for credentials and endpoints, offers an API factory to create service clients, and includes role-related helpers for managing access, so you can create, modify and process spreadsheets in the cloud without writing raw HTTP calls. It is useful for Perl developers who need programmatic, cloud-based spreadsheet manipulation and requires a valid Aspose Cloud account and network access to the service. Using the module lets you focus on spreadsheet logic while the SDK handles authentication, request construction and response parsing.