CPANscan

Masscan::Client is a simple object-oriented Perl wrapper around the Masscan network scanner that makes it easy to assemble, run, and parse high-speed port scans from Perl programs. You build a client by adding hosts, ports or port ranges and any extra masscan arguments, optionally set the binary path, verbosity or DNS servers, then call scan and receive the results as a native Perl data structure containing per-host timestamps and open-port details. The module handles command-line construction, JSON output parsing and logging via Log::Log4perl and will try to find the masscan binary on your PATH if you do not provide one. It relies on common CPAN modules such as Moose and Net::DNS and requires the external masscan program plus the necessary execution privileges, so it is a good fit for scripts and tools that need to orchestrate automated network scans from Perl.

Graph::Easy is a Perl library for building, parsing and rendering node and edge graphs into readable diagrams and portable formats. You can create graphs programmatically or from a simple text syntax, attach attributes to nodes, edges and groups, and then render the result as ASCII art, Unicode box drawing, HTML with CSS, SVG (with an optional helper module), Graphviz DOT, GraphML or legacy GDL/VCG. Its built in Manhattan grid layouter is geared toward flow charts, network diagrams and hierarchical trees and makes it easy to produce compact, human friendly diagrams or to pipe DOT output to Graphviz when you need more advanced rendering. The module supports anonymous nodes, groups, multi edges and basic animation steps for describing state flows though animations are not yet exported to output. There are a few known layouter limits such as imperfect group nesting and missing group-to-node link handling and there is no internal scoring or second stage optimizer, but for quickly creating and exporting diagrams in many formats Graph::Easy is a practical, easy to use choice.

Getopt::Guided is a Perl library for parsing short command-line options with POSIX utility behavior. It offers an iterator-style getopts that parses @ARGV or a supplied array, fills a hash of option values including multi-value options, and supports flags that can be negated or incremented. The processopts helper maps parsed options to scalar or array references or to callback routines so you can attach semantics and control precedence, and it respects an end-of-options signal so callbacks can stop processing early. There is also readopts for loading default options from an rc file in XDG_CONFIG_HOME and print_version_info to implement a standard -V version display. Exports are opt-in and the module follows semantic versioning. A recent 3.1.0 release added readopts and a program_name helper and made some exit status constants exportable, while 3.1.1 focused on documentation and packaging fixes.

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.

Net::Async::Zitadel is an asynchronous Perl client for the Zitadel identity platform that gives you non-blocking OIDC and management API access inside an IO::Async event loop. It uses Net::Async::HTTP and Future-based return values so you can verify tokens via JWKS, use discovery and userinfo endpoints, and perform CRUD operations on users, projects, applications and organizations without blocking your program. The module wraps the WWW::Zitadel API surface and lazily builds OIDC and management helpers; a Personal Access Token is optional unless you need the management API, which will die if no token is provided. If you need a lightweight, event-loop friendly interface to Zitadel from Perl, this module provides the common OIDC and management features in a familiar async style and points to a GitHub repo for issues and contributions.

WWW::Zitadel is a Perl client for the Zitadel identity platform that bundles an OpenID Connect helper and a Zitadel Management API client. It makes it easy to discover JWKS, verify and decode JWTs, and call userinfo endpoints, and it provides CRUD operations for users, projects, applications and organizations. The OIDC part works with any OIDC-compliant provider and uses Crypt::JWT for token validation. Administrative calls go through the management client and require a Personal Access Token. Both subclients are constructed lazily from a simple WWW::Zitadel object configured with the issuer URL.

POE::Component::ElasticSearch::Indexer is a ready-made POE session that lets event-driven Perl programs push documents into an Elasticsearch cluster without blocking your main loop. It batches records and uses Elasticsearch's bulk API for throughput, accepts simple hashes, prebuilt newline JSON, or objects that provide as_bulk, and understands per-document hints like _index, _id, _type and _epoch so you can route or name indices dynamically. The component handles connection pooling, timeouts, periodic flush-by-time or flush-by-size, optional HTTP basic auth, and can write failed batches to disk for later recovery while offering hooks for custom statistics and cleanup. Defaults are tuned for log-style indexing (logs-%Y.%m.%d and _doc), and the module will strip types for clusters newer than 7.x. Recent updates improved logging, changed the default protocol handling, and switched to using the wire compatibility version to improve compatibility with OpenSearch. If you build POE-based loggers or evented pipelines that need efficient, resilient indexing into Elasticsearch or OpenSearch, this module gives a compact, configurable solution.

Term::ReadLine::Repl is a lightweight framework for building interactive command shells in Perl that takes care of the terminal plumbing so you can focus on your commands. You register commands as a cmd_schema that maps names to exec coderefs and optional argument descriptions, and the module provides tab completion, in-session and optional persistent history, a built-in help and quit commands, and an optional "!" shell passthrough for one-off system commands. It also offers hooks for Getopt::Long-style parsing and a custom per-loop callback to alter behavior or swap command schemas at runtime, and a simple run() method drops the user into the REPL and saves history on exit. Use this when you need a ready-made, extensible interactive prompt without reimplementing completion, history, or basic REPL controls.

JSON::Schema::Modern is a mature, actively maintained Perl evaluator for JSON Schema that supports the current Draft 2020-12 and earlier drafts and lets you validate either Perl data structures or JSON strings and receive a structured Result object describing success, errors and annotations. It is highly configurable so you can select the specification version, control short‑circuiting, enable or supply custom format validators, register media type decoders and content encodings, add custom vocabularies, collect defaults that should be applied to missing data, and preload or cache parsed schema documents to speed startup in preforked environments. The module exposes high level APIs to add schemas or prebuilt document objects, to traverse schemas for analysis, and to run targeted evaluations with callback hooks. It does not automatically fetch schema files from disk or the network and some format checks depend on optional CPAN modules, so you should add any custom format, media type or encoding handlers you need and avoid using untrusted schemas because regular expressions and numeric operations in schema or data can be expensive or risky. A recent update fixed the hostname and duration format validators to more strictly reject IP addresses and disallow fractional duration units in cases where the specification does not allow them.

Signal::Mask provides a lightweight, Perl-friendly interface to the process or thread signal mask so you can inspect and change which POSIX signals are currently blocked for the caller. The module exposes the mask as the global %Signal::Mask hash, which lets you localize entries to temporarily block signals inside a lexical scope, for example local $Signal::Mask{INT} = 1 to postpone SIGINT delivery until the scope ends. It is a compact, focused tool for code that needs to protect critical sections from asynchronous interruptions or for threaded programs that require explicit, fine-grained signal control.

EV::Future is a tiny, high-performance helper for coordinating asynchronous tasks on the EV event loop that provides three simple building blocks: parallel to run tasks all at once, parallel_limit to constrain concurrency, and series to run tasks one after another. Each task is a coderef that receives a single done callback which it must call once when finished, and an empty task list causes the final callback to run immediately. The module is implemented in XS for speed and ships sensible safety checks by default to catch exceptions and repeated calls to the done callback, while an optional unsafe mode removes those checks and reuses objects to deliver roughly double the throughput for well behaved code. parallel_limit clamps the concurrency between one and the number of tasks and has no cancellation mechanism for already dispatched tasks, and series supports early cancellation by passing a true value to its done callback. EV::Future is aimed at people who need very fast, low-overhead async control flow inside an EV-driven program and prefer a minimal API over heavier promise or future libraries.

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.

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.

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.