CPANscan

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.

App::KBLIUtils is a small toolkit for working with Indonesian KBLI codes (Klasifikasi Baku Lapangan Usaha Indonesia), providing command line utilities and library routines to look up titles and descriptions for the 2020 and 2025 KBLI releases, list codes, and compare mappings between the two versions. The distribution exposes a set of CLIs such as get-kbli-2020-title, get-kbli-2025-description, list-kbli-2020-codes and compare-kbli-2020-2025-codes for quick scripting and automation, while the underlying functions return programmatic, HTTP-like enveloped results with status, reason and payload for integration into Perl programs. It is handy for developers, data analysts and anyone who needs to validate, transform or report on Indonesian industry classification codes. The recent 0.003 release consolidated the command line tools into version-specific names and added the title/description and comparison commands. Source and documentation are available on CPAN and GitHub.

TableDataBundle::Business::ID::KBLI is a CPAN distribution that provides ready-made Perl table datasets for Indonesia's KBLI business classification, bundling modules for the 2020 categories and the 2020 and 2025 code lists. It is meant for developers who need a reliable, program-friendly source of KBLI codes for tasks such as validating business activity data, normalizing or mapping activity descriptions, building forms or APIs that require standard codes, and producing reports. The datasets are delivered as TableData:: modules so they integrate easily with code that consumes table-style data. The package is free software available on CPAN with source on GitHub and is useful whenever you need an authoritative, versioned KBLI lookup inside a Perl application.

SPVM::Go brings the Go language style of concurrency to SPVM, providing a Go class that lets you spawn lightweight goroutines, create buffered or unbuffered channels, perform select-style multiplexing, and coordinate work with wait groups, timers and contexts. It exposes scheduler primitives to yield and to block on IO with optional timeouts, plus sleep helpers and signal utilities, and ships companion modules such as Go::Channel, Go::Select, Go::Sync::WaitGroup, Go::Time and Go::Context. The implementation builds on coroutines so you can use familiar Go patterns inside SPVM programs, and note that some scheduler operations must be invoked from the main thread. Development and examples are on the project GitHub and runtime debugging can be toggled with the SPVM_GO_DEBUG environment variable.

Plerd is a tiny static-blog engine that turns Markdown files kept in a Dropbox-synced directory into a complete web site and feeds, making it easy to write and maintain a blog from plain files. You configure a few basics like the content path, blog title, base URI, and author info, provide templates, and Plerd renders post pages, recent and archive listings, tag indexes, and syndication feeds without a database or heavy stack. It supports tags, social-media metadata (now emitting Open Graph tags for better link previews), optional webmention handling, JSON Feed and Atom/RSS, and a watcher that performs incremental publishes so changes scale well as your archive grows. Recent releases also ensure atomic writes so your web server never sees half-written files, normalize Windows line endings, and make filenames robust for titles with unusual characters. If you want a minimal, file-first blog workflow that integrates with Dropbox and emphasizes simplicity and predictable static output, Plerd is a good fit.

App::Test::Generator is a toolkit for automatically generating robust black‑box tests for Perl code by turning a concise input/output schema into ready‑to‑run Test::Most fuzz and property tests. You give it a YAML or Perl schema that describes parameter types, constraints and expected outputs and it emits .t harnesses that combine randomized fuzzing, deterministic boundary cases, optional static corpora and Test::LectroTest property checks, with support for semantic generators (email, uuid, url, ipv4/6, semver, json, etc.), transforms that express input→output relationships, and Return::Set/Params::Validate style validation. It also integrates with mutation testing and LCSAJ coverage to drive a feedback loop that writes TODO stubs or runnable augmented schemas for surviving mutants so CI can iteratively kill regressions, and it includes scripts and a dashboard workflow to run scheduled fuzzing on GitHub Actions. You can run it from the CLI (fuzz-harness-generator, extract-schemas, test-generator-index, generate-test-dashboard) or call App::Test::Generator->generate() from Perl, and control reproducibility with seed and iterations plus many configuration knobs for edge cases and timeouts. If you publish CPAN modules or maintain critical Perl code and want to broaden test coverage beyond hand‑written unit tests, this suite delivers automated fuzzing, property testing, and mutation‑guided test generation to uncover boundary errors and regressions. The recent 0.40 release focused on hardening the CI and mutation pipeline, fixing a long list of cross‑platform and correctness bugs so dashboards, per‑mutant reporting, and schema extraction behave more reliably on CI and Windows.

Map::Tube::RheinRuhr is a small Perl module that makes it easy to find routes on the public transit network in Germany's Rhein/Ruhr region, covering Dusseldorf, the Ruhr area and nearby cities. It loads a bundled XML map and, by using the common Map::Tube role, provides handy methods such as get_shortest_route to compute the best connection between two stations. You can supply your own XML source at construction time if you need a custom map. The constructor will fail if the map data are corrupted. The map content was gathered from operators' websites and the module is free software under the same terms as Perl. Recent maintenance moved the project to GitHub and replaced deprecated cpansign signatures with Sigstore/cosign, and the distribution now requires newer Map::Tube and Perl versions.

XML::PugiXML is a Perl binding for the pugixml C++ XML parser that gives you a fast, memory-efficient DOM API with full XPath support and convenient read/write functions. It expects UTF-8 input and produces UTF-8 output and offers parsing options to include or skip comments, CDATA, processing instructions, DOCTYPE and whitespace nodes. You can load or save files, serialize to strings with formatting flags, navigate and modify the tree, clone nodes and attributes, and compile XPath expressions for repeated use. Node and attribute handles keep the underlying document alive so you can hold onto handles even after the document variable goes out of scope. The parser does not process external entities and does not expand user-defined internal entities, so it is safe against common XXE and entity-expansion attacks by default. Benchmarks included by the author show substantial speed gains over XML::LibXML for parsing, traversal and modification. Be aware that concurrent access to the same document is not thread safe and that parse failures return false and set $@ while XPath syntax errors raise exceptions.

Alien::pugixml is an Alien::Base wrapper that makes the pugixml C++ XML parser available to Perl builds by either locating a system installation or downloading and compiling the library from source. It exposes the standard Alien methods and supplies cflags and libs for ExtUtils::MakeMaker or other build tools so XS modules can easily link against pugixml, and it will use pkg-config when available to detect system installs. The current release updates the source build to pugixml 1.16 and treats system pugixml versions 1.8 and newer as acceptable. This module is a good fit when your Perl extension or application depends on pugixml but you want installs to work without manual library setup, and it is distributed under the same license terms as Perl.

Zuzu is a tiny Perl helper for running ZuzuScript code from Perl. It exposes zuzu_eval for parsing and evaluating a ZuzuScript source string and zuzu_evalfile for loading a UTF-8 script file and evaluating it. Both accept runtime options like module denial lists and library paths so you can restrict or extend the script environment. Use this module to embed quick one-off evaluations, run or test Zuzu scripts from Perl, or glue Zuzu modules into a Perl workflow. It is free software distributed under the Artistic License 1.0 or the GNU GPL v2.