CPANscan

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.

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.

Command::Run is a compact, core-only Perl helper for running external commands or Perl code references and capturing their output in a simple, chainable API. You can feed data to stdin, capture stdout and stderr separately or merge stderr into stdout, or obtain a file-descriptor path like /dev/fd/N to hand to other programs. Code references are run in a forked child by default but can be executed in-process with the nofork option and paired with raw mode to avoid PerlIO encoding overhead for much higher throughput. The interface supports method chaining via command, with and run so the same runner can be reused with different inputs. It is intentionally lightweight compared with feature-rich tools like IPC::Run, so it is ideal for straightforward capture-and-run tasks rather than complex pty or timeout management. A recent fix eliminates PerlIO encoding-layer accumulation in nofork mode so long-running processes no longer slow or leak memory and raw mode is no longer required to avoid that problem.

Desktop::Workspace::Util provides small, focused helpers for working with DesktopWorkspace specification modules, letting you locate and instantiate a workspace module, enumerate its items with rich tag and type filters, and open those items (programs, files, directories, URLs) from scripts or tools. The API is deliberately script-friendly, returning enveloped arrays with HTTP-like status codes and optional metadata, and the list and open functions accept options for tag-based inclusion or exclusion, type filtering, query and shuffle, module arguments and namespace prefixes (defaulting to "DesktopWorkspace" and ""), and opening-time overrides such as KDE activity or forcing a new browser window. Functions are not exported by default but can be exported when needed. This module is useful if you want to automate launching or inspecting grouped desktop resources and integrate workspace specifications into other automation, and version 0.001 is the initial release.

Regex::Range::Number generates compact regular expressions that match whole numbers inside one or more specified numeric ranges. You can use it as an object or import the number_range function to get a ready-made regex string for a single range like 100 to 1999 or for a list of ranges such as [[55,56],[75,89],[92,100]], and it can optionally wrap the result in a capture group. The returned pattern plugs directly into Perl m// expressions, making it convenient for input validation, parsing, or filtering when you need precise numeric-range matching without handcrafting complex regexes.

Object::Proto is a compact, high-performance object system for Perl that stores objects as arrays with compile‑time slot mapping and optional prototype chains, giving you fast, memory efficient accessors and method dispatch that still work with normal bless, isa and can. You define classes and properties with object or Object::Proto::define, get automatically generated getters and setters that can be imported as function-style accessors for extra speed, and use built‑in type constraints, defaults, lazy builders, triggers, weak references, readonly flags and other modifiers for robust data handling. The module supports classical inheritance including multiple and multi‑level extends, roles, method modifiers like before, after and around, singleton construction, clone, freeze and lock for mutability control, and BUILD and DEMOLISH hooks for setup and teardown. Advanced users can register custom types from Perl or from XS to move checks and coercions into C for minimal overhead, and a full set of introspection utilities exposes properties, slot metadata, ancestors and prototype chains. If you need a feature rich yet faster alternative to hash‑based Perl objects, especially for performance sensitive code, Object::Proto is a practical choice.

Tk::FileBrowser is a Perl/Tk widget that gives your Perl GUI a multicolumn file system explorer with configurable, sortable and resizable columns. It supports multiple view modes (compact, detailed, icon) and lets you add custom column types via -columntypes by providing display and test callbacks so you can control what each column shows and how it sorts. The widget exposes hooks for custom icons, double‑click file invocation, load and postload callbacks and provides simple methods such as load, reload, collect and openFile to manage the current folder. Header and tree context menus make it easy to toggle case dependent sort, show hidden files and open entries and handy key bindings like Ctrl+A, Ctrl+F and F5 speed common tasks. This module is a good choice when you need an embeddable, extensible file browser for a Tk based Perl application but be aware the author notes loading and sorting very large folders can be slow.

Test::CPAN::Health is a command-line tool and Perl API for evaluating the overall health of a CPAN distribution and producing a scored, configurable report. It accepts a local path, a CPAN distribution name, or a module name and runs a broad suite of checks — from licensing, META and CI configuration, documentation and POD coverage to dependency freshness, known security advisories, CPAN Testers results, test coverage, code complexity and duplicate code — then returns a weighted score out of 100 and renderable output in terminal, JSON, HTML or TAP for CI integration. You can skip or limit checks, disable network queries, require a minimum score to fail a build, or embed the analysis in scripts, though note that coverage checks need Devel::Cover and run the package test suite which can be slow, network checks depend on external APIs and rate limits, and duplicate-code analysis can false positive on generated or data-heavy files. The module provides both a simple CLI for quick audits and a programmatic interface for automated tooling. This is the initial release on CPAN.

Algorithm::Classifier::IsolationForest is a Perl implementation of Isolation Forest and Extended Isolation Forest for unsupervised anomaly detection that builds an ensemble of random trees to score and flag outliers, returning per-sample anomaly scores in (0,1] and optional binary labels. It supports classic axis-aligned splits or oblique hyperplane splits for the extended variant, a majority-voting aggregation mode, learned thresholds from a contamination parameter, several strategies for handling missing values, and named-feature support for single-row scoring. The module offers persistence to JSON, a packed-data wrapper to speed repeated scoring in interactive workflows, reproducible fits via seeding, and multiple ways to speed up training and scoring with an optional Inline::C and OpenMP backend or by forking worker processes while keeping a pure-Perl fallback that produces identical results. Overall it is a practical, feature-rich choice for detecting anomalies in numeric datasets, especially when you want flexibility over aggregation, missing-data treatment, performance tuning, and easy model saving and reloading.