CPANscan

Mojo::File::ChangeNotify watches files and directories and turns those changes into Mojo-style events you can handle in your application. You create a watcher with directories and an optional filter and provide an on_change callback or attach a 'change' event to receive lists of events describing changed paths and types. Because the underlying File::ChangeNotify interface is blocking or poll-based, this module runs the watcher in a subprocess and forwards notifications to the main process so your Mojolicious event loop stays responsive, though the watcher may take about a second to start. It is a good fit for web or event-driven Perl apps that need a simple file-watching hook without blocking the main process. Recent updates fix memory leaks and expand tests around child process cleanup.

Filesys::Notify::Win32::ReadDirectoryChanges is a lightweight watcher for Windows that notifies your Perl program about file system events such as created, removed, modified and renamed files and also reports attribute changes, making it useful when you need native, event-driven directory monitoring on Windows. It provides a simple API to add and remove watched directories, a wait method that invokes a callback for each event, and a Thread::Queue for integrating with your own event loop. The implementation uses the Windows ReadDirectoryChanges API and manages worker threads for each watched directory so it is easy to use but does allocate resources per watch; call stop before renaming or deleting watched directories. Recent updates fixed a constructor option naming bug by ensuring the correct "directories" key is accepted and improved resiliency when disposing watcher objects, and the read buffer size can be tuned if you need to handle very busy directories. Be aware that Cygwin support is problematic and Windows XP is not supported.

EV::Pg is a non-blocking PostgreSQL client for Perl that plugs libpq's async API into the EV event loop so your program never blocks on database I/O. It gives you familiar, callback-driven query methods for simple and parameterized SQL, prepared statements, pipeline mode, single-row and chunked-row delivery, COPY IN/OUT, LISTEN/NOTIFY, protocol tracing and structured error fields. Callbacks receive result rows or error messages and there are convenience helpers for escaping, describing prepared statements and portals, cancelling queries and inspecting connection metadata. The module targets high-throughput, low-latency applications and includes pipeline optimizations that can significantly raise query throughput compared with synchronous drivers. It requires libpq and EV (libpq >= 14) and several newer features such as chunked rows, async cancel and no-flush pipeline sync need libpq >= 17. The recent 0.02 update adds a keep_alive flag to let a LISTEN stay active without exiting EV::run and guards send_flush_request for older libpq builds.

App::Cmd is a lightweight Perl framework that makes it easy to build complex, multi-command command-line programs by turning each subcommand into a small, testable plugin module. It handles locating and loading command modules, parsing and validating options and arguments, producing consistent usage and help text, and wiring in common helpers like version and commands listings so you can focus on the business logic. The framework is customizable so you can change arg handling, define global options, group commands, or allow unambiguous abbreviated command names, and it captures program name and usage details for polished CLI output. If you need to write a git-like or multi-subcommand tool in Perl and want to avoid writing your own argument parsing and dispatch boilerplate, App::Cmd is a solid, well-established choice with a tutorial to get you started.

App::HTTPThis is the small engine behind the http_this command that lets you quickly run a lightweight HTTP server to serve a local directory and generate directory listings. It is intentionally a thin wrapper around Plack::App::DirectoryIndex, so the actual serving and indexing behavior comes from Plack while this module handles command-line and config-file options and kicking off the server. It supports a config file and command-line flags (recently changed so command-line arguments override config settings), optional pretty directory listings, Bonjour name advertising, and a --host option for binding to a specific interface, making it handy for simple development use or sharing files on a local network.

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.

Module::Generic is a versatile Perl module designed to serve as a base class for creating feature-rich objects with minimal boilerplate code. It provides a framework that simplifies the creation of classes by allowing developers to define properties and their types, such as scalars, arrays, and objects, using a straightforward syntax. The module supports dynamic method generation through AUTOLOAD, enabling seamless access to object properties as methods. Recent updates in version 1.1.3 have enhanced the `colour_parse()` method for improved color messaging output and introduced new methods like `force_tty()` and `colour_max_depth()` to further refine debugging capabilities. This module is particularly useful for developers looking to streamline their object-oriented programming in Perl while maintaining robust error handling and serialization features.

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.