CPANscan

App::Netdisco is an open source, web-based network management application that inventories and maps your switching and routing infrastructure by collecting SNMP and related data into a PostgreSQL database and exposing a web UI and command line tools for discovery, reporting and remote port control. It helps you find a device by MAC or IP and show the switch port it lives on, change port state, VLAN or PoE, produce inventory reports by vendor, model or OS, and visualise network topology, while backend daemons handle polling and interactive actions. The project ships a built‑in web server, backend worker scripts and utility commands such as netdisco-deploy and netdisco-do, runs on Perl 5.10+ with PostgreSQL 9.6+, and is available as container images and a live demo. Recent releases added observability endpoints and API improvements including /health and /metrics for monitoring, a /api/v1/statistics endpoint, and richer PoE and power module data in the API, making it easier to integrate Netdisco into modern monitoring and automation workflows.

DateTime::Lite is a lightweight, drop-in replacement for DateTime that gives you the same public API with fewer dependencies, faster startup, and lower memory overhead while keeping accurate timezone and locale behaviour. It reads official IANA tzinfo binaries and stores compact zone data in an included SQLite database, evaluates future DST rules from the POSIX footer using an XS implementation of the standard tzcode, and offers an optional process-level memory cache for high-throughput services. You get full Unicode CLDR and BCP47 locale support including the ability to infer an IANA timezone from a locale tag, XS-accelerated calendar arithmetic with a pure-Perl fallback, convenient constructors like new, now and from_epoch, rich formatting and arithmetic, and non-throwing error handling that returns exception objects. It is especially useful for short-lived scripts and CLI tools that benefit from quicker startup and for applications that need robust future-proof timezone calculations without preloading large Perl locale trees. The recent v0.5.0 release adds timezone abbreviation resolution and safer handling of missing SQLite math functions by supplying user-defined functions when needed.

Wikibase::Datatype::Print provides simple pretty-print helpers for objects from the Wikibase::Datatype family. Use the exported print function as print($obj, $opts_hr) to get a human-friendly string in scalar context or a list of formatted lines in list context. It handles main Wikibase types such as Item, Lexeme, Mediainfo and Property and relies on a collection of focused submodules to format values, statements, references, senses, sitelinks and common value types like time, quantity and globe coordinates. The function will raise an error for unsupported objects. This module is handy whenever you need readable, consistent textual representations of Wikibase datatypes for debugging, logging or basic display and it integrates with the rest of the Wikibase::Datatype toolkit.

Devel::CallParser provides an XS-level C API that lets extension authors attach custom argument parsers to Perl subroutines so calls can be parsed by C code instead of relying solely on Perl's default parser. It supplies header files and linkable objects at build time and exposes a central cv_set_call_parser primitive plus a suite of helper parsers for parenthesised, nullary, unary, list, block-and-list and prototype-driven argument forms, making it useful when you need to implement nonstandard call syntax or custom compile-time argument handling in an XS module. The facility is most effective on modern Perls, with limited support on Perl 5.11.2–5.13.7 and full functionality on 5.13.8 and later, and it only triggers for unqualified subroutine names. The author has fixed portability and core-interaction issues in recent releases so generated headers work across API-compatible Perls and several incompatibilities with older Devel::Declare and Data::Alias versions have been addressed.

Music::SimpleDrumMachine is a lightweight Perl module that turns a MIDI output into a simple, real‑time 16th‑note drum machine you control from code, letting you define named "parts" and "fills" as Perl subroutines that return per‑instrument 16‑step patterns. It handles tempo, phrase length, subdivisions, velocity range and basic multi‑timbral channeling, comes with sensible defaults for common percussion MIDI numbers, and includes example scripts to list devices and build grooves so you can get playing quickly. Triplets are not supported, but you can customize drums, assign channels, toggle automated fills, and use randomised velocity for a humanized feel. Recent updates removed an unnecessary dependency and improved the example programs and groove syntax, making it easier to install and experiment with.

Music::Drummer is a lightweight, friendlier alias for the MIDI::Drummer::Tiny module that exists to make drum- and drumming-related functionality easier to find and use in Perl projects. It provides the same simple API for creating and controlling MIDI drum patterns so you can instantiate a drummer object and call methods like count_in and playback, but it does not add extra features beyond the underlying module. Use Music::Drummer when you want straightforward MIDI drumming support and better discoverability on CPAN.

MIDI::Drummer::Tiny is a lightweight Perl toolkit for programmatically creating drum parts and exporting them as MIDI files, with sensible defaults to get you started quickly. It provides ready-made metronomes for many time signatures, named percussion patches, duration constants, and helper methods for patterns, synchronized voices, fills, rolls, flams, crescendo effects, tempo and time‑signature control, and beat counting so you can script realistic drum parts rather than operate a GUI drum machine. The module is aimed at developers who want to build drum sequences in code and optionally use soundfonts for playback. Recent releases fixed Windows compatibility and added a Grooves helper and documentation improvements.

IO::Trace is a lightweight Perl tool for recording a spawned program's standard input, output and error activity, producing a strace-like, platform-independent log of reads, writes and closes for STDIN, STDOUT and STDERR without altering the data. It uses IPC::Open3 rather than ptrace so it works on Linux, macOS, Windows/Cygwin, FreeBSD and similar environments and is handy when you need a portable record of a program's terminal I/O. Be aware it turns the child's STDIN into a pipe so commands that require a TTY may break and it will not trace reads or writes to other files or file descriptors beyond the three standard streams. Recent updates added argument sanity checks, a version flag and improvements for redirect-to-file logging and broader compatibility.

Debug::Easy is a lightweight Perl logging helper that makes it simple to add colorized, multi-level debug and status output to scripts with minimal fuss. It provides named methods for common log levels from errors up through warnings, notices, info, verbose and two tiers of debug, writes to STDERR or a supplied filehandle, and stamps each message with a customizable prefix that can include time, date, calling location, process or thread info and automatic benchmark timings so you can spot slow spots quickly. Output can be ANSI colored or plain text, complex data structures are pretty-printed when available, and you can create multiple independent logger instances with their own settings. The author notes fork and thread caveats where duplicated objects may misalign padding, so forking code should create separate loggers or write to separate files. Recent releases focused on performance and robustness with numerous optimizations and token fixes, refined color handling and reduced overhead to keep logging from noticeably slowing your programs, making this a handy choice if you want readable, configurable debug output without reimplementing logging logic.

Tailscale is a Perl wrapper around the tailscale-rs library that lets a Perl program join a Tailscale mesh and make peer-to-peer TCP connections without running a separate tailscaled daemon. It calls the libtailscalers.so shared library via FFI, so you must build tailscale-rs and point TS_LIB_PATH at the directory containing that library. You create a node by supplying a path for its JSON state and an optional auth key, then you can obtain the node's Tailscale IPv4 address, open TCP streams to other tailnet peers, or listen for incoming connections, and shut the node down when done. This module is useful if you want to embed secure Tailscale networking directly into Perl services or scripts and are comfortable building the underlying Rust library.

Common::CodingTools is a compact toolkit of readable boolean and state constants plus small but handy file and string utilities for everyday Perl work. It provides named constants like TRUE/FALSE, ON/OFF, ACTIVE/INACTIVE and others to make conditionals clearer, plus functions such as slurp_file for reading a whole file, ltrim/rtrim/trim and center for string handling, tfirst for title-casing, uc_lc (aka leet_speak) for playful case alternation, and schwartzian_sort for efficient decorated sorting. You can import everything or pick specific groups with tags like :functions or :constants so you only bring in what you need. Recent updates fixed the schwartzian_sort implementation and added leet_speak as an alias for uc_lc. If you want a lightweight, practical set of helpers to avoid reimplementing common tiny routines and to improve code readability, this module is worth checking out.

App::DrivePlayer is a lightweight GTK3 desktop music player that streams audio files directly from your Google Drive, so you can listen without keeping full local copies. It builds a local SQLite library of scanned folders and tracks for quick browsing and playback, and it can sync track metadata to and from a Google Spreadsheet so tag edits and playlists can be shared across multiple devices. The package provides a GUI entry point (App::DrivePlayer::GUI) and an installed drive_player script, making it a good fit if you store music in Drive and want a simple desktop app to play and manage that collection.

Ragnetto::Console is a lightweight Perl utility for controlling ANSI-capable terminals, making it easy to clear the screen, set foreground and background colors, move and hide the cursor, change cursor shape, position text, set the window title, query console size, and read single key presses without waiting for Enter. It bundles a convenient write function that applies colors and positioning in one call and a reset routine to restore defaults, so it is well suited to small terminal UIs, colored status output, interactive prompts, simple games, and scripts that need precise cursor control. This initial release was ported from a Lua version and adds ANSI color support plus cross-platform input handling, and it is distributed under the same terms as Perl.

Long::Jump lets you mark a named point in execution with setjump and later unwind out of deeply nested call frames back to that point with longjump, optionally returning a list of values to the setter. It is a Perl-level analogue of C's longjmp but safer because jumps only move upward in the call stack and you cannot jump into arbitrary frames. setjump runs a block and yields undef when no longjump occurred or an array reference containing the returned values when longjump is used, and you may nest multiple jump points provided they use unique names. Calling longjump without a matching setjump throws an exception, and the recent addition of havejump lets you test whether a named jump point is currently active before attempting a jump. This module is handy when you need a controlled way to abort deep call chains and deliver results to a single handler.

HV::Monitor is a small Perl module for collecting and reporting statistics from hypervisors using a pluggable backend system with a simple object API. You create an instance, load a backend (the default is CBSD) and call run to execute the backend poller and return status while emitting the gathered metrics, which previously printed to STDOUT. The module is lightweight and script-friendly, with recent changes adding -q, -w and -o flags so output can be written to files instead of always printing, and the changelog shows ongoing backend fixes and enhancements for Libvirt/QEMU and bhyve. If you need an easy way to poll hypervisor metrics from Perl and wire those results into scripts or monitoring workflows, HV::Monitor is worth a look.

Horus is a high-performance XS UUID/GUID generator for Perl that implements all RFC 9562 versions (v1-v8) plus NIL and MAX and offers ten output formats including hyphenated, hex, URN, base32/64, Crockford and raw binary. It provides both procedural functions and an OO interface for single or bulk generation, supports deterministic namespace UUIDs (v3 and v5), time-based and sortable variants (v1, v6, v7), and handy utilities for validation, parsing, comparison and format conversion. Written with no external C library dependencies and optimized with random buffering and precomputed tables, Horus is designed to generate millions of v4 UUIDs per second while minimizing Perl/C crossings. Recent releases tidy up internal XS/op handling and pp code and include platform fixes for clock_gettime and threaded Perls to improve stability. If you need a fast, flexible UUID generator with broad format and version support, Horus is a solid choice.

WWW::PayPal is a Perl client library for PayPal's REST API that makes it easy to integrate checkout and recurring billing into Perl applications. It implements Orders v2 for one‑time payments and Billing Subscriptions v1 for recurring plans, and exposes controllers for orders, payments, products, plans and subscriptions so you can create orders, redirect buyers to approve payments, capture payments, issue refunds and manage subscription lifecycles. Authentication uses a PayPal client ID and secret and the module supports sandbox mode for testing. It caches OpenAPI operation tables to avoid runtime spec parsing and is a straightforward, Perl-native way to work with PayPal's modern REST endpoints.

Authen::Passphrase is an extensible Perl framework that models hashed passwords as objects and gives a consistent, high level API for creating, checking and serializing passphrase verifiers. You can construct recognisers from common encodings such as Unix crypt strings or RFC 2307 userPassword values, ask an object whether a candidate passphrase matches, and emit the stored form back as a crypt or RFC 2307 string; very weak schemes may also expose a recoverable passphrase. The distribution implements a wide range of historical and practical schemes for compatibility but recommends using modern choices such as SaltedDigest or BlowfishCrypt for new applications. The documentation also explains practical concerns like side‑channel timing exposure and limitations of doing cryptography in Perl, so you can assess whether extra hardening is needed. Recent maintenance updates fixed various loading and compatibility bugs and improved the documentation to emphasise preferred algorithms and side‑channel considerations.

Net::Async::Kubernetes is an asynchronous Kubernetes client for Perl built on IO::Async that gives you Future-based CRUD plus high-level helpers for pod logs, port-forwarding, exec and attach sessions, file copy to and from pods, and resilient watch streams. It integrates with Kubernetes::REST and IO::K8s so you work with inflated resource objects and the same short class names and CRD support you already know, and it resolves authentication from explicit server/credentials, a kubeconfig file, or in-cluster service account tokens automatically. All operations return Futures and the watcher includes automatic reconnect, resume via resourceVersion, and per-event callbacks so you can build event-driven tooling and controllers without blocking. Recent work adds a minimal controller runtime you can bind to a client for keyed workqueues and serialized reconcile dispatch, active exec and attach APIs with websocket duplex sessions and session helpers, cp_to_pod and cp_from_pod file-transfer helpers built on exec, and a TLS fix for kubeconfigs that embed CA or client PEM blocks so mTLS works correctly. If you need a nonblocking, IO::Async-native way to script or run controllers and interactive pod sessions against Kubernetes from Perl, this module is a solid choice.

App::Run::Command::ToFail is a small Perl base class that provides a simple framework for building a command line tool which runs another program and reports its outcome as an exit code. It offers a constructor and a run method that returns 0 on success and 1 on error, and relies on Getopt::Std for argument parsing and Readonly for constants. The module is minimal and intended as a starting point for utilities that need to invoke a script or binary and detect failure conditions, as illustrated by the included example that executes a temporary Perl script and returns an appropriate exit code. The code is lightweight, easy to subclass, and available on GitHub under a BSD 2-Clause license.

Net::Nostr is a Perl implementation of the Nostr decentralized messaging protocol that provides both client and relay functionality along with a rich set of helper modules for keys, events, message parsing, identity and signing, and many NIP extensions. It makes it straightforward to build WebSocket clients and run relays from Perl using simple factory methods and includes support for things like encrypted direct messages, relay info and management, media attachments, bech32 identifiers, threads, reactions, channels, and application-specific data. The distribution targets a wide range of NIPs so you can interoperate with modern Nostr features without wiring them up yourself. Recent releases added native TLS listener support for relays and exposed TLS options on the client so secure wss connections are easy to configure. If you want to build or integrate Nostr-capable applications or run relays from Perl, this module collection provides a comprehensive, production-minded toolkit.

Geo::H3 is a Perl object oriented wrapper for Uber's H3 geospatial indexing library that exposes H3 functionality through libffi and FFI::Platypus so you can work with H3 cells from Perl code. H3 partitions the globe into hexagonal cells and Geo::H3 makes it easy to convert between latitude and longitude and H3 indexes, to find a cell center, to get cell boundaries, to enumerate neighbors, and to measure distances, all using simple Geo::H3, Geo::H3::GeoCoord and Geo::H3::Index objects. The module presents coordinates in decimal degrees on the Perl side and supports H3 indexes as 64 bit integers or strings, while a lower level Geo::H3::FFI interface talks directly to the C structures when needed. This is a good fit if you need spatial indexing, aggregation, tiling, or proximity queries in Perl, but note it targets the stable H3 3.x API and does not support the incompatible 4.x line. The distribution is MIT licensed and requires installing the libh3 C library from the H3 project.

Spreadsheet::Write is a lightweight, row-oriented writer for spreadsheet files that lets you build CSV, Excel 97 (XLS) and Excel 2007 (XLSX) documents one row at a time with a single, consistent API, making it ideal for generating reports and data dumps. You create a new writer with new(file => ...), optionally let it auto-detect format from the filename or supply an IO handle, then push rows with addrow or batches with addrows, using simple scalars or hashrefs to attach styles, types, formatting and comments to individual cells, and use addsheet, freeze and close to manage worksheets and finalization. Many formatting options can be defined once as named styles and reused, unsupported features are safely ignored for formats that do not support them, and the module caches formats for better Excel performance. Recent maintenance cleaned up dependencies, added a license, and improved IO handle and format handling to make the module easier to install and use.

App::MARC::Filter is a small Perl base class that powers a command line utility for reading MARC21 XML bibliographic records and extracting or filtering records by simple criteria such as tag and subfield values. It supplies a constructor and a run method to drive a CLI workflow that accepts a file and matching arguments, returns standard exit codes, and can handle MARC XML input and common compressed formats via existing CPAN modules. The module is aimed at librarians, data managers, and developers who need a lightweight, scriptable way to count or pull MARC records from files and integrate that capability into larger workflows. It is intentionally minimal, depends on well known CPAN libraries, is available on GitHub, and is distributed under the BSD 2-Clause license.

Geo::H3::FFI is a Perl FFI binding that exposes the H3 geospatial hexagon grid C library to Perl programs. It lets you convert latitude/longitude to H3 indexes and back, get cell centroids and boundaries, traverse neighborhoods and lines (k-ring, hexRange, h3Line), move between resolutions, compact and uncompact sets, perform polygon polyfills and outline extraction, work with directed edges, and access utility functions for areas, edge lengths and distances. The module supplies FFI-friendly structs and wrapper helpers that return Perl data structures for convenient use. Note that it targets the H3 v3.x API and is intended to be used with H3 v3.7.2 because the H3 library underwent an incompatible rewrite in v4. This is a good choice if you want full H3 functionality from Perl without writing XS code.

Treex::PML is a Perl library that implements the Prague Markup Language (PML) to read, write and manipulate linguistically annotated treebanks and related XML-based annotation formats. It provides a high-level object model for documents, trees and nodes, schema-aware instances and utility types, pluggable I/O backends and optional on-the-fly XSLT conversion so you can load, validate, convert and traverse complex annotation layers without dealing with raw XML. The package uses a Factory pattern so you can swap in customized class families, includes helpers for resource-path resolution and deep cloning, and still supports older FS-format treebanks used by the TrEd ecosystem. If you work with dependency or constituency treebanks, corpus conversions or tooling around PML, this module gives you a ready-made, extensible Perl API; recent updates fixed saving of relative resource paths and made the test suite compatible with Perl 5.10.

Finance::Tax::Aruba is a Perl toolkit for calculating Aruba-specific taxes, focused mainly on individual income tax and payroll-related components at a practical, user level. It handles yearly tax rules across recent years and includes support for pensions, employer- and employee-paid premiums, fringe and non-fringe benefits, child deductions, and computations of employer social and government costs, with a bundled payroll helper script (bin/loon.pl) to simplify typical use cases. The distribution is actively maintained and recent releases added 2025 support and fixed a bug in the lowest income tier for 2023/2024. The author lists further planned improvements such as elderly deductions, dual-household calculations, SVB fees and other tax types, so the module is a good fit if you need a straightforward Perl-based way to model Aruban individual payroll and income tax today and want a project that is continuing to gain features.

Protocol::Gearman is an abstract base class that provides the common plumbing for implementing Gearman clients and workers rather than a drop-in tool for end users. It defines the minimal methods an implementation must supply, such as a send method to transmit bytes, new_future to create Future objects for asynchronous responses, and a place to stash Gearman-related state, and it supplies a suite of helpers for packing, parsing and sending Gearman protocol packets, dispatching received messages and handling simple request patterns like echo. The module also offers a convenient new_prototype constructor so you can build lightweight prototypical client or worker objects with code references, which is handy for tests and small scripts. Recent updates refreshed the codebase for newer Perl features and fixed a Future API compatibility issue, so the module is current and suitable as the foundation for custom Gearman implementations.

Apertur::SDK is the official Perl client for the Apertur API that makes it simple to manage upload sessions, send images, verify webhooks, and perform full CRUD on resources like destinations, API keys, webhooks, and encryption keys. You create a client with an API key or OAuth token and the module auto-detects sandbox versus live environments from the key prefix, then exposes focused resource accessors for uploads, polling, stats, and more so you can integrate Apertur workflows with a few straightforward calls. It supports plain and encrypted image uploads, long polling to retrieve processed assets, and helpers to verify webhook signatures, with encryption features enabled on demand via optional Crypt::OpenSSL::RSA and CryptX dependencies. Errors from the API are raised as typed Apertur::SDK::Error objects so you can catch authentication, rate limit, validation, and not found conditions explicitly. The SDK relies on common Perl HTTP and JSON libraries and is released under the MIT License.

Test::Which is a small testing helper that makes it easy to skip unit tests when required external programs are not available or do not meet version requirements. You can declare program requirements at compile time or check them at runtime with which_ok, and the module will locate executables on PATH or accept absolute paths, probe their version output using a built in heuristic or a custom flag or extractor, and compare versions with standard operators or regexes. Results are cached for the life of the process to avoid repeated invocations and verbose output can be enabled via environment variables so your test runs show the detected versions. The module works across Unix, macOS and Windows though platform quirks are noted and unusually formatted version output may need a custom extractor or explicit version_flag. Recent updates added a configurable timeout for program probes, better Windows handling and fixes to ensure messages are not lost.