CPANscan

Math::Prime::Util is a comprehensive Perl toolkit for computational number theory that gives you fast prime sieves, high‑quality primality tests (including BPSW and proof options), integer factoring, prime counting and nth‑prime routines, random prime generation, modular arithmetic and a large collection of arithmetic and number‑theory utilities (totients, Möbius, partitions, divisor functions, combinatorics, set and permutation helpers, and more). It works with native integers and bigints and is tuned to be the fastest on CPAN for most tasks while remaining thread‑safe; installing the optional Math::Prime::Util::GMP/Math::BigInt::GMP backends dramatically improves big‑number performance. The module also includes a secure ChaCha20 CSPRNG for random primes and sampling. The recent 0.74 release expanded the API substantially, adding many exact integer primitives (addint, mulint, powint, shifts and several division semantics), new modular operations and root routines, richer set and sequence helpers, fixes to edge cases, and performance and prime‑counting improvements; note a few behavioral changes such as is_pseudoprime defaulting to base 2 and adjusted divisor and lcm edge handling. If you need reliable, high‑performance prime work, modular arithmetic, or other number‑theory functions in Perl, this module is very likely relevant.

DateTime::Format::ISO8601 is a Perl module for reliably parsing and formatting ISO 8601 date and time strings, handling a very wide range of date-only, time-only and combined formats including basic and extended forms, fractional seconds and timezone offsets. You can call its parse_datetime and parse_time methods as class or object methods and supply a base_datetime to fill in missing fields for incomplete inputs, and you can control two-digit year interpretation with cut_off_year and legacy_year options. It also provides format_datetime to emit ISO 8601 strings that include nanoseconds and correct timezone offsets. Time-intervals are not yet supported. The recent 0.19 release fixed a precision issue in nanosecond calculation on some architectures such as arm64 Raspberry Pi builds.

Music::Drummer is a tiny, user-friendly alias for the MIDI::Drummer::Tiny module that makes drum-related MIDI functionality easier to find and refer to by providing a clearer name and descriptive keywords like drum, drums, and drumming. It exposes the same simple interface as MIDI::Drummer::Tiny so you can create drum patterns, perform count-ins, and drive MIDI drum playback without learning a new API. There is no extra functionality beyond the underlying module, so it is useful mainly for discoverability and convenience. Recent releases keep the package synchronized with MIDI::Drummer::Tiny and update its prerequisites to stay compatible with that implementation.

MIDI::Drummer::Tiny is a Perl toolkit for programmatically creating drum parts and exporting them as MIDI files. It is not a realtime drum machine but a high-level library that provides sensible defaults, named drum patches, musical durations, metronomes for common time signatures, pattern and sync utilities, fills, rolls, flams, crescendos and simple swing control so you can build realistic drum scores in code and write them to disk or render with a soundfont. The module tracks beat counts and supports time signature and tempo changes, pattern generation (including euclidean-style patterns), multi-voice synchronization and easy customization of kit pieces and velocity for accents. If you want to script drum parts, generate grooves, or build algorithmic percussion for backing tracks or demos, this makes the job much faster. Recent releases modernized and refactored the internals, added a Grooves module and example programs, removed some playback helpers, and the latest 0.7002 release contains a small documentation/code typo fix.

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.

Graphics::Framebuffer is a Perl library for drawing directly to a Linux console framebuffer, offering simple APIs to plot pixels, draw primitives like lines, circles, boxes and polygons, render TrueType text, load and blit images and play simple animations. It works in 16, 24 and 32 bit framebuffer modes and includes an emulation mode so you can develop offscreen on systems without a framebuffer. The module can use Imager and optional Inline::C acceleration for much faster drawing and image transforms but pure Perl fallbacks are always available when compilation or drivers are not. It is intended for console use only and will not work correctly inside X or Wayland or with proprietary DRM drivers, so you need a framebuffer device and appropriate permissions to access it. The author recommends 24/32 bit color for best performance and documents workarounds for 16 bit limitations. The latest release mainly cleans up the code and fixes Debian installation scripts while continuing to refine performance and buffering behavior.

Data::HashMap is a family of ultra‑fast, type‑specialized hash maps implemented in C for Perl that give you compact, high‑throughput in‑memory maps with both a blazing keyword API that bypasses Perl method dispatch and a convenient method API. Each variant is tuned for a particular key/value combination (integers, strings, or Perl SV* values) and supports common map operations plus integer counters, iteration, bulk snapshotting, and cache features such as LRU eviction and TTL expiry with optional per‑key TTL. The implementation focuses on performance and low memory overhead compared with Perl hashes, uses open addressing and xxHash, and exposes useful extras like get_or_set and zero‑copy reads for string values. Note that some integer variants require 64‑bit Perl and that string zero‑copy results are read‑only and must not be retained past any map mutation; the iterator also resets if structural changes trigger rehash or compaction. Recent updates include switching to bundled xxHash v0.8.3 and a new get_direct keyword for zero‑copy string lookups, improving lookup speed and reducing allocations for read‑heavy workloads.

Tlaloc is a playful but practical Perl module that attaches invisible "wetness" metadata to scalars so they behave as if they evaporate when read, letting you mark a variable as wet, drench it to 100, dry it, and query or adjust its evaporation rate. The wetness level (0–100) automatically decreases by a configurable rate on each access, while the underlying scalar value remains unchanged, and you can apply the same idea to arrays and hashes via tied wrappers that trigger evaporation on element reads. It exposes simple functions and tied-object methods for wet, drench, dry, wetness, is_wet, is_dry, and evap_rate, so it is useful for demos, testing, teaching about Perl magic, or any situation where you want invisible per-variable state that reacts to reads. Be aware that magic is attached to the variable itself so assigning a scalar copies the value but not the wetness, attaching magic to literals is meaningless, and the implementation is not thread safe across interpreter threads. This is the initial 0.01 release.

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.

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.