CPANscan

DBIx::Auto::Migrate is a small Perl helper that wraps DBI connections and automatically applies schema migrations defined in your code, making it easy for server or desktop programs to upgrade their database at runtime. You create a simple database wrapper package that provides a migrations list of SQL statements plus basic connection subs like dsn, user, pass and an optional extra for DBI options, then call finish_auto_migrate to enable the feature. The module exposes connect and connect_cached methods that mirror DBI but take no arguments. Migrations are plain SQL statements and the first migration must create an options table that the module uses to track the current migration number. Migrations only run forward so be careful when changing them. The author designed it to work with multiple engines such as PostgreSQL and SQLite, but full cross-database guarantees are not promised and more testing is needed.

GitHub::RSS is a small helper that periodically syncs GitHub issues and their comments into a local database so you can build RSS feeds or otherwise query a stable cache of issue activity. It connects to GitHub using an API token that can be supplied directly or read from a JSON token file and stores fetched data via a DBI handle, so you can use SQLite or another supported database. The module tracks the time of the last stored update and provides methods to fetch and store all issues or only those changed since the last check, with options to catch up by fetching extra pages of historical data. If you need to turn GitHub issue activity into an RSS feed or keep a local copy of issue history for reporting, this module handles the synchronization and storage details for you.

Object::Configure is a lightweight Perl utility that makes it easy to inject runtime configuration and logging into your classes so you can tune behavior without changing code. It merges settings from class-specific files, parent-class files and an optional universal section, accepts environment-variable overrides, and will construct a Log::Abstraction logger for you if needed, so you can control logging per-module at runtime. It also provides instantiate to wrap third-party classes and a hot-reload system that can watch config files and push updates into registered objects on Unix systems by forking a watcher and signaling the parent process. The module is ideal when you want fine-grained, outside-the-code control of timeouts, retries, and logging, but be aware it uses global registry state, hot reload is not supported on Windows, the configure function is large, and its internal deep-merge replaces arrays rather than merging them.

DBIO::DuckDB is a small DBIO component that plugs DuckDB-specific storage and schema management into DBIO-based applications. When loaded into a DBIO::Schema class it makes the schema use DBIO::DuckDB::Storage so your app gets direct access to DuckDB features like the Appender API for fast bulk inserts, Arrow-style columnar fetches, and table-function helpers to read CSV, Parquet, or JSON files. It builds on DBD::DuckDB, a pure-FFI DBI driver that requires libduckdb at runtime, so you keep DBI conveniences such as transactions and result sets while gaining DuckDB’s embedded, columnar analytics capabilities. Schema install, diff and upgrade are handled by a test-deploy-and-compare flow via DBIO::DuckDB::Deploy, and the included tests use in-memory DuckDB databases for easy local verification. Use this module if you already use DBIO and want to leverage DuckDB’s performance and IO features without rewriting your ORM layer.

PDF::Make is a self-contained Perl PDF toolkit built on a pure C engine (libpdfmake) that implements its own compression, encryption, font handling, and image decoding so it has no external runtime dependencies aside from Object::Proto for the high-level API. It offers two layers: a chainable, user-friendly PDF::Make::Builder for rapid document creation with automatic layout, word wrap, and font metrics, and a low-level XS API (Document, Page, Canvas, etc.) when you need direct control over PDF objects and content streams. The distribution also includes parsing and extraction tools, font and image embedding, interactive forms and fields, link actions, digital signatures, redaction and sanitisation, layers, attachments, and output features like linearization. Choose PDF::Make if you want a feature-rich, dependency-light solution for generating, editing, and reading PDFs from Perl, with both high-level convenience and low-level control.

App::karr is the engine behind karr, a Git-native kanban tool that keeps task cards and board configuration inside Git refs so your repository remains the single source of truth. The karr command line lets you create, list, move, and inspect cards that are ordinary Markdown files with YAML frontmatter stored under refs/karr/*, and each command materializes a temporary board view and writes changes back into refs to avoid adding persistent board trees or causing file-level merge conflicts. It is aimed at teams that prefer to manage task state alongside their code, and it includes features like numeric id allocation, append-style activity logs, and sparse YAML configuration layered over sane defaults. You can run karr from a provided Docker image or directly from a Perl install, and the distribution also exposes lower-level modules so automation scripts can load, snapshot, create, and push tasks programmatically. If you want a lightweight kanban workflow that is tightly integrated with Git rather than with external services, App::karr and the karr CLI are likely relevant to your workflow.

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.