CPANscan

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::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.

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.

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.

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.

Map::Tube::Napoli is a Perl module that lets developers compute the shortest routes between metro, tram, and funicular stations in Naples. It implements the Map::Tube role and exposes routing methods such as get_shortest_route, making it easy to query the Naples transit network from scripts and small applications. By default it uses an included XML map file but you can supply an alternative XML source via an xml code reference when constructing the object. If the map data are corrupted the constructor will die. The map data were gathered from public transit websites and the module is distributed under the same terms as Perl. Report bugs or feature requests on the project's GitHub page.

Map::Tube::Lyon is a simple Perl interface for computing shortest journeys across Lyon's public transport network including metro lines, funiculars and tramways. It implements the Map::Tube role so you can use familiar methods like get_shortest_route to find routes between named stations, and it ships with an XML map of Lyon while also accepting an optional code reference to supply an alternative XML source if you need to update or replace the map data. The constructor will die if the map information is missing or corrupted. The underlying map data were sourced from the French Wikipedia under CC BY-SA and the module itself is distributed under Perl's license. This module is useful for building small transit tools, scripts or research prototypes, and bugs or feature requests can be reported via the project's GitHub page.

Map::Tube::Hamburg provides a simple way to compute shortest routes between stations in the greater Hamburg rail network, covering U-Bahn, S-Bahn and the AKN line. It implements the Map::Tube role so you can call familiar methods such as get_shortest_route after creating an object with Map::Tube::Hamburg->new. The constructor accepts an optional xml code reference to supply a custom map file or XML content, otherwise it uses the bundled hamburg-map.xml, and it will die if the map file appears corrupted. Map data were derived mainly from OpenStreetMap under CC BY-SA 2.0 and the module itself is licensed under the same terms as Perl. Recent updates moved the repository and issue tracker to GitHub and replaced deprecated code signing with Sigstore/cosign while improving the build script.

Map::Tube::Glasgow provides a simple Perl interface to the Glasgow Subway map so you can query and compute the shortest route between any two Glasgow stations. It implements the Map::Tube role and ships with an XML map file by default, while the constructor also accepts an optional code reference to supply alternate XML content. The module acts as a lightweight data adapter that enables Map::Tube's route-finding features for Glasgow stations and will die at construction if the map file is corrupted. The map data come from a Wikipedia source under CC BY-SA and the module is distributed under the same terms as Perl. Recent maintenance moved the code and issue tracking to GitHub, replaced deprecated code signing with Sigstore/cosign, and updated packaging and dependency requirements to match newer Map::Tube and Perl versions.

IO::Socket::SSL is a widely used Perl module that brings SSL/TLS into your socket code by wrapping OpenSSL (via Net::SSLeay) behind the familiar IO::Socket API, so you can make secure clients and servers with minimal changes. It provides sensible, security-minded defaults for protocol versions and ciphers, does hostname verification and SNI automatically, supports OCSP stapling, ALPN/NPN, TLS 1.3 features, PSK, certificate pinning by fingerprint, session caching and many advanced hooks for fine control, and it can upgrade plain sockets for STARTTLS-style workflows. Because TLS has tricky behaviors, the module documents important differences for non‑blocking I/O, select/poll-based event loops and thread interactions and offers helpers such as pending(), $SSL_ERROR and start_SSL/stop_SSL to manage them. Recent releases fixed layering and upgrade edge cases and restored the old behavior of closing sockets on failed handshakes created with new while leaving upgraded sockets open on start_SSL. If you need robust, configurable TLS support in Perl code that works like regular sockets, IO::Socket::SSL is the right choice.

JSON::JSONFold reformats pretty-printed JSON into a more compact yet still readable layout by folding arrays, objects and simple nested structures to reduce unnecessary vertical space. It offers a functional API, an object-oriented formatter, a streaming writer for incremental post-processing, and drop-in replacements for JSON::encode_json and JSON::to_json, so you can use it wherever you already produce JSON. You can control the target line width, choose presets or per-call overrides, tweak indentation and key sorting, and plug in a custom JSON encoder when needed. The streaming writer accepts pretty JSON chunks and writes folded output without buffering the whole document, and write operations return simple formatting statistics. JSON::JSONFold is useful when you want human-friendly JSON that takes fewer lines while staying clear and easy to scan.

Map::Tube::Brussels provides a simple Perl interface to find shortest routes on the Brussels metro system by reusing the common Map::Tube routing role and a bundled brussels-map.xml data file. You create an object, optionally choose Dutch rather than the default French station names with nametype => 'alt', and call the familiar Map::Tube methods to compute and format routes between stations. The module is useful if you need programmatic routing or human-readable directions for Brussels specifically and it ships with verified station and line data drawn from Wikipedia and OpenStreetMap. The constructor will die if the map file is corrupted and the author notes occasional minor source discrepancies that need verification. The code is free software under the same terms as Perl and recent maintenance moved the project to GitHub and updated signing and packaging practices.

CPAN::MetaPackager is a small utility for turning CPAN's package index into a local, queryable SQLite database named cpan.metapackager.sqlite, so you can import the 02packages.details.txt.gz file and work with CPAN metadata offline or in automated workflows. It is aimed at developers and maintainers who need machine-readable package information or who want to generate and manage changelogs programmatically. The module provides import/populate routines and records timing information during import, and its changelog was converted to a machine-friendly Changelog.ini format. The project is maintained on GitHub by Ron Savage, is released under the Perl 5 license, and recent updates (1.04) refreshed the instructions and rebuilt the database from a new 02packages.details.txt.gz.

CPAN::MetaCurator is a toolkit for building and maintaining a curated SQLite database of CPAN metadata and Perl Wiki content and for turning that data into browsable web trees and exports. It ingests CPAN package lists and Perl Wiki tiddlers into cpan.metacurator.sqlite, offers scripts to rebuild and validate the data, and can export the curated information as HTML, CSV and jsTree-friendly structures so you can produce clickable, searchable module catalogs and topic trees for a website. The distribution also includes search and validation helpers, support for optionally reading a CPAN::MetaPackager database, and utilities to collect statistics and generate module tables. Recent work focuses on producing an explicit tree structure before rendering, now using Tree::DAG_Node, plus improved export parsing and HTML-escaping to make generated links safer and easier to use. If you maintain a CPAN-related index, documentation site, or want a programmatic way to turn Perl Wiki and CPAN data into a navigable tree, this module provides a practical, scriptable foundation.

HTML::Composer is a Perl library that lets you build validated HTML from plain Perl arrays and hashes using a concise, data-driven syntax inspired by TyXML and Hiccup. You describe elements, attributes and content as nested Perl data structures and the module renders a complete HTML document or a single partial, automatically handling tags, attributes, escaping and a DOCTYPE. It can produce raw unescaped fragments via an unsafe wrapper when you need to inject prebuilt script or markup, and it can optionally cache generated templates for better performance. The builder croaks on validation errors so you get immediate feedback, making it a good fit for web apps, static page generators, testing tools or any code that needs a clear, programmatic way to produce correct HTML.

SPVM::File::Spec is a lightweight port of Perl's File::Spec that gives SPVM programs a portable, platform-aware way to build, split, normalize and convert file paths. It exposes familiar class methods such as catfile, catdir, join, splitpath, splitdir, canonpath, abs2rel, rel2abs and helpers like tmpdir, rootdir and devnull, and each method simply forwards to a singleton File::Spec::Instance so the platform specific behavior is handled by instance implementations for Unix or Win32. Use this module when you need to manipulate file names without hardcoding path separators or platform conventions. See the File::Spec::Instance implementations or the project repository for platform details and source.

SPVM::Compress::Raw::Zlib is a low-level SPVM wrapper around the zlib compression library that gives SPVM programs direct access to Deflate and Inflate operations and zlib constants. It provides classes for streaming or in-memory compression and decompression and adds convenient gzip and gunzip static methods that compress and uncompress strings while handling common options like AppendOutput and WindowBits for you. This module is useful when you need efficient, controllable zlib behavior from SPVM code rather than a high-level abstraction. It is actively maintained on GitHub under the MIT license and recent releases added gzip/gunzip and the AppendOutput option and improved Windows/MSVC support and builds so it works well on modern SPVM environments.