CPANscan

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.

Disk::SmartTools is a Perl toolkit for discovering disks and working with S.M.A.R.T. health features across platforms. It detects the OS and locates useful command-line utilities such as smartctl, diskutil, lspci and softraidtool, enumerates candidate and physical disks, identifies which drives support SMART, and provides convenience routines to query SMART attributes, fetch self-test history, and start short or long self-tests. Example scripts show how to display SMART data or run tests from cron, and the module supports per-host overrides via ~/.smarttools.yml; note that many operations must be run as root and the smartmontools package is required. Recent updates improved safety by checking files before deleting, migrated internal file handling to Path::Tiny, added FreeBSD and OpenBSD support, and strengthened tests and documentation.

Text::HTML::Turndown is a Perl port of the popular turndown libraries that converts HTML into Markdown, offering an object-oriented API and a handy html2markdown helper that returns a Text::FrontMatter::YAML object for easy use in static site or note-taking workflows. It aims to match the JavaScript turndown behavior and test suite while applying practical fixes for real-world HTML, with recent updates that escape image alt text, improve Markdown table output and table cell handling, and correctly handle <br> inside pre/code blocks and checkbox states. If you need to turn HTML fragments into portable Markdown from Perl scripts or content pipelines, this module provides a straightforward, maintained implementation that integrates well with common workflows.

OpenGL is the Perl binding that lets you drive the native OpenGL graphics API from Perl programs and scripts, exposing most classic GL functions plus many newer extensions and the GLU, GLUT and partial GLX helpers so you can create windows, upload GPU buffers, draw geometry and run shaders without leaving Perl. It supports convenient calling variants for C-style pointer arguments, integrates with OpenGL::Array for efficient C-backed arrays and with companion modules such as OpenGL::Shader and OpenGL::Image, but it does assume your system has the underlying OpenGL, GLU and a GLUT implementation installed. If you want to prototype 3D rendering, GPU-based math, or embed OpenGL surfaces in Perl GUI code this module is directly relevant. The current 0.7007 release modernizes many bindings by using OpenGL::Modern for generated calls, adds a glpErrorString helper, adds _o aliases for OpenGL::Array arguments, improves type-correct generation of _s functions, and adds build support via ExtUtils::Depends while standardizing on Perl 5.016 or newer.

Pod::Example is a small Perl utility for extracting example code blocks from a module's POD documentation so you can print, run, or include them elsewhere. It offers a simple API with get, which returns the example source and optionally a suggested filename when the POD supplies one, and sections, which lists example sections present in the POD. The module looks for a default EXAMPLE section and also supports numbered sections like EXAMPLE1 and EXAMPLE2, accepts either a filename or a module name as input, and is handy for generating demos, tests, or documentation-driven examples. It is lightweight, easy to use, and complements the pod-example script and the App::Pod::Example base class.

Term::ANSIColor::Gradients is a small library of curated ANSI 256‑color palettes organized into thematic submodules so you can pick ready-made color ramps for terminals and text output. Each submodule provides a %GRADIENTS hash that maps human-friendly palette names to arrays of ANSI color indices from 0 to 255, which you can iterate and feed to Term::ANSIColor or other terminal-rendering tools. Available groups include Classic, Extended, Scientific, Sequential, Diverging, Accessibility, and Artistic, covering everything from simple single‑hue ramps and decorative schemes to perceptually tuned and colorblind‑safe palettes for data visualization. Call list_groups to see what packs are included and load the specific submodule that matches your needs.

WWW::Mechanize::Chrome is a Perl module that automates a real Chrome or Chromium browser via the Chrome DevTools Protocol. It gives you a WWW::Mechanize-style interface but drives an actual browser so you can execute JavaScript, query and manipulate the DOM with CSS selectors or XPath, take screenshots or PDFs, intercept and alter network requests, emulate network conditions, and handle dialogs and events. The module can launch or connect to a browser (including headless mode), manage tabs, fill and submit forms, click elements, and render page content as images, MHTML, or PDF, which makes it suited for scraping and end-to-end testing of modern web apps. You will need a Chrome-compatible executable installed and some older WWW::Mechanize methods are not implemented or behave differently. The author notes a few quirks such as occasional harmless DevTools messages and limited POST support, but otherwise the module exposes powerful browser-level control from Perl.

Remote::Perl lets you run Perl code on a remote machine over any pipe-based transport such as SSH by bootstrapping a small protocol client on the remote side, and it is available both as a command-line tool (remperl) and as a library. It streams remote STDOUT and STDERR in real time, can forward local STDIN on demand, and can send signals to the remote executor independently of the transport. When module serving is enabled the remote interpreter can fetch missing modules from your local @INC so the target only needs a bare Perl install, and special tmpfile modes are provided so scripts that use __DATA__ behave correctly. The API offers run_code and run_file calls with callbacks for output, per-run options like args and tmpfile, and a disconnect method that cleanly shuts down the remote side. Requires Perl 5.36+ locally and Perl 5.10+ remotely. Recent updates fixed a flow-control bug, added short options like -e/-w/-M with support for multiple -e invocations, and introduced options and an API serve_filter to restrict which local modules may be served.

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.

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.

The Bluesky Perl module is a comprehensive client library designed to facilitate interaction with the Bluesky social network, leveraging the AT protocol. It provides an object-oriented interface for users to authenticate via OAuth, create and manage posts, follow or block other users, and access real-time streaming of events. With methods for retrieving timelines, trending topics, and user profiles, as well as functionalities for direct messaging and moderation, this module simplifies the process of building applications that integrate with the Bluesky platform. Whether you're posting updates, managing social connections, or exploring content, Bluesky offers a user-friendly approach to harnessing the capabilities of the Bluesky ecosystem in Perl.

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.