CPANscan

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.

Map::Tube::Plugin::FuzzyFind is a lightweight add-on for Map::Tube that helps you find stations and lines by partial, misspelt, or phonetically similar names. It plugs into Map::Tube as a Moo role and provides a fuzzy_find method that accepts strings or regexes and searches lines, stations, or both using many matching strategies such as exact, prefix, substring, regex, phonetic encodings (Soundex, Phonix, Koeln, Metaphone, DoubleMetaphone, Daitch‑Motokoff), edit distances (Levenshtein, Damerau, Jaro‑Winkler) and trigram similarity. You can get either a ranked list of matches or a single best match and control behaviour with options like maxdist, maxsize and maxcodelen for Metaphone. Recent releases added several new algorithms, hardened behavior so unknown methods now croak, set Metaphone to a 4 character default that you can override, and moved the project to GitHub with updated tests and packaging. This module is a good fit if you use Map::Tube and want robust, flexible name matching for fuzzy, phonetic or approximate searches.

Config::Model::LcdProc is a Perl module that makes it easy to view, validate and safely edit the LcdProc daemon configuration file (/etc/LCDd.conf) using the Config::Model framework and the cme tool. You can launch a graphical editor, run sanity checks, or apply automatic fixes from the command line, and you can also call the module from Perl code to programmatically read, validate and modify LCDd settings. The distribution ships generated models matched to LCDd configuration syntax and is kept in step with Config::Model changes and newer lcdproc specifications, so recent releases require up-to-date Config::Model components. It is open source under the LGPL and is a practical choice for system administrators or developers who need reliable, validated management of LcdProc configuration.

Map::Tube::Toulouse provides a simple Perl interface for computing shortest routes between stations in Toulouse's metro, tram, and cable car network. It implements the Map::Tube role so you create a Map::Tube::Toulouse object and call methods like get_shortest_route to obtain route information. The constructor accepts an optional xml code reference to supply a custom map, but by default it uses the included toulouse-map.xml derived from Wikipedia. If the map file is corrupted the constructor will die. This module is a handy, lightweight choice for developers building routing, mapping, or transit utilities for Toulouse and is distributed under the same terms as Perl.

Map::Tube::SanFrancisco is a lightweight Perl module that models San Francisco rapid transit, trams and cable cars and lets you compute the shortest route between any two stations. It implements the Map::Tube role so you get familiar route-finding methods such as get_shortest_route, and it ships with an XML map of the network while also allowing you to provide your own XML source via a code reference at construction. The module is useful for small route-planning tasks, testing, or embedding a static city transit graph in scripts or services and will die if the map file is corrupted. Data for the map were assembled from Wikipedia, BART, SFMTA and OpenStreetMap and the code is free to redistribute under the same terms as Perl. Recent updates raise the required Map::Tube dependency to 4.09 and require Perl 5.14, and the test suite was adjusted to handle Unicode output more robustly.

Map::Tube::Stockholm lets you find the shortest routes between subway and tram stations in Stockholm with a simple Perl interface. It implements the Map::Tube role so you get the standard routing methods and you create an object with an optional xml argument to point to a custom map file or XML string, otherwise it uses the bundled stockholm-map.xml. If you want to generate network diagrams, be aware of a known interaction with GraphViz2 and Swedish station names; upgrading GraphViz2 to at least 0.48 or supplying a small callback to generate node ids avoids the issue. The constructor will die if the map data are corrupted, bugs can be reported on the module GitHub page, and the underlying map data were sourced from tunnelbanakarta.se. The module is free software and licensed under the same terms as Perl.

GnuPG::Interface is an object-oriented Perl wrapper for the GnuPG command line that makes it easy to perform encryption, decryption, signing, verification, and key listing from Perl by spawning a gpg process and wiring up stdin, stdout, stderr, status, logger, and passphrase handles. It delegates option management to GnuPG::Options and handle management to GnuPG::Handles and uses Moo-generated accessors so list fields get convenient push/pop helpers. The module does not hide the underlying bidirectional IPC model, so you should be comfortable with perlipc/IPC::Open3 style interaction when feeding or reading data, which gives you flexible, low-level control instead of a heavy abstraction. It can parse gpg's machine-readable key output into GnuPG::PublicKey and GnuPG::SecretKey objects and provides a wrap_call method for arbitrary gpg commands. Recent updates keep tests passing on newer GnuPG releases and fix behavior under mod_perl. Be aware of a few known limitations noted by the author, such as buffering issues when sending very large data streams and uncertain handling of older OpenPGP v3 keys, but for most scripted uses that need direct, programmatic control of gpg this module is a solid choice.

Map::Tube::Oslo is a compact Perl module for finding the shortest tram and metro routes in Oslo. It provides the route-finding methods defined by the Map::Tube role so you can call functions like get_shortest_route and either use the included oslo-map.xml or supply your own XML map via an optional code reference when creating the object. If the map data are corrupted the constructor will die so invalid XML will surface as an immediate error. The module uses route data taken from ruter.no and vy.no and is distributed under the same license terms as Perl, with bug reports handled through the project GitHub issues page.