CPANscan

Role::Tiny is a tiny, dependency-light Perl library for composing roles into classes and objects, offering the core features of role-based code reuse without attributes or a heavyweight meta system. It gives you requires to declare required methods, with to compose roles, and optional before/after/around method modifiers via Class::Method::Modifiers when needed. Composition favors the class over the role so existing class methods win and conflicting methods from multiple roles raise an exception unless the class provides an implementation. You can apply roles to packages or individual objects, create a new class with roles applied, and test role application with does_role or the ->does helper. If you want attributes or a richer role protocol use Moo::Role or Moose::Role, and note a couple of minor overload-related caveats on very old Perl versions.

Crypt::OpenSSL::PKCS12 is a lightweight Perl wrapper around OpenSSL's PKCS#12 functionality that makes it easy to load, inspect, create and modify .p12 or .pfx bundles from Perl code. You can open PKCS12 data from a file or a string and extract the certificate, private key and CA chain in Base64 form, verify the file MAC, change passwords, and create new PKCS12 files or return the PKCS12 data as a string, and it also offers an info dump and a structured info_as_hash for programmatic inspection. The module works with OpenSSL 1.x and 3.x and requires a system OpenSSL installation and Perl 5.8 or later. The project is maintained and the recent 1.95 release fixes security issues including an integer overflow and safer password handling, so users are advised to upgrade.

Horus is a high-performance XS UUID/GUID generator for Perl that implements all RFC 9562 versions (v1–v8) plus NIL and MAX and offers ten output formats from hyphenated strings to base64, base32, Crockford and raw binary. It ships without external C library dependencies and is optimized for speed with random pool buffering and bulk generation to produce millions of v4 UUIDs per second while also providing deterministic namespace UUIDs (v3 and v5), time-based variants, validation, parsing, conversion and a simple OO interface. The API is straightforward for both single and bulk generation and includes utilities to compare, extract timestamps and change formats. Recent releases focused on test robustness and platform quirks and improved thread-safety and debugging behavior so the module is stable across a wide range of Perls and environments.

Net::Statsd::Tiny is a compact, dependency-light Perl client for sending StatsD metrics that implements the StatsD Metrics Export Specification v0.1 and can pack multiple metrics into a single UDP packet. It supports common metric types such as counters (with increment/decrement helpers and an update alias), gauges including increment/decrement extensions, timings (timing_ms alias) and histograms, plus set_add for tracking unique values. You can configure host, port, protocol, name prefix and buffering behavior with autoflush and max_buffer_size to batch packets, and the API aims for compatibility with other StatsD clients. The module intentionally does not strictly validate metric values and allows sampling and nonstandard values, so some StatsD daemons may ignore those metrics and not all servers accept multimetric packets. It requires Perl 5.10.1 or later and points users to Net::Statsd::Lite if they want stronger validation and higher performance.

Chandra provides Perl bindings to the webview-c library so Perl developers can build cross-platform desktop GUIs using HTML, CSS and JavaScript. It wraps the native webview on macOS (WebKit/WKWebView), Linux (WebKitGTK) and Windows (Edge/WebView2 with an MSHTML fallback) and exposes a concise API to create windows, run or manually control the event loop, execute JavaScript, inject CSS, bind JavaScript calls back to Perl, and manipulate window state such as title, size, fullscreen and background color. It offers both a simple blocking run() and more advanced init/loop control, supports safe dispatching of JS evaluation from callbacks, and includes examples plus a higher level Chandra::App helper. On Windows you should install the WebView2 runtime or supply WebView2Loader.dll for best modern web feature support because the fallback MSHTML engine is limited. If you want to build lightweight desktop apps with a web UI from Perl or embed a browser view into a Perl program, Chandra is a compact, MIT licensed bridge that gets you started quickly.

Func::Util is a compact toolkit of functional programming helpers for Perl implemented in XS and custom ops for speed, aimed at developers who want concise, expressive utilities without giving up performance. It provides zero-overhead compile-time predicates for common type, truthiness, string and collection checks so operations like is_array, is_true, starts_with and array_len execute as fast native checks, plus faster XS implementations of memoization, pipelines, compose, lazy evaluation, safe navigation, null coalescing and common list/hash transforms like pick, omit, pluck, uniq and partition. For array-heavy workloads it includes pure C comparison helpers such as first_gt and any_ge that avoid Perl callback overhead, and a callback registry that lets you register named Perl or XS callbacks for even higher performance. The module also offers small utilities such as clamp, tap, always, once and replace_all to simplify everyday data handling. Use Func::Util when you want readable functional idioms in Perl but need the extra speed of C-level ops, keeping in mind that operations which still invoke arbitrary Perl coderefs are subject to normal call overhead.

Hypersonic is a performance-first micro HTTP server for Perl that JIT-compiles your routing and event loop into C so the hot path runs at native speed. You define routes, WebSocket endpoints, streaming endpoints and static assets in Perl, call compile to generate C via XS::JIT, and then run the resulting server with optional workers and TLS. Static handlers and files are evaluated once at compile time and baked into C string constants for minimal overhead while dynamic handlers run per request with a JIT-compiled request object, and the framework also offers sessions, middleware, gzip compression, an async thread pool and optional WebSocket room broadcasting. If you need a tiny, extremely fast HTTP server and are comfortable with a compile step and native dependencies like XS::JIT, zlib and OpenSSL, Hypersonic is a strong fit.

Dist::Zilla::Plugin::Docker::API integrates Docker image builds into your Dist::Zilla release workflow so you can produce and publish container images alongside your distribution. You point it at a repository name and one or more tag templates and it will build the image from a Dockerfile during dzil build, optionally load it into your local daemon for verification, and then re-tag and push those tags during dzil release if configured. Configuration options cover the image name, tag templates (for example %v for the distribution version), Dockerfile name, build arguments, OCI labels, target platforms, and flags to control loading and pushing behavior. Legacy option names are accepted but deprecated. If you package Perl software with Dist::Zilla and want to ship Docker images as first-class release artifacts, this plugin automates the build, tagging, and publish steps.

File::Raw::Gzip is a lightweight plugin for File::Raw that transparently compresses and decompresses gzip, zlib and raw-deflate streams so you can read and write compressed files with the same file_slurp/file_spew style calls you already use. It supports full gzip files, zlib streams and raw deflate data, lets you tune compression level, memory and chunk sizing, and can stream large gzip files line by line without loading them into memory. Because it is a pure byte transform it composes cleanly with other File::Raw plugins so you can, for example, read a .csv.gz straight into a CSV parser. The module links against the system zlib library so you will need the zlib development package on Unix or Homebrew on macOS while Strawberry Perl on Windows already bundles zlib. Recent releases fixed a Windows crash related to memory pool handling and bumped the File::Raw prerequisite to ensure correct streaming behavior on Windows.

File::Raw::Separated is a compact CSV/TSV parser that plugs into File::Raw to give you fast, memory-friendly reading of delimited text whether it fits in RAM or must be streamed from disk. It registers "csv" and "tsv" plugins and also exports parse routines you can call directly to read whole buffers, iterate row-by-row with a callback, or stream large files in fixed-size chunks, with optional header handling to return rows as hashes. The parser is configurable for separator, quote and escape characters, line ending handling, trimming, empty-field behavior, strictness on malformed input, and a per-field size cap, and the callback variants reuse a single arrayref for performance so you should copy rows if you need to retain them. Write/record phases are not yet implemented so this is a read-focused tool, and the module integrates cleanly with File::Raw without global mutable state. The recent 0.04 release bumps the File::Raw prerequisite to 0.13 to pick up a Windows streaming O_BINARY fix. If you need a lightweight, high-performance, configurable CSV/TSV reader in Perl, especially for very large files, this module is a good fit.

File::Raw::Hash is a compact File::Raw plugin that computes cryptographic and integrity digests while letting the file bytes flow through unchanged and returning the checksum via a caller-supplied scalar, hash or array reference. It supports single- and multi-algorithm runs in one pass with common choices such as sha256 (default), sha512, sha1, md5, crc32, xxh64 and blake3, offers hex, base64 and raw output formats, and can operate in RFC 2104 HMAC mode for the usual MAC-capable digests. The module vendors public-domain reference implementations so there are no external library dependencies and it works across File::Raw read, write, stream and record phases, making it easy to checksum either on-disk bytes or decoded payloads inside plugin chains. Recent updates raised the File::Raw prerequisite to 0.13 to pick up a Windows streaming O_BINARY fix.

Tie::OrderedHash is an XS-backed replacement for Tie::IxHash that preserves insertion order for Perl hashes while exposing a stable C API so other XS modules can manipulate and iterate the underlying ordered hash without the overhead of Perl's tie magic. At the Perl level it behaves like a familiar tied hash and also provides an object interface with Push, Pop, Shift, Unshift, Keys, Values and Length, giving modest speedups over Tie::IxHash for normal Perl use. The real benefit is the public C ABI and caller-owned iterator, which let downstream C code call functions such as tie_oh_store and tie_oh_iter_next to get large performance wins and support concurrent C-level iteration. Recent small maintenance updates improve build compatibility for smaller systems and loader behavior to make the module easier to use across platforms.

Perl7::Handy is a tiny compatibility shim that gives your Perl 5 code a set of Perl 7–style defaults so you can adopt modern practices without upgrading the interpreter. Using Perl7::Handy injects strict and, where available, warnings into the caller, disables bareword filehandles and the multidimensional array emulation, enables subroutine signatures on newer Perls while suppressing their experimental warning, lexically disables the indirect method call syntax, and removes the current directory from @INC to avoid the well known unsafe module load issue. It works on Perl 5.00503 and later and selectively enables or skips features depending on the interpreter version, making it a handy way for developers to write cleaner, safer code with Perl 7 semantics while staying on Perl 5. Recent releases added signature support and the indirect-feature toggle and explicitly remove "." from @INC to address the CVE-2016-1238 risk.

Modern::Open is a small compatibility helper that brings safer, more modern file and socket opening behavior to older Perl installations. It provides autovivification and autodie-style handling for open, opendir, sysopen, pipe, socket and accept, and it enables the three-argument form of open so mode and filename are kept separate. Targeted at Perl 5.005_03 and later, the module is useful when you want legacy scripts to fail loudly on bad opens and avoid common filehandle mistakes without rewriting large amounts of code.

WWW::Mechanize::Chrome is a Perl module that drives a real Chrome or Chromium browser via the Chrome DevTools Protocol so you can automate modern web pages the way a human user and a full browser would. It gives you the ability to run JavaScript in page context, select and inspect nodes with CSS or XPath, intercept and modify network requests, capture screenshots, PDFs and MHTML snapshots, manage cookies and tabs, and interact with dialogs and console messages. You can run headless or visible Chrome, control viewport size, fill and submit forms, upload files, emulate network conditions, and record events or screencasts, which makes it well suited to web scraping, UI testing and automation of single page apps. The module exposes many convenient high level methods while hiding DevTools JSON plumbing, but it does require a Chrome-compatible browser installed and does not implement every WWW::Mechanize method; POST and some legacy APIs are not supported and you may see occasional harmless DevTools messages. If you need browser-accurate rendering and scriptable interaction from Perl, WWW::Mechanize::Chrome is a practical choice.

Net::CUPS provides a straightforward object oriented Perl interface to the Common Unix Printing System so you can script and automate printer administration from Perl programs. It lets you list and look up configured printers, retrieve and inspect PPDs, add or remove printer destinations, send IPP requests to a CUPS server, and change the server, username, or password callback used for transactions. Companion classes handle destination, PPD and IPP details when you need finer control. Pick this module if you need to integrate printing management into Perl applications or automate CUPS tasks, and note the project is maintained on GitHub where pull requests are welcome.

Resource::Silo is a lightweight, declarative container for managing the external resources an application uses, such as configuration files, database handles, HTTP clients, and other services. You declare named resources with a small DSL and those names become methods on the container, then resources are created lazily, cached, and cleaned up automatically, with support for dependency wiring and a Spring-style "class" mode for constructor injection. The container is fork-aware so cached handles are reset after a fork, and it offers fine-grained controls to override resources, lock the container to prevent accidental side effects, preload items at startup, validate or coerce values, and define custom cleanup order, which makes it convenient for testing and safe production use. It integrates with Moo and Moose when used as a class and aims to simplify wiring and lifecycle management without pulling in a heavyweight IoC framework. The module is still in beta and its interface is evolving, but it is well suited for applications that need predictable, testable management of external resources.

HTTP::Tiny is a compact, dependency-light HTTP/1.1 client for Perl that gives you a straightforward way to make GET, POST and other HTTP requests without pulling in a heavy framework like LWP::UserAgent. It supports proxies, basic redirection handling, persistent single-host keep‑alive connections, streaming request and response bodies via callbacks, simple form encoding and a mirror-to-file helper, with cookie handling available if you supply an HTTP::CookieJar. HTTPS works when IO::Socket::SSL and Net::SSLeay are installed and IPv6 is used automatically if IO::Socket::IP is present, and the module now verifies TLS certificates by default with can_ssl available to check support. HTTP::Tiny focuses on correct, low-level transport rather than a full browser feature set, so you must supply properly escaped URLs and it follows a deliberately strict redirection policy and other documented limitations, but it is reliable for scripts and small services that need a minimal, correct HTTP client. The recent 0.093 release fixed header validation to prevent invalid characters and header smuggling (CVE-2026-7010), reinforcing its suitability for secure, lightweight HTTP use.

Graphics::Colourset generates harmonious sets of five related colours intended for window‑manager themes, UI components and web CSS, so you can produce consistent background, top and bottom shadow, foreground, inactive foreground and optional high and low alert colours from a single hue and a simple shade value. You can build one set with new or generate multiple coordinated sets with make_n_coloursets or attempt_n_coloursets using traditional color‑theory styles like complement, split complement, triad, tetrad, analog and mono, and the module will try to avoid visually clashing combinations with a built‑in heuristic. Colours are returned in familiar formats including hex strings, X rgb strings, HSL text and HSV numeric tuples, and there are small helpers to bias a hue toward red or green and to compare or test equality of sets. Recent updates added additional ways to retrieve colour information, documented the foreground_high and foreground_low colours for alerting use, and allow you to restrict which style families are used when generating multiple sets, and the module integrates with Graphics::ColorObject for color math.

File::Raw::JSON is a small, fast JSON and JSONL plugin for the File::Raw family that wires high-performance yyjson parsing into File::Raw so you can slurp, spew, or stream JSON with a single syscall path. It registers two plugins, "json" for single-document files and "jsonl" for JSON Lines streams, and also exports two direct XSUB helpers file_json_decode and file_json_encode for in-memory conversions. JSONL streaming is memory-bounded and uses a brace‑balancing slicer so pretty-printed records, multi-record lines, braces inside strings, and chunked reads are handled correctly. You get useful encode/decode options such as pretty printing, key sorting, relaxed parsing, UTF‑8 handling, preservation of insertion order via an ordered decode mode, and control over NaN/Infinity and maximum depth, with the usual tradeoff that ordered decoding is slower. The module vendors yyjson under an MIT license and aims for byte-identical output between the plugin and codec paths. Recent work fixed a Windows Strawbery Perl build issue so it compiles cleanly on Win32.

App::TextTemplatePermuteUtils is a small command-line toolkit for working with Text::Template::Permute templates, centered on the template-permute utility. It accepts a template string and related options and produces permutations of text fragments, with features to return results as an array or send them to the clipboard so you can integrate it into scripts and workflows. Calls return an enveloped result with HTTP-like status codes, a human-readable reason, and an optional payload and metadata, which makes error handling and automation straightforward. This is a lightweight first release aimed at people who need to generate or batch-process variant text from templates; see Text::Template::Permute and the project homepage for full usage and source.

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.