CPANscan

Perl5::Build::Warnings is a small utility for parsing the output of make when building the Perl 5 core so you can study compiler warnings across a build. You point it at a plain text or gzipped make/test_prep log and it extracts warnings that match the typical "<file>:<line>:<char>: warning: ... [-W...]" form, normalizes the warning class to a "W..." name and exposes the results programmatically. The module can return a list of all parsed warnings, counts by warning class, or filtered lists for a particular warning class or source file, and it can pretty-print a summary to STDOUT. It has no runtime dependencies outside the Perl core and is primarily aimed at Perl core developers or maintainers who want a quick way to tally and inspect build-time warnings, provided the log uses the expected warning format.

JSON::Schema::Tiny is a slim, fast Perl validator that checks ordinary Perl data structures against JSON Schema rules. It offers a simple functional call and an object-oriented API and returns a clear result indicating validity and, when validation fails, JSON Schema style error details. The module implements the most commonly used keywords so it is well suited for everyday validation tasks while deliberately omitting some advanced features such as external $ref resolution, annotations and several newer draft keywords to keep the code small and quick. You can tweak behavior with options like boolean-only results, depth limits, and tolerant handling of boolean or numeric-like values. Be aware that regexes from schemas are evaluated without sanitization so do not use untrusted schemas, and use a reliable JSON decoder such as Cpanel::JSON::XS so data types are preserved. For a more complete, specification-compliant alternative see JSON::Schema::Modern.

Crypt::DSA is a Perl library that implements the Digital Signature Algorithm so you can generate DSA key pairs, sign messages or digests, and verify signatures; it is written in Perl and uses Math::Pari for the heavy math. The API is modeled on Crypt::RSA and supports configurable p bit length, optional seed and verbosity during key generation, and automatic SHA-1 hashing of messages when you pass plain text to sign or verify. Note that DSA and SHA-1 are now considered weak for new signatures, so this module is best used for verifying legacy signatures or when a DSA signature is explicitly required. It does not yet provide built-in key file format conversions such as SSH key files.

IO::Compress is nominally a module for reading and writing compressed data in multiple formats, but this particular release is only a stub and contains no code. It exists mainly as a placeholder on CPAN for packaging or compatibility and therefore does not provide compression or decompression functionality itself. If you need to work with compressed data, use the concrete implementations such as IO::Compress::Gzip or IO::Compress::Bzip2 or other compression modules. The stub is maintained by Paul Marquess and is distributed under the same license as Perl.

Sys::Virt is a Perl XS binding for the libvirt API that lets Perl scripts and applications connect to and control virtualization hosts with a single, consistent interface. It supports opening connections to local or remote hypervisors via libvirt URIs, creating and defining domains, networks, storage pools and volumes, inspecting host capabilities and resource statistics, and registering event callbacks for domain, network, storage and device lifecycle changes. The module surfaces libvirt features such as authentication callbacks, CPU and migration helpers, stream and save/restore operations, and returns failures as Sys::Virt::Error exceptions so they are easy to catch from Perl code. Because it uses callbacks into C, you must deregister any registered callbacks before discarding a connection object to allow the connection to be closed and memory reclaimed. Sys::Virt is a mature, actively maintained binding that requires the libvirt library on the host and keeps up with libvirt additions for new constants and APIs, most recently adding the virDomainAnnounceInterface API and related constants as well as support for vCPU removal and related event and stats constants.

Mojolicious::Plugin::Localize is a localization plugin for the Mojolicious web framework that gives you a dictionary-driven way to manage translated text and render it from controllers and templates. You register it with a nested dictionary or resource files and it merges entries while offering an override option, then exposes helpers like loc to fetch messages and localize->dictionary to inspect the merged data. Dictionary values can be Mojo::Template strings or code references so translations may include variable interpolation and additional lookups, and the module provides convenient short notation for keys such as de_tree_plural. It also supports preferred and default fallbacks via special keys underscore and dash, an end key to force final values, and a command to generate locale templates. The localize->preference helper is marked experimental and CLDR support is listed as a future enhancement. The plugin is inspired by Mozilla l20n, available on GitHub, and released under the Artistic License 2.0.

XML::Loy is a lightweight, extensible XML builder for Perl that makes it easy to construct, traverse and serialize small XML documents. It leverages Mojo::DOM to provide a simple API for creating elements, attributes, text and comments, selecting nodes with CSS3-style selectors and producing pretty-printed output with special content modes such as escaped, raw or armour-wrapped (for base64). The module supports namespaces and a pluggable extension system with bundled helpers for formats like Atom, XRD, GeoRSS, ActivityStreams, OStatus and HostMeta, and extensions can add convenience methods and preferred namespace prefixes or MIME types. Because it is written in pure Perl and emphasizes simplicity and extensibility over raw speed, XML::Loy is best suited for small serialized documents rather than huge, performance-critical parsing tasks. Recent releases include updates to stay compatible with modern Mojolicious, including a fix for Mojolicious 9.31.

Sendmail::PMilter is a pure-Perl implementation of the Sendmail Milter protocol that lets you write mail filters in Perl to inspect, modify, accept or reject messages as they flow through an MTA that supports milters. It implements modern Milter Protocol version 6 and exposes a simple API for registering callback handlers, configuring the listener (setconn or auto_setconn for Sendmail configurations), choosing a dispatch strategy for handling connections, and entering the protocol loop via main. The module ships several dispatchers for different concurrency models and the prefork dispatcher is the most exercised and recommended, while others are marked as not thoroughly tested. It exports the usual milter return codes so your callbacks can continue, reject, discard or accept messages, and it includes helpers to read Sendmail configuration values. Note the security advice in the docs: avoid running Perl milters as root and drop privileges after creating any privileged sockets.

Algorithm::Time::ToNumber converts clock times into simple numeric features for analytics and machine learning, with helpers for both naive and circular encodings. It offers two basic numeric mappings called noon_fail and midnight_fail that map time to a single number but have opposite wrap artifacts causing a gap at 12:00 or 00:00 respectively. For proper circular encoding it provides circle which returns two floats, sine and cosine of the time angle, so you can represent time-of-day without discontinuities and use both values as separate features for algorithms like isolation forest. The angle routine returns only the sine component for a cheaper single-value approximation but can produce overlapping points. There is also suricata_to_circle to parse Suricata EVE timestamps and return the same circle pair ready for modeling. Use this module when you need compact, model-friendly numeric representations of time-of-day.

Algorithm::Classifier::NaiveBayes is a compact Perl module that gives you a ready-to-use multinomial naive Bayes text classifier with sensible defaults and a handful of practical tunables. You train it by feeding labeled strings and it tokenizes text (configurable splitter, lowercase and stop-word filtering) with optional n-grams, supports either raw-count or binary token weighting, and scores classes using log priors plus smoothed token probabilities with Laplace or Lidstone (add-alpha) smoothing. It provides simple train, untrain and prune operations, a classify method that returns the best class plus per-class scores and normalized probabilities, and an explain method that breaks down which tokens drove the decision. Models are JSON-serializable for saving and reloading, scoring options can be tweaked after training, and outputs are deterministic. Note that, as with most naive Bayes classifiers, returned probabilities may be overconfident and are best used for ranking or thresholding. This is the initial release of the module.

Net::Nostr is a full-featured Perl implementation of the Nostr protocol that lets you build both clients and relays and provides focused helpers for identity, event creation, messaging, storage, and many protocol extensions. The distribution is organized into many purpose-built modules such as Net::Nostr::Key for secp256k1 keypair and signing, Net::Nostr::Event for creating and verifying events, Net::Nostr::Client for WebSocket client connections, and Net::Nostr::Relay for running relay servers, plus dozens of NIP-specific helpers for things like encrypted direct messages, media attachments, lists, badges, and more. It targets a wide range of NIPs up to the 2026-07-01 conformance commit and is suitable for developers building clients, bots, relays, gateways, or embedding Nostr features into apps. Recent releases expanded protocol coverage and tightened validation, adding NIP-29 group identifiers, NIP-43 role definitions and role management checks, NIP-44 extended encryption and NIP-59 ephemeral gift wraps, NIP-78 app-data support, and other conformance and security improvements, and the library also supports secure TLS/wss relay connections.

Test2::Harness is a backend test harness for Perl that runs and processes test files and provides tight integration with the Test2 testing framework. It is meant to be used as a library rather than a direct end user tool, so most people will interact with it through App::Yath which supplies the user interface and configuration built on top of Test2::Harness. The module modernizes and improves test execution for Perl projects, is actively maintained by Chad Granum, and its source code is available on GitHub.

Audio::Nama is a small Perl toolkit and command-line application for managing, auditioning, and routing audio samples from a terminal. It provides a text-based user interface built on the Tickit UI toolkit, with entry widgets that support completion, a console front end, and helper modules for defining reusable audio objects, global settings, and processing chains. The result is a lightweight, scriptable way for developers, sound designers, and live performers to browse sample libraries, assemble simple processing chains, and control behavior from the shell without a full graphical DAW. If you want a modular, Perl-centered approach to organizing and routing audio in a terminal environment, Audio::Nama is likely relevant.

MetaCPAN::Client is a polished Perl client for the MetaCPAN API that gives you programmatic access to CPAN metadata and search functionality with a DWIM (do what I mean) layer to make common lookups simple. It covers authors, distributions, releases, modules, files, packages, mirrors, covers and CVEs, supports autocomplete, reverse-dependency queries, bulk scrolling of large result sets, POD fetching and download URL resolution, and lets you tune searches with field filtering, raw Elasticsearch filters and scroller options. The client is intentionally lightweight so it works well in scripts, daemons and CLI tools, and it lets you supply a custom user agent to enable caching or different HTTP backends. It is an official MetaCPAN namespace module and aims to implement the full API surface. Note that a recent change (v2.044.000) makes ResultSet items return an array reference, which may affect how you iterate or extract results.

TOML::Tiny is a compact, pure-Perl TOML v1.0 parser and serializer that makes it easy to read and write TOML without extra dependencies. It provides simple functional helpers from_toml and to_toml plus an object API with decode and encode, and aims to be compatible with the older TOML and TOML::Parser interfaces so you can swap it in easily. The module handles common TOML features including inline and multiline strings, tables and arrays, binary/octal/hex integers, and special float values like inf and NaN, and it automatically returns Math::BigInt or Math::BigFloat for numbers that do not fit native Perl types while letting you supply custom inflate hooks for datetimes, booleans, integers and floats to control how values are represented. TOML::Tiny defaults to somewhat stricter parsing than the original TOML module and enforces a few extra rules when strict mode is enabled, and it intentionally only interprets the official TOML escape sequences and ignores invalid surrogate pairs. If you need a lightweight, dependency-free way to work with TOML in Perl and want control over how special types are represented, TOML::Tiny is a practical choice.

Term::ReadLine is a lightweight frontend that offers a consistent, object-oriented API for interactive command-line input in Perl, standardizing access to different ReadLine backends so your program can prompt for input, perform line editing and manage history with methods like new, readline and addhistory. It returns underlying input and output handles and exposes configuration via Attribs and Features so callers can adapt to whatever implementation is loaded, and if no real ReadLine implementation is available it supplies a basic stub so your code still works with reduced capabilities. When a feature-rich backend such as Term::ReadLine::Gnu or Term::ReadLine::Perl is present you get full editing, history and optional extras like event-loop integration, Tk support, terminal ornaments and TTY switching. You can control which backend is used with the PERL_RL environment variable, making Term::ReadLine a practical choice for portable, pluggable interactive input in command-line Perl applications.

Test::Simple is a tiny, no‑frills testing module that gives you the basics for writing TAP-style tests in Perl. You declare how many tests you plan to run and use ok(expression, name) to produce numbered "ok" or "not ok" lines so test harnesses can report pass or fail. It is ideal for small CPAN modules, quick smoke tests, or developers new to testing and can be replaced by Test::More once you need richer assertions and diagnostics. The module is mature and well maintained, works on very old Perls and is thread-safe on modern ones, and recent maintenance releases have fixed Windows path‑separator test issues and EBCDIC-related problems while improving compatibility with newer Test2 tooling.

Cpanel::JSON::XS is a high-performance, C-backed Perl module that converts Perl data structures to and from JSON with a strong emphasis on correctness, robust Unicode handling, and many practical options for real-world use. It provides both simple functional helpers and a configurable object interface so you can produce compact, ASCII-only, latin1, or pretty-printed JSON, control boolean mapping, handle blessed objects via TO_JSON or FREEZE/THAW hooks, do incremental stream parsing, and tune limits like max depth and max size. The cPanel fork maintains a public repository and issue tracker and adds thread-safety, relaxed decoding modes for human-edited files, and many interop and security fixes. If you need the fastest possible encoder/decoder that cares about round-trip fidelity and correct Unicode, this module is likely a good fit; if you require the strictest RFC-4627 behavior note that as of a recent release the default now accepts top-level non-reference values (allow_nonref is true) for compatibility with the wider Perl JSON ecosystem and you can revert to strict behavior with allow_nonref(0).

Text::AsciidocDown is a lightweight, pure-Perl converter that turns practical AsciiDoc documents into Markdown with minimal dependencies. It exposes a simple object interface with new and convert methods and accepts runtime attributes and a source path so you can control parsing and include resolution. Optionally it can pre-merge local include directives before conversion and supports tag, tags and lines selectors, nesting limits, base directory restrictions and configurable policies for missing files, cycles or bad selectors (error, keep, or drop). The implementation is intentionally conservative about some advanced Asciidoctor include and cross-reference semantics, so it is best suited when you need a straightforward, dependency-light AsciiDoc-to-Markdown tool for typical documents rather than full Asciidoctor compatibility.

Params::Signature provides flexible, declarative parameter validation for Perl subroutines and methods using simple signature strings that can include type constraints, default values and optional flags. It integrates with common type systems such as Type::Tiny or Moose, accepts CODE refs as constraints, supports coercion and per-parameter callbacks, and can normalize named keys or detect positional versus named arguments with configurable fuzzy behavior. The module exposes convenient entry points like validate and validate_method and returns either a hashref or a list of validated values, making it easy to enforce and document expected parameters. It caches parsed signatures for better performance and is pure Perl, with guidance to use a per-module singleton for optimal speed and safe cooperation with Moo via Type::Tiny. The recent 0.05 release focused on documentation fixes and improved examples and guidance for multi-dispatch in the Manual and related modules.

This module lets you search Apple macOS Calendar data from the command line by converting the Calendar.sqlite database into iCalendar VEVENT-like paragraphs that the greple tool can scan. It runs the sqlite3 command to extract events and prints them either as full VEVENT blocks or as compact summaries with the --simple option and extended summaries including descriptions with --detail, and the summarized output is sorted. To use it you need sqlite3 available and your Terminal must have Full Disk Access in macOS Privacy settings so the calendar database can be read. It is a handy read-only way to find calendar events from a shell without opening the GUI Calendar app.

Dancer2::Plugin::OIDC makes it easy to add OpenID Connect login and OAuth2 token validation to Dancer2 web applications. It lets your app act as an OpenID Connect relying party for user authentication and as an OAuth2 resource server by validating access tokens issued by an external provider. The plugin builds on the OIDC::Client distribution, automatically creates client objects and callback routes from simple configuration for one or more providers, and exposes an oidc() helper that returns an OIDC::Client::Plugin instance bound to the current request and session. Common tasks covered include redirecting users to a provider for sign in, building local user objects from identity claims, validating bearer tokens for API endpoints, and performing token exchange when calling other services. Configuration is declared in your Dancer2 config file with provider ids, secrets, scopes and redirect paths, and the author recommends storing session data and tokens on the server side rather than in client cookies for improved security.

Mojolicious::Plugin::OIDC is a plugin that makes it easy to add OpenID Connect support to a Mojolicious web app, letting your application act as an OpenID Connect Relying Party for user login and as an OAuth 2.0 Resource Server by validating access tokens. It wraps the OIDC-Client distribution, registers an oidc helper that creates client instances and callback routes, and supports configuring one or more providers with client id, secret, well-known endpoints, scopes and claim mappings. Typical uses are redirect-to-login authentication flows, verifying JWT access tokens for API endpoints, and performing token exchanges when calling downstream services. It does not implement an OpenID Provider and the documentation recommends keeping session tokens on the backend rather than in client-side cookies. If you are building a Mojolicious application that needs OIDC-based authentication or token validation this plugin provides a practical, configurable integration.

Catalyst::Plugin::OIDC makes it easy to add OpenID Connect sign‑in and OAuth2 token validation to a Catalyst web app by letting your application act as an OpenID Connect Relying Party and an OAuth2 Resource Server that accepts tokens from an external provider; it does not implement an identity provider. The plugin leverages the OIDC::Client library to create and manage client instances at application startup, install callback routes, and expose a per-request $c->oidc helper that drives authentication, identity validation, and token-aware API calls. Configuration supports multiple providers, claim mapping and audience aliases, and the documentation includes example flows for redirect-based login, obtaining a validated identity, and exchanging tokens for calling other services. The authors strongly recommend storing access and refresh tokens on the server side rather than in client cookies for security. Recent updates align the module with OIDC::Client v1.07 and refresh the documentation to match upstream changes.

ExtUtils::XSpp provides XS++ which is a thin preprocessing layer that helps you expose C++ classes and functions to Perl by generating the underlying XS glue code for you. It is driven by .xsp source files or the xspp command and can invoke xsubpp to produce standard XS, supports separate or inline typemap files to control how C++ types convert to Perl values, and can auto-generate object mappings and accessor methods for member variables. XSpp also catches C++ exceptions and translates them into Perl croak errors, supports handling of references, aliases and custom call/return handling via parsed typemaps, and lets you drop in custom XS code where needed. Because it sits on top of plain XS you still need to know C++ and XS/typemaps to use it effectively. If you are binding a C++ library to Perl and want to reduce boilerplate while keeping precise control over type conversions, XSpp is a practical tool.

Netdisco is an open source, web-based network management system that gathers SNMP data into a PostgreSQL database to let administrators discover, map and manage their switched networks. It helps you find a device by MAC or IP and show the exact switch port, change port state, VLAN or PoE settings, build inventory reports by vendor and OS, and produce topology visualizations, all via a built-in web UI and accompanying backend daemon that polls devices. Designed to run on Unix-like servers, it requires Perl and PostgreSQL and works with SNMP-capable switches and routers, offers command-line utilities, a plugin system for customization, and official container images and documentation to simplify installation and upgrades. If you need automated discovery, port-level troubleshooting and centralized hardware inventory for a layer 2/3 network, Netdisco is a mature, community-backed option.

greple is an advanced, configurable grep-like tool written in Perl that lets you search text with the full power of Perl regular expressions while also extracting and formatting matched regions and blocks. It supports multi-line patterns, pattern files, capture-group indexing, custom output formats and colors, callbacks and plugin modules, and can be used as a filter for processing code, logs or other text-heavy data. The tool is aimed at developers and power users who need more flexible region handling and post-processing than standard grep. The recent 10.05 release adds a -P option to search multiple patterns in parallel using child processes and fixes a UTF-8 block-printing performance issue when producing many matches.

Time::Nanos is a tiny, easy-to-use Perl extension that gives you high-resolution timestamps by calling the system clock, exposing simple functions nanos, micros and millis to get time in nanoseconds, microseconds or milliseconds. In scalar context each function returns the total units elapsed since the clock epoch and if you pass a true argument you get a two-element list of seconds and subsecond units. You can choose the clock source via the $Time::Nanos::CLOCK variable, which defaults to realtime but can be set to monotonic when you need reliable elapsed-time measurements that are not affected by NTP or user clock changes. The module is suitable for profiling, building stopwatches, or any task that needs submillisecond timing and the recent 0.1.4 release added the seconds-plus-units return option, an externally settable clock choice, Windows high-resolution timer support and a stopwatch example.

YAML::LibYAML is the Perl wrapper around the libyaml C library, exposed via XS to give fast, standards-aware YAML parsing and generation for Perl programs. It makes it easy to convert Perl data structures to YAML and back with support for anchors, aliases, booleans, regexps and common YAML features and it provides convenient Load, Dump and file helpers. The module is mature and production ready so it is a good choice when performance and fidelity to libyaml matter, and it includes security-minded options such as disabling automatic loading of blessed objects and recent defaults that avoid following cyclic references. Recent releases add experimental object oriented interfaces and improved YAML 1.2 handling along with a new boolean option and various robustness fixes. Note that the CPAN distribution name YAML-LibYAML corresponds to the YAML::XS module so consult YAML::XS documentation for usage examples.

Dezi::App is a lightweight convenience wrapper for building search applications with the Dezi toolkit that pulls together an index, an indexer, an aggregator, and indexing configuration into a single App object. You instantiate it with simple parameters like an invindex directory, an indexer shortcut (for example lucy or test), an aggregator shortcut (fs, spider, mail, or mailfs), a config file or object, and an optional filter coderef, and you can enable test_mode to run only the aggregator without touching the index. Call run(paths) with files or URLs that the aggregator understands and it will return the number of documents actually indexed, and the count method reports the indexer count. This module is useful when you want a quick, configurable way to crawl files or mail and index their contents without wiring Dezi components together by hand. Recent releases improved mail aggregator support with FileRules and FileMatch and better attachment handling, fixed dot-file path parsing and CLI docs, and moved CI to GitHub Actions.