CPANscan

Tree::DAG_Node is a mature Perl class for building and manipulating ordered N-ary trees by treating each node as an object that knows its mother, its ordered daughters, a name, and an arbitrary attributes hashref. You can use it directly to create trees or subclass it to add domain-specific behavior, and it enforces tree invariants so nodes cannot have two mothers or become their own ancestors. The module provides a large toolkit of practical operations including adding and removing daughters, splicing and replacing nodes, traversal via a depth-first walk_down callback, copying subtrees, finding ancestors or common ancestors, converting to and from list-of-lists notations, and pretty ASCII rendering or string serialization for read/write, with attention to utf-8 handling. It also offers delete_tree to break circular references so memory can be reclaimed and utilities for addresses, generations, and leaf queries that make tree processing straightforward. The interface is feature rich so it may feel heavyweight for trivial trees but remains efficient for simple uses, and recent updates include documentation fixes and distribution modernizations such as an updated license bundle and tidy Makefile.PL dependencies in v1.36.

Params::Validate::Strict is a Perl library for rigorously checking and sanitizing named parameters against a declarative schema. You describe each field with types, ranges, regexes, optional/default rules, transformations and custom reusable types, and the module returns a new hashref with validated and coerced values or reports errors when inputs do not match. It also supports nested structures, per-element checks for arrays, union types, cross-field checks and relationship rules like mutually exclusive or dependent parameters, so it fits use cases from API and form validation to feeding test generators or a web application firewall. The API is compatible in spirit with older validators and includes hooks for custom callbacks and logging, and the author provides bug reporting and test coverage links while noting the module is supplied without warranty.

Desktop::KDEActivity::Util provides a tiny, focused set of Perl helpers for working with KDE Activities from scripts and small tools. It exposes functions you can optionally import to read the current activity (by name or GUID), list all known activities, and switch the current activity by name while handling the GUID translation that KDE tools often require. Each function returns an enveloped result as an array with an HTTP-like status code, a human reason string, an optional payload and optional metadata so callers can detect and handle errors cleanly. The functions are simple to use from command line utilities or automation tasks and are exported only on request. The 0.002 release is a small maintenance update that removes some old vestigial code.

OpenAPI::Modern is a Perl helper that validates HTTP requests and responses against OpenAPI v3.0, v3.1 and v3.2 documents and returns a JSON::Schema::Modern::Result describing errors and the deserialized request or response data, so you can check conformance and extract typed parameter and body values easily. It works with common web request/response objects by converting them to Mojolicious messages, provides validate_request and validate_response helpers, can locate the matching path/operation in your spec, follow $ref chains to fetch referenced components, and can optionally populate defaults into the deserialized data. The distribution bundles up-to-date OpenAPI metaschemas and supports media-type decoding, rich parameter styles including query and cookie parsing, and caching-friendly loading for preforked apps. The author notes a few unimplemented areas to be aware of, such as multipart and application/x-www-form-urlencoded encoding and no built-in verification of Authorization headers, but most typical API validation needs are covered. Recent updates include trying to decode message content even when the best-matching media type is "*/*", stricter load-time validation of path and server templates, and removal of some hard dependencies to reduce runtime requirements.

Term::ANSIEncode is a Perl module that turns a simple token-based markup into ANSI escape sequences so you can produce colored, styled and cursor-controlled terminal output without hand-crafting escapes. You write text with tokens such as [% RED %], [% BOLD %], [% LOCATE 10,5 %], BOX/ENDBOX and WRAP/ENDWRAP blocks and the module emits the appropriate sequences, including 24-bit RGB colors and a large set of Unicode symbols when the terminal supports them. The distribution also provides a command-line tool (ansiencode) and options to use an abbreviated symbol table for faster startup or the full table for richer graphics, and recent releases have focused on expanding tokens, improving Unicode and truecolor detection, and speeding up output. If you need portable, tokenized control of colors, cursor movement, simple frames and text wrapping for terminal UIs or ANSI art, this module is a practical choice.

HTTP::Session is a lightweight, PSGI-friendly session manager that provides a simple, pluggable API for storing and managing web session data using interchangeable storage backends (memcached, CHI, file, in-memory, etc.) and state mechanisms (cookies, URI, mobile IDs). It exposes straightforward methods to get, set, remove and enumerate session keys, expire or regenerate session IDs, finalize commits, and apply filters to HTML, redirects and headers before responses are sent. The module supports configurable session-ID generators and cookie options like HttpOnly and SameSite, making it easy to slot into existing Perl web apps, but it is now deprecated in favor of Plack::Middleware::Session and will no longer be maintained. Recent updates hardened session ID generation by using Crypt::URandom for unpredictability and fixed related vulnerabilities, and improved memcached ID validation.

Net::Nostr is a full-featured Perl implementation of the Nostr protocol that provides both a WebSocket client and a relay server plus a rich set of helper modules for identity, event creation, signing and validation. Start with Net::Nostr::Key for identity management and Net::Nostr::Event for building and verifying events, then use the client to connect to relays or run Net::Nostr::Relay to host one. The distribution implements a wide range of NIPs to support direct messages, encrypted payloads, channels, media attachments, wallets and payments, relay discovery and management, lists and filters, remote signing and many other protocol extensions so it is suitable for building clients, bots, relays or integrations in Perl. Recent releases tightened UTF-8 and byte-level handling for event serialization and message parsing to avoid malformed or wide-character JSON, and added improved TLS support including native TLS listeners and exposed TLS client options for secure wss connections.

MIDI::Util is a small collection of practical Perl utilities for working with MIDI and musical data, designed to complement MIDI::Simple and related modules. It helps you set up a MIDI::Simple score with sensible defaults, convert human-friendly note names and durations into MIDI-ready values, inspect internal MIDI mappings, compute ticks and microsecond timing, and turn scores into low-level event lists. It also generates timidity configuration snippets and can drive timidity or fluidsynth to play a score, so it is handy when you need quick playback or to target a specific soundfont. Nothing is exported by default and functions are grabbed as needed, making it useful for scripts that assemble or analyze MIDI without reimplementing common helpers. Recent releases added a scale_names() helper for compatibility with Music::Scales and cleaned up documentation and playback support.

Email::Abuse::Investigator inspects the raw source of a spam or phishing message and automates the routine work abuse investigators do: it walks the Received header chain to find the likely originating IP and owner, extracts and resolves all HTTP/HTTPS links from text and HTML parts, and pulls domain intelligence such as A/MX/NS records, RDAP/WHOIS registrar and registrant details, and flags like recently-registered or expiring domains. You feed it a raw RFC‑2822 message with parse_email() and then call methods like originating_ip(), embedded_urls(), mailto_domains(), abuse_contacts(), risk_assessment(), abuse_report_text() or report() to get curated, human-readable findings and suggested abuse recipients. The module caches lookups per message and optionally across messages via CHI, supports IPv6, can follow common object-store or shortener redirects when LWP::UserAgent is present, and can use Net::DNS, AnyEvent::DNS and Domain::PublicSuffix to improve accuracy and parallelism. It is practical for analysts and automation pipelines but has a few known limits: body text is not charset-converted, the bundled MIME parser is a lightweight implementation that may drop tricky parts, trusted_relays CIDR matching is IPv4 only, WHOIS rate limits are not retried, and the class is not thread-safe. The code is on GitHub and distributed under GPL2.

App::Cme delivers the command line tool "cme" that helps developers and system administrators inspect, validate, edit and manage configuration data using Config::Model models. It provides commands to check and fix configuration problems, edit files interactively or with a UI, dump configuration in YAML/JSON/Perl formats, apply scripted modifications and run small configuration scripts with optional commit support. The tool understands application-specific models and backends so you can work safely with system or application config trees, reuse models across sites, and automate changes with script variables and commit messages. Recent releases have focused on the "cme run" workflow with better script formats support (YAML or Perl), variable substitution, foreach processing and safer commit handling, and the latest update adds extraction of documentation and app metadata from Perl scripts managed by cme run. If you manage structured configuration files or need a consistent, model-driven way to validate and modify system settings, App::Cme is worth a look.

Acrux is a compact Perl utility collection that provides small, opinionated helpers for application development and pairs with Acme::Crux for additional features. It bundles conveniences such as simple prompt and string-formatting utilities, a TTY detection constant, and components for common infrastructure tasks like configuration/log/pid file handling. Recent work added a Damm checkdigit/digest module and a file-locking utility, and the project was relicensed under the Artistic License 2.0. If you want a lightweight set of building blocks to simplify routine app plumbing rather than a full framework, Acrux is worth a look.

PAGI::Tools is the application-side toolkit for the Perl Asynchronous Gateway Interface that makes building PAGI apps far easier by wrapping the raw async $scope/$receive/$send protocol in familiar, high-level building blocks such as request and response objects, routing and endpoint helpers for HTTP, WebSocket and SSE, a middleware suite, test utilities, and composition helpers that let you mount components and coerce apps easily. It is aimed both at people learning PAGI who want less boilerplate and at framework authors who want a ready-made base to build on, and it works with any PAGI server including the reference PAGI-Server. Recent changes split PAGI::Tools into its own distribution and introduce breaking API updates you should note when upgrading: responses are now value objects that are returned from handlers and must be sent explicitly with respond(), request configuration methods were simplified and some behaviors moved into per-call options, and various helpers and header handling were redesigned to be more predictable.

PAGI::Server is a reference Perl HTTP server that implements the PAGI 0.3 application protocol and provides a clear, standards-focused way to serve HTTP/1.1 applications plus WebSocket and Server-Sent Events, with experimental HTTP/2 support. It is designed as the canonical, spec-compliant server rather than a micro-optimized engine, yet includes production-ready features you will care about: multi-worker preforking, Unix domain socket support for proxy workflows, systemd socket activation, hot restart with inherited listening fds, configurable timeouts and limits, file-response streaming, and optional TLS support. The module exposes a rich constructor and runtime options for tuning concurrency, backpressure, body and header limits, and HTTP/2 settings, and it integrates with IO::Async event loops and Future::IO-based libraries when configured. Windows is not supported because the server depends on Unix primitives such as fork and signals. Recent releases split PAGI::Server out into its own distribution, declared PAGI 0.3 conformance, and added robustness and operational features including explicit transport backpressure, lifespan startup controls and timeouts, HTTP/2 rapid-reset mitigation, and various reliability and documentation fixes, making it a strong choice if you need a clear, interoperable PAGI server implementation that works well behind a reverse proxy.

CPAN::Plugin::Sysdeps is a CPAN.pm plugin that helps Perl users and testers install the operating system packages a CPAN distribution needs before building and testing. It maps CPAN modules and distributions to system packages and can invoke the native installer for your platform, for example apt-get on Debian-like systems, pkg on FreeBSD, yum or dnf on Fedora-like systems, homebrew on macOS and Chocolatey on Windows, and it can be forced to use a specific installer or run in batch, interactive or dryrun modes. You can use it inside CPAN.pm or as the standalone cpan-sysdeps script, and you can extend or override its static mapping with custom mapping files. The project works best on FreeBSD and Debian-like Linux and has growing support for other systems including Fedora, macOS, Windows and recently Alpine Linux, with frequent mapping updates to keep package names current. Note that it needs common build tools and the system package manager available, may require sudo or root privileges to install packages, and its static mapping does not cover every platform or package so you should review mappings and test batch installs carefully.

App::GUI::Juliagraph is a desktop GUI tool for exploring, previewing and exporting Julia and Mandelbrot fractals with a high degree of creative control, letting you tweak the iteration formula (up to four monomials), exponents, constants and stop metrics, pick and map colors with fine-grained gradients or stepped palettes, navigate and zoom with the mouse, and save full-resolution images as PNG, JPEG or SVG. The interface shows live low-resolution previews while you adjust parameters and then renders a detailed image on demand, stores your presets and colors in a config file, and is aimed at hobbyists, artists and anyone who wants an interactive way to experiment with complex-plane fractals. Recent development includes a major 0.7 update that rebuilt the drawing engine, added complete mouse navigation and reworked the color-mapping system with subgradients for smoother results, followed by minor fixes in subsequent releases. The program is free software distributed under the GPLv3.

App::GUI::Cellgraph is a desktop GUI that lets you generate decorative and experimental images by running one dimensional cellular automata across a tiled canvas, with each row representing the automata state at the next time step. You control neighborhood size, number of cell states, detailed state and action rules, activity thresholds, symmetry or grouping of rule space to reduce complexity, drawing direction, grid and fill style, cell size and full color palettes, and you can preview changes in real time, save rule sets and color schemes, export the final artwork to PNG, JPEG or SVG, and persist your preferences under ~/.config/cellgraph. The interface exposes 20 editable seed cells, per-subrule result counts to guide tweaking, and a rich set of batch and randomization tools so you can explore both deterministic patterns and serendipitous variations. It is ideal for artists, educators and anyone curious about how simple local rules produce complex patterns, but be aware that very large choices for state count and neighborhood size can produce an enormous number of subrules and may overload the program.

App::GUI::Harmonograph is a Perl/Wx desktop app for interactively generating intricate harmonograph and epicyclic art by simulating four lateral and two rotary oscillators with independent frequencies, amplitudes, damping and phase controls. The GUI exposes rich, hands-on controls and live preview so you can tweak integer or fractional frequency ratios, apply constants like Pi or Phi, swap trig and hyperbolic functions, combine variables in custom expressions and choose between dots or connected lines to sculpt Lissajous, spiral and epicycle patterns. Color flows support up to ten colors with several transition modes and dynamic skewing, and you can render full-resolution images to PNG, JPEG or SVG, save and load settings as INI files, and batch-produce numbered outputs; user preferences are stored under ~/.config/harmonograph. This tool is a practical pick for generative artists, educators and anyone curious about mathematical drawing and visual experimentation, and it is released under the GPLv3 license.

App::MechaCPAN is a lightweight deployment tool that automates installing a specific Perl interpreter and CPAN modules into a self-contained local/ directory so you can ship an app without relying on the system Perl or multiple separate tools. It reads your .perl-version and cpanfile and will honor a Carton-generated cpanfile.snapshot if present, letting you install exact dependency sets, and it can also build a reusable, relocatable Perl archive to reuse across machines. The tool includes optional checksum and signature verification of CPAN releases using external PGP tools, configurable logging and timeouts, and simple commands to install Perl, individual modules, or perform a full deploy. It is designed for deployment scenarios rather than as a full developer replacement for plenv, perlbrew, cpanm, local::lib or Carton, and it will restart the running script when used as a module if the running Perl does not match the one in local/, so be prepared for that behavior.

Matplotlib::Simple is a convenience wrapper that turns Perl data structures into ready-to-run Python3 matplotlib scripts so you can produce common scientific and business plots without writing Python by hand. It accepts hashes or arrays of data and can generate single plots or multi-panel figures including bar, barh, boxplot, hexbin, hist, hist2d, imshow, pie, plot, scatter, violin and colored table visualizations, with options for grouping, stacking, error bars, color maps, shared colorbars and axis tuning. The module writes the generated Python script to a temporary file for inspection or editing and can execute it for you, which makes it easy to iterate while keeping full access to matplotlib features. It is cross-platform, discovers an appropriate Python 3 interpreter, and aims to simplify common plotting tasks compared with using matplotlib directly. You do need a working Python 3 and matplotlib installation for it to run.

Data::Identifier is a lightweight, format-agnostic wrapper for handling identifiers that keeps both a raw value and its type and gives a common API to parse, normalize, compare and convert them. It understands many well known kinds such as UUID, OID, URI, GTIN, IBAN, BIC, DOI and several application-specific small identifier families, can generate random identifiers via pluggable sources, and can convert identifiers into other objects or representations with as(). The module offers equality and ordering, optional validation, basic normalization and deduplication with a register mechanism to cache hot identifiers, and utilities for namespaces, generators, display names and tagnames. Validation is conservative for performance so it may accept some invalid values and normalization can change the exact string you pass in. Recent updates improved display metadata generation, added ISBN URN normalization and a small is_null helper, and there is an option to disable OID support if you need to trim overhead.

Cucumber::Messages is a Perl library that implements the Cucumber messages protocol so Perl tools can produce, consume and manipulate the same NDJSON message streams used across the Cucumber ecosystem. It provides an in-memory representation and JSON serialization helpers for the protocol's many message types, from core containers like Envelope, Pickle and TestCase to supporting objects such as Attachment, ExternalAttachment, Timestamp and Duration, letting formatters, runners and reporters read or emit standardized test events. You can deserialize a stream into Envelope objects with Envelope->from_json, inspect or build messages in Perl and then serialize them back to NDJSON for other tools to consume. The project follows the upstream Cucumber messages schema and is MIT licensed, and recent protocol work added ExternalAttachment to reference large files externally while deprecating the old Attachment.url field so consumers can avoid embedding big blobs in the stream. If you need to integrate Perl test tooling with Cucumber-compatible reporters or to process NDJSON test event streams, this module gives you the protocol classes and serialization you need.

Thunderhorse is a modern, async-ready Perl web framework built specifically around the PAGI protocol that aims to be lightweight, extensible and easy to reuse. It provides a fast, cache-friendly router with flexible placeholders, bridges for shared pre-processing, and action-based routing that cleanly separates HTTP, SSE and WebSocket handlers. Applications are organized with persistent controllers, pluggable modules for logging, templating and middleware, and a smart configuration system that merges environment-specific settings. You assemble apps with a simple application class and run them under a PAGI server, or mount native PAGI apps and wrap handlers in PAGI middleware when needed. The distribution includes a command line utility to generate project skeletons and inspect routes and configuration. Thunderhorse uses modern Perl 5.40 syntax and a modest set of dependencies to keep the core small and performant, and it exposes hooks and overridable methods so you can customize lifecycle events and error handling. The project is currently in beta so interfaces may change before a 1.000 release.

Tree::RB::XS is a high-performance C implementation of a Red/Black tree for Perl that gives you a sorted key/value store with rich, practical features for real applications. It supports fast lookups, O(log N) access to the Nth element so the tree can act like an ordered array, smart bi-directional iterators that survive deletions, optional duplicate keys with preserved insertion order, case-folded comparisons, and a built-in insertion-order list to implement LRU or MRU caches. The module ships several optimized comparison modes (integers, floats, byte or UTF-8 strings, and a natural numeric-split comparator) and also accepts custom coderefs when needed. It provides bulk operations, range deletes, rekeying, a tie-hash interface, and iterator methods that return batches to reduce loop overhead, making it a good choice for ordered indexes, caches, and range queries where predictable performance matters. Recent releases made node objects persist once created so you can hold weak references to them, and added conveniences like automatic recent-list truncation and rekeying.

BATsh is a pure-Perl bilingual shell that lets a single script contain both Windows CMD batch syntax and POSIX-style sh/bash syntax and run them interchangeably without invoking external shells. It detects CMD versus SH mode per line, shares a common variable store so values set in one mode are immediately visible in the other, and implements common features such as pipelines, redirection, functions, parameter handling, control structures and many builtins so you can write mixed-mode scripts or translate shell idioms across platforms. The module is self-contained apart from calling any external programs the host OS provides and works on very old Perls back to 5.005_03 using only core modules. Recent 0.06 work is notable because full indexed and associative arrays are now supported in SH mode along with improved CALL/SHIFT behavior and enhanced case and trap handling, making bash-style scripts much closer to real bash. Do note that BATsh does not reimplement every external utility so commands like FINDSTR or SORT are executed via the system shell if present and some advanced shell features remain unimplemented such as tilde or brace expansion, here-strings, process substitution and certain shell options and builtins, so it is best suited when you need portable, mixed CMD/SH scripting and testing rather than a drop-in replacement for every shell quirk.

PAGI is a modern specification for building asynchronous web applications in Perl and a direct successor to PSGI designed to handle long‑lived protocols like WebSocket and Server‑Sent Events as well as traditional HTTP. It defines a simple, async message-based application interface where your app is an async coderef that receives a scope describing the connection and two async callbacks for receiving and sending events, with explicit backpressure via Futures so streaming and background work are practical. PAGI is the specification only and is intentionally split from the reference server and the application toolkit which now live in the PAGI::Server and PAGI::Tools distributions, though the PAGI distribution still pulls them in temporarily for compatibility. The specification is stable while the reference server and toolkit are considered beta and are recommended to run behind a reverse proxy in production until they are more battle tested. The project ships extensive learning material including a tutorial, cookbook, and migration guide from PSGI and recent changes reorganize the distribution into pure spec POD, add connection metadata flags like response_started and response_complete, document middleware scope cloning semantics, and shift header byte-safety enforcement to the server. If you need to write async-capable Perl web apps that stream, push events, or maintain persistent connections, PAGI is the place to start and you can try it quickly by installing PAGI::Server and PAGI::Tools and running pagi-server.

Store::Indexed is a lightweight, high-performance Perl data store that maps integer row IDs to a fixed set of named columns. You create it by listing the column names and it automatically generates get_key, set_key, exists_key and delete_key methods so you can read and write values by row and column without hand-rolling accessors. The module provides a fast C-based XS backend with a portable Pure-Perl fallback and you can force one or the other with the STORE_BACKEND environment variable. It keeps data in a compact flat-array layout for speed and is a good choice when you need simple, columnar storage with very fast random access across many integer-indexed records.

Music::VoicePhrase is a small Perl helper for algorithmic composition that builds measured phrases of multiple voices with both pitch and rhythm. It combines scale and interval selection from Music::Scales and Music::VoiceGen with rhythmic partitions from Music::Duration::Partition so you can generate motifs and matching voices for a measure-length phrase using simple attributes like base note, scale, octave, measure size, duration pool and motif count. The object exposes handy real-time attributes such as a priority queue, an index, current note and onsets so it can be used in live or streaming contexts. If you need to programmatically create short melodic phrases or drive MIDI/playback scripts, this module gives a lightweight, configurable building block for that work. Recent updates added the real-time-friendly attributes and voice handling to make live use easier.

App::PerlGzipScript is a small command line utility that compresses Perl scripts to reduce their file size, making them easier to distribute and faster to transfer or store. You run it with the perl-gzip-script command and redirect the compressed output to a new file, and in practice it can yield large reductions, for example shrinking the cpm script from 731KB to 189KB. The project includes GitHub artifact attestations for release tarballs if you care about provenance, and it is freely redistributable under the same license terms as Perl.