CPANscan

Dump::Krumo gives you colorized, human readable dumps of Perl variables so debugging is easier. It exposes simple helpers kx to print a value and kxd to print then die with file and line information and optional stack traces. You can turn color on or off, return the dump as a string, change indentation, disable all dumps at runtime, control how JSON booleans are shown, and supply your own color scheme. If you want prettier, configurable debug output that is easy to read and parse, Dump::Krumo is a convenient alternative to Data::Dumper and similar tools.

App::mailmake is a tiny CPAN distribution whose sole purpose is to install the mailmake command‑line tool so you can use the Mail::Make family from the shell. It does not provide a programming API itself because all the work is done by the mailmake script, which integrates with Mail::Make and related modules such as Mail::Make::GPG and Mail::Make::SMIME. Installers can use cpanm or the standard Perl build steps to place mailmake in their bin directory, and the package declares the usual dependencies like Getopt::Class and Encode. Recent updates focused on quality and reliability with minor documentation improvements and fixes to how mailmake calls Mail::Make, improved error propagation, and more robust test behavior.

Mail::Make is a strict, RFC-compliant MIME email builder for Perl that offers a fluent, chainable API for composing messages with plain and HTML bodies, inline resources and attachments while keeping a single authoritative headers object. It chooses the right MIME structure automatically, encodes non‑ASCII display names and subjects, and auto‑generates standard headers like Date and Message‑ID when needed. You can render the message as a string, as a scalar reference to avoid copying, or stream it directly to a filehandle to keep memory use low, and it can spool to a temporary file when messages exceed a configurable size. It also provides a convenient smtpsend wrapper around Net::SMTP with TLS and authentication options and integrates GPG-based signing/encryption (via gpg/IPC::Run) and S/MIME signing/encryption (via Crypt::SMIME), with a clear note that S/MIME operations require the entire message in memory. Overall it is a practical choice for developers who need a robust, high‑level way to build, protect, and deliver complex email messages from Perl.

Crypt::OpenSSL::EC is a Perl wrapper around OpenSSL's elliptic curve library that gives you direct access to EC_GROUP, EC_POINT and EC_KEY primitives for creating curves, manipulating points, doing point arithmetic, serializing and deserializing points, generating and validating keys, and performing precomputation for faster multiplications. It exposes most of the functions from openssl/ec.h through a procedural API with optional object-oriented call forms and uses blessed mortal references so objects are automatically freed when no longer needed. Support for binary-field curves (GF2m) is present only when your OpenSSL build provides it and a few higher-level helpers are not implemented, but otherwise the module is suitable for Perl programs that need low-level EC operations or to build EC-based protocols provided you can compile against a compatible OpenSSL. Recent releases focus on build and packaging improvements, better handling of OpenSSL include and link paths, and suppression of compiler and OpenSSL deprecation warnings to make the module easier to build on modern toolchains.

Test::Changes::Strict::Simple is a small Perl test helper that performs strict, semantic validation of CPAN-style Changes files to catch release mistakes before you ship. It checks formatting rules like uniform indentation, no trailing spaces, and only space characters for whitespace, enforces a required title line and unindented version lines, ensures a version plus date per release, and validates that version numbers and calendar dates are well formed, non-regressive, and not in the future or earlier than 1987. The module exports a single test function changes_strict_ok that integrates with Test::More and emits diagnostic messages, and you can tune behavior with import options such as disabling the trailing-period check, requiring an empty line after versions, or supplying a custom version regex. It is intended for release tests (for example in xt/release guarded by RELEASE_TESTING) and helps detect common errors like version regressions and chronological inconsistencies, but it expects a traditional CPAN Changes layout and may not support highly customized formats.

Device::AVR::UPDI is a Perl class for communicating with modern AVR microcontrollers over the UPDI single-wire programming and debug interface. It connects to a serial device or an IO::Termios handle and knows chip parameters for many ATmega, ATtiny and AVR DA/DB parts so you can query part info and fuse definitions. The API is asynchronous and returns Future objects, and it exposes common tasks such as initialising the link, reading signature and system information, requesting resets, performing chip erase, entering NVM programming mode, and reading and writing flash, EEPROM and fuse values. You can supply a device path or an IO handle and override the default 115200 baud if needed. This module is aimed at developers who want to script or automate flashing, fuse configuration and basic debug operations on UPDI-capable AVRs using a simple USB-UART adapter wired to the UPDI pin.

Legba is an XS-based Perl module that provides simple global "slots" — named storage locations exported as accessor functions that you call with a value to set or with no arguments to retrieve. Because the accessors are regular functions imported into your package the stored values are shared across packages, making Legba useful for small global caches, shared configuration or session data. The module also offers dynamic name-based helpers like _get, _set and _exists for programmatic access along with utilities to list, clear or delete slots. For advanced embedding and performance work it exposes the internal registry SV, raw SV* pointers and helpers to construct getter and setter ops for optree injection. Bear in mind that the imported accessors are the intended fast path and the dynamic _get/_set calls are slower.

Future::IO is a lightweight abstraction that lets Perl code perform common IO operations asynchronously by returning Future objects instead of blocking. It mirrors familiar functions like read, write, send, recv, accept, connect, sleep and alarm and adds higher-level helpers such as read_exactly, read_until_eof, write_exactly, poll and waitpid so libraries can be written without tying themselves to a particular event loop. A minimal default implementation is provided so simple programs that need a single filehandle can work out of the box, but real event loops can plug in full implementations via override_impl, load_impl or the convenient load_best_impl helper. Futures returned from IO calls support cancellation but cancellation of in-flight low-level IO may produce partial or already-applied effects so you should only rely on cancelling timeouts or when abandoning a connection. The module is test-friendly and integrates with Test::Future::IO for unit testing, and recent releases have strengthened the default implementation to support multiple filehandles and improved timer performance and platform probing for kqueue.

Test::Future::IO::Impl is a small utility module that bundles acceptance tests you can run against any Future::IO implementation to check basic asynchronous IO behavior. It provides a single entry point, run_tests, which you call after loading the implementation under test and which runs named test suites such as accept, connect, poll, recv, send, sleep/alarm, read/sysread, write/syswrite and waitpid. The suites cover common socket, read/write and timing operations and include names for both older and renamed methods so tests remain useful across Future::IO versions. Use it with Test::More in your test scripts to quickly verify that a Future::IO backend behaves as expected.

Future::IO::Impl::Tickit is a small adapter that lets Future::IO use the Tickit event loop so you can drive asynchronous futures inside a Tickit-based application. It does not provide its own event loop. Instead you create a Tickit instance and call set_tickit to register that top-level object before using the Future::IO interface. This makes it useful when you already build a terminal UI or event-driven program with Tickit and want Futures to schedule work and timers on the same loop.

WWW::VastAI is a lightweight Perl client for the Vast.ai REST APIs that makes it easy to script marketplace searches, create and manage instances, work with templates and volumes, handle SSH and API keys, inspect invoices, and interact with serverless endpoints and workergroups. It provides convenient helpers for instance lifecycle tasks and SSH/log access and routes requests via a central operation map modeled after OpenAPI-style clients while keeping the distribution small. The module is aimed at Perl developers who need to automate or integrate Vast.ai operations into tooling and workflows and includes optional live tests for read-only and cost-incurring flows that can be enabled via environment variables. If you want programmatic access to Vast.ai from Perl with a ready set of API bindings and helpers, this module is a good fit.

Crypt::SecretBuffer provides a purpose-built container for sensitive byte strings in Perl so passwords, keys, and other secrets are kept out of Perl's normal string memory and are harder to copy or linger after use. It supplies safe read and write primitives including secure terminal input with echo disabled, constant-time comparisons to reduce timing leaks, methods to stream a secret to a pipe or background writer without materializing a Perl scalar, and ways to temporarily expose the raw bytes to XS code when unavoidable. The module also includes parsing helpers, length‑prefixed encodings, random byte generation, file load/save helpers, and a C API so XS or Inline::C modules can interoperate without depending on Perl stringification. It is not a magic bullet for long‑lived secure systems but gives practical controls to minimize accidental leakage in Perl programs. Recent updates (0.021) improved console prompt handling and defaults and fixed a bug when saving with the 'rename' overwrite mode.

DNS::Robot is a lightweight Perl client for the free DNS Robot web API (dnsrobot.net) that exposes 11 handy network and DNS tools including DNS and WHOIS lookups, SSL certificate checks, SPF/DKIM/DMARC validation, MX and NS queries, IP geolocation, HTTP header analysis, and a simple TCP port check. It needs no API key and depends only on core Perl modules (HTTP::Tiny, JSON::PP, Carp), returns decoded JSON as hashrefs, and will die on HTTP errors so you should wrap calls in eval or Try::Tiny when embedding it in scripts. The constructor accepts simple options like base_url, user_agent, and timeout, making it easy to drop into automation or monitoring tasks that need quick DNS and email authentication checks. This initial 0.01 release documents all 11 API methods and emphasizes zero external dependencies, making it a low-friction choice for Perl developers who want programmatic access to the DNS Robot tool set.

Hades is a DSL-driven code generator for Perl that turns compact class descriptions into full, ready-to-use Perl modules and test files, so you can write a high-level spec and get constructors, typed accessors, method modifiers, lifecycle blocks, inheritance, and tests generated for you. You describe classes in a simple .hades format or pass a string to Hades->run with options like file, eval, lib, tlib, dist, author and version, and Hades produces strict, warning-aware Perl packages with features such as required and default attributes, clearers and predicates, type checks and coercions, private accessors, before/after/around method modifiers, macros for reusable code, and automatic Test::More test scaffolding. The generator aims to remove boilerplate and make consistent, well-tested class code easy to produce, while still allowing you to add custom logic and tests where the auto-generation cannot fully cover domain-specific behavior.

Acme::Matrix is a lighthearted Perl module that displays a "Matrix"-style falling characters animation in your terminal. You simply load the module and call Acme::Matrix->start() to run the decorative digital rain, making it useful for demos, toys, or adding a bit of flair to scripts rather than for production functionality. The module is an Acme novelty module by LNATION, documented via perldoc, and distributed under the Artistic License 2.0 with bug reports handled through CPAN's RT.

Acme::Hospital::Bed is a lightweight, command‑line Q&A game that challenges you to decide whether randomly generated "patients" should be admitted to limited hospital beds based on a 1–10 illness level and an associated phrase. You configure the number of beds, the number of lives, patient names and per‑level phrases, then run start or next_patient to play rounds where admitting a patient with level above 5 is considered correct and wrong choices cost lives while occupied beds count down each turn and free up when their stay ends. The API is simple and scriptable with new, start, next_patient, available_rooms and check_patients_out, making it useful for small demos, amusements or learning Perl I/O and game loops. It is published under the Artistic License 2.0 and recent updates include minor output tweaks and a fix to improve compatibility with older Perl installations.

Getopt::EX::termcolor is a small helper for Getopt::EX-based command utilities that detects your terminal background color and automatically supplies a light or dark option so your program can adapt its output. It relies on terminal-specific submodules (for example Apple Terminal, iTerm and XTerm) or on the TERM_BGCOLOR environment variable, accepts several RGB notations, converts colors into a 0-100 luminance value and inserts a configurable option name when the luminance crosses a threshold. The module also provides a bgcolor helper you can call from shell startup files to export TERM_BGCOLOR. Recent releases improved XTerm support and detection behavior while keeping the interface simple and configurable for custom option names, thresholds and defaults.

Test::Routine provides a lightweight way to organize Perl tests as reusable, composable units built on Moose roles and attributes. Instead of writing procedural .t files you declare tests with the test declarator inside a role or main and compose those roles into a testable object that can carry fixtures and setup or teardown behavior via Moose attributes and method modifiers. Tests are executed with helpers from Test::Routine::Util such as run_tests and run_me and by default each test runs as a subtest, with optional filtering via the TEST_METHOD environment variable. If you need to avoid subtests the recent 0.032 release adds Test::Routine::Runner::NoSubtest so you can run all tests on an instance without wrapping them in a subtest. Test::Routine is intentionally minimal and delegates most behavior to Moose so you should be comfortable with Moose basics before using it.

File::Meta::Cache provides a lightweight, high-performance cache for open file descriptors and stat metadata so programs that repeatedly read the same files, such as web servers serving static content, can avoid repeated open and stat calls and reduce the total number of file descriptors used. You create a cache object and open files through it to get back a compact array-style entry containing the file descriptor, optional filehandle, stat info and a user slot for precomputed data like HTTP headers. The module exposes a simple OO interface and also returns raw code references for the hot path operations (opener, closer, sweeper, updater) to minimize overhead when you need maximum throughput. Entries share a single descriptor per file so callers must manage their own file positions when doing I/O and you are responsible for calling sweep on a timer to expire unused entries and keep metadata fresh. The API is tuned for speed rather than niceties, so entries are array refs indexed by constants and there are options to disable filehandles or use IO::FD where available. Recent 0.3.0 updates fixed descriptor closing order, added an optional callback invoked for each invalidated entry during sweeping, and renamed the entry-field constants (old names remain deprecated).

Dancer2 is a modern, lightweight web application framework for Perl that makes it easy to build web services and apps with a compact, expressive DSL and minimal boilerplate. It is a ground-up rewrite of the original Dancer using the Moo object system, and it supports fatpacked deployment so you can ship apps to hosts without installing extra CPAN modules while also offering optional XS components for extra speed. The module is the primary entry point for creating Dancer2 applications and is backed by comprehensive documentation, tutorials, configuration and deployment guides, a plugin ecosystem, and a migration path from Dancer 1, making it a good choice for developers who want a simple, flexible framework with strong community support.

Git::Grouper is a Perl module designed to categorize Git repositories into one or more groups, enabling users to perform various actions on them efficiently. With functions for configuring repositories, filtering based on group membership, and retrieving group information, it streamlines the management of repositories by allowing users to easily identify and manipulate groups of related projects. The module returns results in an HTTP-like format, providing clear status codes and messages, which enhances usability. Released on November 11, 2025, this initial version lays the groundwork for organized repository management in Git workflows. For more information, visit the project's homepage at MetaCPAN.

This module is just a placeholder included so CPAN will index the distribution and is not meant to be installed on a user system. The actual distribution provides a command-line tool for working with the SlackBuilds.org repository, offering commands to search, build, install, remove and query packages, plus repo sync and shell completion, while this Perl module itself contains no runtime functionality. If you are looking for the tool in the distribution, note that the project is mature and actively maintained and the recent 1.6.0 release added a -n option to skip md5sum verification when installing or building and fixed a bug that caused package names with special characters to be misrecognized.

Noise is a pure-Perl implementation of the Noise Protocol Framework that provides the core cryptographic building blocks for modern secure handshakes and transport keys. It implements the SymmetricState and CipherState primitives managing the chaining key, transcript hash, AEAD encryption with ChaCha20-Poly1305, and SHA-256 hashing so you can derive shared keys, encrypt/decrypt payloads, and finalize a handshake to produce send and receive keys. The module exposes simple methods to initialize a protocol (defaults to Noise_XX_25519_ChaChaPoly_SHA256), mix in key material or prologue data, write and read handshake messages with automatic transcript updates, and split into transport keys. This is aimed at developers who need low-level control to compose or experiment with Noise handshakes in Perl rather than drop-in network integrations. For application-level use you will likely prefer a higher-level wrapper such as Net::Libp2p::Noise that builds on these primitives.

Device::Chip::SSD1306 is a Perl driver for small monochrome OLED controllers (SSD1306, SSD1309 and SH1106) that gives a simple, high-level way to drive those displays via adapter subclasses for I2C or 4‑wire SPI. It supports common module sizes such as 128x64, 128x32 and 64x32 and provides options to flip the X or Y axis and to tweak contrast and VCOMH to help avoid burn‑in on static content. The module keeps a 1bpp framebuffer and exposes drawing primitives like draw_pixel, draw_hline, draw_vline, draw_rect, draw_blit and draw_glyph plus clear, refresh and send_display so you compose updates locally and push them to the hardware; many device operations are asynchronous and return Futures so they integrate with async code. The API is similar in shape to Device::Chip::MAX7219Panel making it easy to pick up if you have used that driver, and the recent 0.15 release added glyph and rectangle drawing, allowed contrast and VCOMH overrides, and moved framebuffer drawing into a faster XS implementation.

Eval::Closure provides a single convenient function, eval_closure, that lets you turn a string of Perl code into a coderef while giving you precise control over the lexical environment in which that code runs. Instead of the usual unpredictable string eval scoping, you supply an environment hash that maps variable names (with sigils) to references so the generated closure can access only the variables you explicitly provide. The module rethrows compilation errors rather than hiding them in $@ and offers helpful options such as alias to make closed-over variables truly alias the originals, description and line to improve stack traces, and terse_error to suppress extra source text in error messages. It is aimed at cases of dynamic code generation, for example inlining accessors in Moose, where predictable scoping and clearer diagnostics matter. The distribution is mature and maintained on MetaCPAN and GitHub, with recent work adding lexical sub support and the alias feature plus minor optimizations.

Algorithm::Kademlia is a pure-Perl toolkit that implements the core math and data structures of the Kademlia distributed hash table so you can build DHT-based systems without tying them to any specific network protocol. It provides XOR distance utilities, a k-bucket routing table that manages peers with the usual least-recently-seen behavior, a simple in-memory key/value store with TTL for holding DHT entries, and a Search object that tracks the state of iterative lookups with configurable k and alpha parameters. The module is protocol-agnostic, so it does not handle RPCs or networking for you but gives you the routing, storage and lookup machinery needed for BitTorrent-style DHTs, libp2p Kademlia modules, or custom peer-to-peer storage services.

Brick is a lightweight framework for expressing and applying complex business‑rule validation to Perl data structures. You define a validation "profile" made of required, optional and custom checks, optionally load external validator packages, and then apply that profile to an input hashref to get a structured results object describing success, failures and transformed values. The module is designed to be extensible so you can plug in custom validator packages, swap the Bucket/Profile/Result classes, or subclass for specialized behavior, and it ships with companion modules like Brick::Profile and Brick::Result to manage profiles and outcomes. The project is mature and actively maintained on GitHub and CPAN, and recent updates have focused on keeping dependencies current, for example removing a MIME::Types dependency to avoid version conflicts.

Business::ISBN::Data is a companion data pack for the Business::ISBN module that supplies the official ISBN group and publisher range data derived from the ISBN Agency's RangeMessage.xml file. You normally do not load it yourself because Business::ISBN loads it automatically and it stores the parsed ranges in %Business::ISBN::country_data with a _source key pointing to the original RangeMessage.xml. The distribution includes a copy of RangeMessage.xml and you can point Business::ISBN at an alternate file by setting the ISBN_RANGE_MESSAGE environment variable or simply placing RangeMessage.xml in your program's working directory, otherwise the module falls back to embedded default data. Note that you need Business::ISBN version 3.005 or later because the data structure was adjusted to fix an ISBN-13 prefix issue. The data are kept current with frequent updates (recent updates extend into 2026) and the project is hosted on GitHub, so you can refresh the bundled data yourself or contribute fixes.

Business::ISBN is a Perl module for parsing, validating and manipulating International Standard Book Numbers, handling both ISBN-10 and ISBN-13 formats. It accepts and normalizes messy input, checks and can fix checksums, extracts group, publisher and article codes, and converts between ISBN-10 and ISBN-13 where applicable. You can format ISBNs with standard or custom hyphenation, increment or decrement the article code, and produce an EAN-13 PNG barcode if GD::Barcode::EAN13 is available. The module offers a simple exportable checksum-checking function and a richer object interface that reports detailed validation errors and uses updatable range data from Business::ISBN::Data. Use it when you need reliable ISBN validation, conversion, metadata extraction or barcode generation for publishing, cataloguing, inventory or bookstore workflows.

Test::ValkeyServer is a small testing helper that automatically launches and manages a temporary valkey-server instance for use in Perl test suites, making it easy to run integration tests against a real Valkey key/value store. It is a fork of Test::RedisServer adapted for Valkey and provides simple options to control startup, temporary configuration, timeouts, and single-node cluster mode when you have valkey-cli and a compatible Valkey version available. You can start the server automatically or manually with start or exec, get connection parameters directly for client libraries like Redis.pm, check the server pid, wait for exit, and rely on the object to clean up the process and temp files when tests finish. If valkey-server is not available your test harness can skip the tests, so this module is useful whenever you want reliable, isolated Valkey instances for automated testing.