CPANscan

SIRTX::Font is a Perl library for reading, writing and manipulating SIRTX bitmap font files and related bitmap formats. It gives you a font object to inspect and edit glyphs and codepoint mappings, tweak font metadata like size, baseline and version, import fonts from SIRTX, PSF and Roman .hex sources, generate simple missing glyphs, deduplicate unused glyphs with garbage collection and export alias maps or images of glyphs. The module also ships named character lists (ASCII, DEC sets, CP437/850/858 and an SIRTX-specific list) and utilities to test, strip or fill codepoints against those lists, which makes it useful for preparing terminal or legacy bitmap fonts. Recent v0.08 work added unified import_font/export_font APIs, a new SIRTX::Font::Renderer with proportional rendering and size calculation, basic glyph attributes and support for exporting .hex, while some older methods such as import_psf, import_hex and the built in render() are now deprecated. Be aware many utilities are marked experimental, methods will die on error, and glyph attributes cannot yet be stored to font files in this release.

HTML::Object is a comprehensive Perl toolkit for parsing, querying and modifying HTML that aims to be fast and safe by only changing the parts of a document you edit instead of rebuilding and re-encoding the entire tree. It ships three usage layers: a lightweight Element API, a full Web API compatible DOM implementation so you can script HTML much like browser JavaScript, and an XQuery layer that offers a jQuery-like interface for convenient DOM manipulation. The parser accepts strings, files, globs or URLs, supports utf8 handling, exposes utilities to create, traverse and replace nodes, and relies on an external JSON tag dictionary to stay aligned with HTML semantics. If you need to fetch remote pages the module returns the HTTP::Response for inspection and it can be configured to provide a global DOM or enable xquery-style shortcuts. The recent 0.6.2 release made no API changes but fixed a bug in XQuery removeClass, switched to DateTime::Lite by default, updated dependencies and improved the documentation.

Sieve::Generator is a small Perl library that helps you build correct, nicely formatted Sieve (RFC 5228) email filter scripts programmatically by composing a tree of objects that each render themselves via an as_sieve method. It is aimed at any developer who needs to generate or assemble Sieve programs from reusable pieces rather than hand-writing strings, and it provides a friendly sugar layer Sieve::Generator::Sugar with short constructor functions so you can write filter logic tersely and readably. The module makes it easy to cut up and stitch together subtrees, produces properly indented output, and supports commands, blocks, heredocs, comments, and now numeric literals and negation helpers. The recent 0.003 release introduced a common Element role, made documents immutable, added bracket-style comments and improved command and heredoc handling, and added sugar for number and negate to simplify authoring. If you need to generate Sieve scripts from code, this module gives you a clear, composable API to do it, though you should note it does not promise a fixed future minimum Perl version.

Asm::X86 is a Perl utility for working with x86 assembly mnemonics and operands that can tell you whether a string is a valid register or instruction, validate 16/32/64-bit addressing modes in Intel or AT&T syntax, and convert addresses or whole instructions between the two syntaxes. The module exposes a large set of optional exportable lists and predicates for different register sizes and types so you can build linters, assemblers, transpilers, disassemblers, or any tool that needs to recognize or normalize x86 assembly. Most routines work best on input that has already been preprocessed so macros and constants are expanded. The 0.73 release updated the instruction list to match NASM 3.02 and includes some build-system refinements.

Syntax::Infix::EqualityInsensitive adds two lexical infix operators, eqi and nei, for clear, readable case-insensitive string comparisons that honor full Unicode case-folding. They sit at the same precedence as eq and ne and are non-associative, so you can write conditionals like a simple equality test without calling fc or using regex /i, and they handle tricky cases such as the German sharp-s correctly. The operators are active only in the lexical scope that uses the module and can be turned off with no Syntax::Infix::EqualityInsensitive, and the implementation uses Perl's Unicode folding routines for correctness. Note that the module relies on Perl 5.38 or newer.

MsgPack::Raw provides lightweight Perl bindings to the MessagePack C library so you can efficiently serialize and deserialize Perl data into MessagePack's compact binary format for fast storage or cross-language exchange. It exposes simple Packer and Unpacker objects plus helpers for extension types and booleans, letting you pack Perl structures into a small binary blob and stream them back out again with minimal overhead. This module is aimed at developers who need a low-level, high-performance serializer that is smaller and faster than JSON while remaining language-agnostic. It supports older Perl releases and has an active maintenance history, with the most recent release fixing a buffer overflow in the Unpacker for improved stability and safety.

Business::ISBN::Data is a data-only companion for Business::ISBN that supplies the official ISBN group and publisher ranges used to validate and parse ISBNs, and it is normally loaded automatically by Business::ISBN. The module ships a copy of the ISBN Agency RangeMessage.xml and also embeds a default dataset so your code can work offline, and you can point to a different RangeMessage.xml at runtime with the ISBN_RANGE_MESSAGE environment variable or place it in the current directory for app bundlers. The data are regularly refreshed to match the ISBN Agency updates and the project is on GitHub if you need newer data or want to contribute. Note that the data structure changed to fix ISBN-13 prefix handling so you must use Business::ISBN 3.005 or later, and recent releases also include packaging and behavior fixes such as avoiding unintended autovivification when looking up ISBN_RANGE_MESSAGE.

Music::VoicePhrase is a lightweight Perl helper for algorithmic music that builds measured phrases of simultaneous voices with both pitch and rhythm, making it easy to generate motifs and voice lines for MIDI or composition tasks. It wraps Music::Scales, Music::VoiceGen and Music::Duration::Partition to produce lists of rhythmic motifs and corresponding pitch voices and exposes simple methods like build_motifs and build_voices so you can regenerate material quickly. The module is aimed at real-time or programmatic workflows and includes convenience attributes for base note, scale, octave, pitch and interval selections, phrase size and duration pools, MIDI patch and channel, and runtime state such as a priority queue, index, current note and onsets. Defaults are musical and sensible so you can get started immediately, and recent updates made all attributes read/write and added named pitch and interval attributes plus other real-time friendly fields to make integrating this into live or iterative systems straightforward.

CPANSA::DB exposes the CPAN Security Advisory dataset as a ready-to-use Perl data structure so auditors and tools can check CPAN modules for known vulnerabilities. Its single db subroutine returns a hashref containing all advisory reports and the distribution also ships a JSON copy for non-Perl consumers. Releases are signed with GPG and published with GitHub Attestations so you can verify integrity of the archive, and the project is actively updated with new reports and CVE mappings. If you need an authoritative, machine-readable list of CPAN security advisories to drive audits, alerts, or tooling, this module gives you that dataset in a simple, importable form.

App::bcrypt is a lightweight Perl distribution that supplies a simple command-line utility for creating and verifying bcrypt password hashes and mainly exists to reserve the App::bcrypt namespace and to install the tool's prerequisites. The actual hashing work is handled by Crypt::Bcrypt and the package is useful if you want a small Perl-based CLI for generating bcrypt hashes or integrating bcrypt into Mojolicious workflows. There is no heavy API to learn because the CPAN module itself is essentially a packaging shim rather than a full-featured library, so check Crypt::Bcrypt or Mojolicious::Plugin::Bcrypt if you need a programmatic interface. Recent maintenance updates refreshed the distribution metadata in 2024 and in 2026 the test suite was tightened to scrub the environment for more reliable test results.

Syntax::Infix::ConditionalSplice adds a lexically scoped infix operator "?|" so you can write "COND ?| LIST" to include LIST in a surrounding list only when COND is true, which makes code that builds argument or option lists much cleaner than using the ternary with an empty-list branch. The operator short‑circuits so the right side is not evaluated unless the condition holds, and it is context aware so in list context it flattens into the outer list while in scalar context it yields the list's last value, mirroring standard ternary behavior. It binds tighter than the comma operator but looser than comparisons and logicals, so conditions usually need no extra parentheses, and it is implemented to be lexically scoped and safe for real-world use. Requires Perl 5.38 or newer.

Syntax::Infix::OptionalChain provides a lexically scoped safe-navigation infix operator ?-> that makes it easy to step into objects, hashes or arrays without repeatedly checking for undef. At runtime the bareword on the right becomes a method call if the left is a blessed object with that method, a hash key for HASH refs or an array index for ARRAY refs, and chains short-circuit to undef at the first missing value so you can write expressions like $cfg?->servers?->0?->port // 8080 without autovivification or "can't use an undefined value" failures. A blessed object that lacks the method falls through to structural access so blessed hashrefs behave like hashes, and attempting to navigate a defined value that is not navigable will croak rather than be silently swallowed. The operator is lexically scoped, requires Perl 5.38 or newer, and has the limitation that the right-hand side must be a compile-time bareword literal so you cannot pass arguments, use computed keys or negative indices.

Infix::Custom lets you add your own binary infix operators to Perl so expressions like a custom glyph between two operands are parsed at compile time and lowered into ordinary operations. You declare a glyph and choose how it lowers so the operator can call a Perl sub, map directly to a native binary operator for zero-call overhead, or act as a method-style operator that captures a bareword name for safe navigation. Declarations are lexically scoped and can be rebound or removed with no Infix::Custom, and you specify precedence to place the new operator into Perl's operator hierarchy. XS authors also get a low-level hook to supply a C-level build_op for custom optree construction when needed. The module requires Perl 5.38 or newer because it depends on a core parsing hook introduced in that release.

YAML::As::Parsed is a small, drop-in style alternative to YAML::Tiny that reads and writes YAML while preserving the order of mapping keys, so you get predictable key iteration and output instead of Perl's usual unordered hash behavior. It is aimed at people who need to load or emit YAML configuration or data files and keep the original key order for readability, diffs, or downstream processing. The module exposes the familiar YAML::Tiny API so existing code can switch with minimal changes. Recent updates replace the underlying implementation with Tie::OrderedHash to ensure stable ordering and the module requires a modern Perl runtime.

Tie::OrderedHash is an XS-backed replacement for Tie::IxHash that preserves insertion order while offering the same tied-hash and common OO methods so you can drop it into existing code and use new, Push, Pop, Keys and Values without changing behavior. Its distinguishing feature is a public C API with a provided header so downstream XS modules can access and iterate the underlying ordered hash directly for much better performance than paying Perl's tie dispatch. If you only need ordering at the Perl level you will see modest speedups, but if you are writing or calling into XS code this module is designed to be the high-performance option and includes ExtUtils::Depends integration and Windows-friendly build support for linking the exported symbols. The project aims for compatibility with Tie::IxHash and recent updates added unit tests and bug fixes for UTF8 keys along with some loader and test-suite adjustments.

Unicode::UTF8 is a compact, high-performance Perl module for encoding, decoding and validating UTF-8 text. It provides simple functions to turn octet strings into decoded Perl character strings and back again, lets you validate raw byte sequences, and includes read_utf8 to read and decode UTF-8 characters directly from a byte filehandle so you do not need to apply a PerlIO encoding layer. You can supply a custom fallback callback to control how ill-formed sequences or unrepresentable code points are handled, otherwise the module replaces them with the Unicode replacement character U+FFFD and emits standard utf8 warnings. The implementation aims to follow the Unicode recommendation closely and gives clearer diagnostics than the core Encode module while preserving taintedness and delivering significantly better performance in benchmarks. Use this module when you need robust, fast UTF-8 handling in Perl programs and want precise control or reporting for encoding errors.

Game::Cribbage is a Perl module that implements the rules and flow of the card game Cribbage and provides a ready-to-run terminal user interface. It includes a Game::Cribbage::Board engine to manage players, dealing, discards to the crib, the starter card, pegging/play logic and scoring, plus a suite of terminal rendering helpers for drawing cards, the board, scores and handling cursor positioning and input. The engine is reusable, so you can use the terminal client as-is for a quick playable game or embed the board logic in your own GUI, web or bot projects to add Cribbage support. If you need a compact Cribbage implementation in Perl that covers gameplay and scoring and ships with a simple terminal front end, this module is a relevant choice.

Cucumber::Messages is a Perl library that implements the Cucumber messages protocol and gives you a full set of classes for the protocol's NDJSON message types, plus simple serialization and deserialization helpers. It provides in-memory objects for everything in the Cucumber ecosystem, including Source and GherkinDocument ASTs, Pickles and TestCases, test run and test step events, Attachments and ExternalAttachment references, timestamps and durations, and an Envelope wrapper that can be created from or converted to JSON. Use it when you need Perl code to produce, consume or transform Cucumber message streams for formatters, reporters, CI integrations or other tooling that interoperates with Cucumber components.

Config::Model is a Perl framework for describing application configuration as declarative models and using those models to validate, migrate and edit real configuration files. You write a model as a Perl data structure or create one with the supplied GUI, then Config::Model drives a validation engine and can generate interactive editors for terminal, curses or Tk, expose configuration as a virtual filesystem, and run batch upgrades or command line edits via the cme tool. It includes backends for common formats such as INI and Perl files and can work with Augeas, and it also supports lightweight models focused solely on migration where unknown parameters are tolerated. The framework centralizes structure, defaults, constraints and help text so you get consistent user interfaces, immediate validation and easier maintenance of config evolution across releases. If your application needs robust config validation, interactive editing or automated migration, Config::Model is likely relevant, though unusual file formats may require writing a custom backend and the author welcomes bug reports and contributions.

Tk::AppWindow is an extendable application framework built on Perl/Tk that gives you a ready-made main window, a plugin and extension system, and a collection of common UI building blocks so you can assemble desktop GUI applications quickly. It makes it easy to load extensions for menus, toolbars, status bars, multi-document interfaces, sidebars and settings, and it includes a unified configuration and command registry with before and after hooks, logging callbacks, and optional saved geometry. The module also supplies convenient helpers for dialogs and forms, file and folder pickers, progress items and status messages, icon and art lookup, opening URLs, and small utilities like pause and abbreviate so you can focus on features rather than UI plumbing. If you want a modular, user-configurable shell for Perl/Tk apps with plugin support this module is likely relevant. Recent maintenance updated compatibility to accommodate Tk::FileBrowser 0.13.

Mojolicious is a polished, full‑stack real‑time web framework for Perl that gives you everything needed to build modern web apps quickly, from a flexible RESTful router and Perl-ish templates to built-in servers, WebSocket support, a powerful HTTP user agent, session and cookie handling, form validation, a testing toolkit and an extensible plugin system. It is designed for developer productivity with sensible defaults, first-class Unicode support, easy helpers and a small footprint so you can prototype or deploy production services without pulling in lots of glue code. If you write web services, APIs or interactive apps in Perl this is one of the most complete options available and includes tools for static assets, content negotiation, embedded apps and CLI commands. The project is actively maintained and the recent 9.47 release added support for the QUERY HTTP method from RFC 10008 and new query-related helpers across the user agent, router and Mojolicious::Lite, and it also fixed a potential security issue in the pure-Perl JSON decoder by limiting nesting to 512 levels to prevent memory exhaustion.

CGI::Lingua is a helper for Perl CGI apps that figures out which language and country a visitor prefers so your site can present the right localization without hard wiring everything to English. You tell it which RFC-1766 language tags your site supports and it returns a human-readable language name, optional sublanguage, two-letter language and country codes, the raw requested language string, and best-effort locale and timezone guesses. It integrates with CHI for caching and will use local geo modules like Geo::IP or IP::Country when available otherwise falling back to WHOIS lookups or external APIs for country and timezone. The module handles sensible fallbacks for language variants and normalizes IPv4-mapped IPv6 addresses, but it has a few practical limits you should know about such as left-to-right Accept-Language scanning that can ignore q-values, slow WHOIS fallbacks if no geo database is installed, certain regional codes like es-419 not resolving to sublanguages, and a requirement that any logger object be a blessed object with warn/info/error methods.

RPi::Pin provides an object that represents a Raspberry Pi GPIO pin and makes it easy to set pin mode, read and write pin state, configure pull-up or pull-down resistors, and control PWM on supported pins. It uses the BCM/GPIO numbering scheme and ties into the WiringPi API so you can also use RPi::WiringPi for safer setup and automatic cleanup, otherwise you are responsible for resetting pins yourself. The module supports edge-triggered interrupts with Perl code references and offers both in-process handlers that require you to service an interrupt dispatch loop and background handlers that fork a child to run the callback independently while your main program continues, returning a handle to stop or read results. Interrupt callbacks must be code references and you can opt into automatic dispatching to avoid writing your own loop. PWM values use a 0–1023 range and only the Pi’s hardware PWM-capable pin is supported by default. RPi::Pin is a compact, practical tool for controlling and monitoring GPIO pins from Perl for tasks like reading sensors, driving LEDs, or responding to switches.

CLI::Simple is a minimalist object-oriented Perl base class for building modulino-style command line tools that need options, subcommands and positional arguments. It layers Getopt::Long parsing with automatic getter/setter creation, integrates with Log::Log4perl for logging, and provides handy features like built-in help and pager support, bash completion generation, and low-dependency scaffolding tools to migrate a single-module script into a role-based project driven by a YAML manifest. In role mode it composes Role::Tiny roles declared in the manifest so you can split commands into focused modules, and it includes commands such as -dump-spec, -scaffold and -migrate to bootstrap that workflow. The module deliberately keeps the surface small and non-prescriptive so you get a simple init/run lifecycle without a heavy framework, which makes it a good fit for internal utilities and straightforward CLIs while teams needing complex interactive command trees may prefer a fuller framework like App::Cmd.

CPAN::Maker is a command-line tool for creating CPAN distribution tarballs from a declarative YAML "buildspec" file. It parses and validates the spec, stages your lib, bin, test and extra files into a temporary build area, generates a Makefile.PL with dependency information, runs the usual perl Makefile.PL / make manifest / make dist (and optionally make test) steps, and copies the resulting tarball to a destination directory. It also includes a validate command suitable for CI, a create-cpanfile command to assemble dependency lists into a cpanfile, and a write-makefile mode for previewing the generated Makefile.PL. The tool runs its build pipeline entirely in Perl and offers options to control metadata, dependency versioning, test execution and cleanup so it fits into automated release workflows.

CSS::Object is an object oriented Perl library for parsing, inspecting and generating CSS. It reads stylesheets from strings or files, parses them into rule, selector, property and value objects, and provides an API to iterate, query, create and modify rules programmatically, including a Builder for dynamic CSS generation and formatting options that preserve or control output style. It integrates easily with HTTP and HTML parsing tools for extracting remote or inline styles and reports errors via Module::Generic exception objects. Use it when you need to analyze or transform CSS from Perl code or produce CSS dynamically. Recent releases have focused on dependency maintenance and slimming the module’s required dependencies.

mb.pm is a modulino that lets you write and run Perl scripts using a variety of legacy multibyte encodings (Big5, Big5-HKSCS, EUC-JP, GB18030, GBK, Shift_JIS/CP932, UHC) as well as UTF-8 and WTF-8 by transpiling MBCS literals into ordinary octet-oriented Perl so your script behaves predictably without relying on Perl's UTF8 flag. It preserves traditional byte semantics for core operations while offering an mb:: namespace of codepoint-aware helpers for length, substr, ord, chr, transliteration and regex work, rewrites regexes and character classes for safe multibyte anchoring, and provides useful variables like $mb::PERL and $mb::ORIG_PROGRAM_NAME for running MBCS programs and preserving original names. You can run scripts via the modulino wrapper (perl mb.pm script.pl), install a source filter on modern Perls with use mb, or use the new runtime interface that exposes mb::qr, mb::valid and mb::split to call codepoint behavior only where needed. Recent releases document and implement that three-way model and clarify mb's strict definition of a "character" versus plain octet semantics so you can choose strict codepoint handling or octet-safe I/O. The module supports many Perl versions back to 5.005_03 and includes Windows-friendly features like DOS-style globbing, but it intentionally omits some Unicode facilities (full Unicode properties, named codepoints and full case folding) and inherits a few platform limits noted by the author, so it is most relevant if you need to maintain or write Perl programs that must work with native multibyte encodings without forcing UTF-8 conversions.

App::ChangeShebang is a small command line utility that fixes the shebang lines of Perl scripts so they still run after you move a relocatable Perl installation. When Perl is built with relocatable support scripts can contain absolute paths to the build-time perl binary that break if the installation is relocated. change-shebang rewrites those shebangs into a tiny portable shell wrapper that locates and execs the perl binary next to the script so the script remains executable wherever the Perl tree is moved. Run it on a script path like change-shebang /path/to/bin/script.pl and it is particularly useful for packagers and anyone who ships or moves Perl installations.

PAGI::Server is a reference Perl HTTP server that implements the PAGI spec and gives you a clear, production-capable foundation for serving HTTP/1.1, WebSocket, and Server-Sent Events with optional experimental HTTP/2 support. It is designed for correctness and clarity rather than extreme micro-optimizations and includes features you expect from a modern async server such as pre-fork worker mode, Unix domain socket support, systemd socket activation, hot restart with inherited file descriptors, backpressure controls, file streaming, and a variety of tuning knobs for timeouts, headers, connection limits, and TLS. The server plays well with IO::Async and Future::IO based libraries, recommends delegating TLS and static files to a reverse proxy in production, and currently does not run on Windows. Recent releases added important SSE behavior from the PAGI spec so applications can decline an SSE stream with a normal HTTP response and can explicitly close SSE streams, improving correctness for EventSource and failed-route handling.