CPANscan

CGI::ACL is a lightweight Perl module for CGI scripts that decides whether a client may run a script by checking the client's IP address and geographic origin. You can allow or block individual IPs or CIDR ranges, permit or deny specific countries, and optionally integrate with CGI::Lingua to detect the client's country. It also offers a deny_cloud helper that uses verified reverse DNS lookups to block traffic from major cloud providers, which is handy for reducing bot and scraper traffic. Restrictions are evaluated with the all_denied method and the module supports runtime configuration via environment variables or Object::Configure. Note that IP-based rules can be circumvented by VPNs or proxies.

Mo::utils::IRI is a compact helper for Perl projects using the Mo lightweight object system that provides a single exported function, check_iri, to validate that an object attribute holds a well-formed IRI. You call check_iri($self, 'key') and the module uses the IRI library to parse and validate the value, emitting an Error::Pure error if the value is invalid and otherwise returning undef, so it slips into existing Mo-based validation flows with minimal fuss. It depends on the IRI and Error::Pure modules for validation and error reporting. Recent updates improved how the IRI constructor is used, added support for errors emitted by the IRI module, and included tests to strengthen reliability.

Crypt::OpenSSL::PBKDF2 is a thin Perl wrapper around OpenSSL's PBKDF2 key derivation function that lets you derive cryptographically strong binary keys from passwords or other binary secrets. You call derive for text passwords and derive_bin for binary passwords, supplying the password, salt and its length, iteration count and desired key length, and you can pick the hash algorithm (default SHA1) from any digest supported by your OpenSSL installation. The module produces raw binary keys suitable for use as encryption keys or password verifiers, runs fast because it uses OpenSSL, and will croak on error. It requires the OpenSSL library to be installed and supports modern digests such as SHA-2, SHA-3 and others as they are provided by OpenSSL.

Test2::Harness2::ChildSubReaper is a tiny XS wrapper that lets a Perl process ask a Linux kernel to become a "subreaper" so orphaned descendant processes are adopted by it instead of init, which helps long-running harnesses reliably wait for and clean up grandchildren that double-fork or call setsid. It exposes two simple functions, have_subreaper_support() to detect whether the build and platform support PR_SET_CHILD_SUBREAPER and set_child_subreaper() to enable or disable the flag on the current process. The API is deliberately minimal, it returns success or failure and sets errno on error rather than throwing exceptions, and it is safe to install on non-Linux systems because the XS code falls back to a stub that returns ENOSYS when the kernel feature is not available.

NBI::Slurm is a Perl toolkit for creating, configuring and submitting jobs to SLURM-managed HPC clusters. It provides NBI::Job and NBI::Opts classes so you can define a job name, command, output and error files, and resource requests such as queue, threads, memory and walltime, generate the SLURM header and submit or track the job from Perl code. The distribution also bundles command-line utilities for common tasks like submitting jobs, listing queues and interactively inspecting jobs, making it easy to integrate SLURM workflows without writing raw batch scripts. Recent updates improved the interactive viewer so you can inspect StdOut and StdErr files and added persistence of completed jobs for later inspection. This module is intended for Linux SLURM environments and aims to simplify routine HPC job management.

Chandra provides Perl bindings to the webview-c library so you can build cross‑platform desktop UIs with HTML, CSS and JavaScript while driving them from Perl. It gives a simple API to create and show a window, run or control the event loop, evaluate or dispatch JavaScript, inject CSS and bind JavaScript calls back to Perl callbacks, and to control window properties like title, size and fullscreen. Chandra supports macOS (WebKit/WKWebView), Linux (WebKitGTK) and Windows, where it prefers the modern Edge/WebView2 runtime but will automatically fall back to the legacy MSHTML engine when WebView2 is not present, so you should install the WebView2 runtime for best web feature support and ensure WebView2Loader.dll is available. If you want a higher level application framework or extra helpers look at the companion Chandra::* modules such as Chandra::App. Recent releases added an Edge/WebView2 backend for Windows for Chromium rendering and new components like Chandra::Canvas.

Image::Size is a lightweight Perl utility for quickly discovering an image file's width and height without loading the whole image into memory. You call imgsize with a filename, an open filehandle, or a scalar reference to in-memory data to get numeric width and height plus an optional type identifier, or use helpers html_imgsize and attr_imgsize to produce ready-made HTML width/height attributes or option lists for CGI and Tk. It recognizes a long list of common formats such as GIF, JPEG, PNG, TIFF, BMP, PSD, SWF, WebP and icons, and will fall back to Image::Magick when needed to handle other types. The module caches results for filenames and checks file mtimes to avoid repeated work, offers controls like $NO_CACHE to disable caching, and exposes its cache so you can tie it to shared memory in multi-process web servers. There are a few format-specific knobs such as GIF_BEHAVIOR to choose how animated GIFs are measured and PCD_SCALE to pick a PhotoCD resolution, and note that caching only works for filenames and Image::Magick requires filenames rather than handles.

Net::Z3950::FOLIO is a Perl library that implements the application logic of a Z39.50 server for querying and retrieving bibliographic, holdings and item data from a FOLIO inventory back end, and is the engine behind the z2folio server program. It is configured from a JSON file and exposes two simple entry points: new() to create the service and launch_server() to start a YAZ-backed Z39.50 server that speaks standard record syntaxes and element sets and can produce MARC and OPAC-style records with configurable post‑processing. Note that version 4.x switched to FOLIO’s new expiring-and-refreshing token authentication model so it requires FOLIO releases from Poppy onward, and recent updates add configurable XML element sets (via XSLT) for formats such as MODS and improved handling of holdings and item-level data. If you need a ready-made Z39.50 gateway for a FOLIO instance, this module provides a focused, production-ready solution.

TUI::Vision is a Perl Text User Interface framework intended as a native port of Borland's Turbo Vision 2.0 for modern Perl. The current release only reserves the TUI:: namespace and provides stub modules as placeholders while the existing TV:: codebase is migrated, so it does not yet include usable widgets or runtime drivers. If you need a working TUI toolkit right now this package will not meet that need, but it is the groundwork for a planned toolkit that will add driver abstraction, a unified object and event model, dialogs, validation, and standard widgets. The initial 2.0.0 release (2026-04-16) establishes the namespace, adds stub modules for all TUI::* components, and includes a toolkit placeholder, making this module relevant if you want to follow or contribute to the upcoming migration and development.

Win32::Pipe::PP is a pure-Perl implementation of Windows named pipes designed to be a drop-in replacement for the original XS-based Win32::Pipe. It exposes the familiar new, Read, Write, Connect, Disconnect and Close methods so existing code that talks to named pipes can run without rebuilding XS modules. The module uses Win32::API under the hood and integrates with Win32::IPC, even providing a raw handle accessor, so it fits into typical Windows IPC workflows. It is useful when you need pipe functionality on Windows but cannot install or build XS modules, and it is distributed under the MIT License while referencing other open source components.

Win32::Console::DotNet gives Perl programmers a familiar .NET-style System::Console interface for working with the Windows console, wrapping Win32::Console to expose high-level properties and methods for reading keyboard input, writing formatted text, controlling cursor position, colors, buffer and window size, moving screen regions, handling standard in/out/error streams, and playing beeps. It is aimed at anyone who needs precise, programmatic control of a Windows terminal or who wants to port or mimic .NET console code in Perl. The module handles encodings and code page aliases, supports locking for threads, and returns rich key info for interactive input. It requires Win32::Console and other small helpers and is MIT licensed and actively maintained with recent releases focused on encoding support and a stream of bug fixes and test improvements.

Win32API::Console gives Perl programs direct access to the native Windows Console API so you can control consoles, screen buffers, input events, text attributes, fonts, code pages and window behavior from Perl on Windows. It wraps and extends the Win32::Console XS interface and exposes both ANSI and UTF-16LE wide variants of the classic API calls as well as convenient wrappers that auto-encode Perl strings when appropriate. The module supplies structures and helpers for packing and unpacking console data, functions to allocate or attach consoles, read and write console output and input records, manipulate cursor and window size, and set code pages and control handlers. The API was modeled on the original Windows documentation so you can usually follow MSDN examples, but not every function is supported on every Windows release and there are known platform quirks around UTF-8 on older Windows versions. Use this module if you need low level, Windows-native console control from Perl, especially when Unicode handling or advanced screen buffer operations are required.

Alien::fpm is a lightweight helper for Perl modules that need the fpm packaging tool, handling discovery or installation so you can invoke fpm from Perl without managing RubyGems yourself. It exposes paths such as bin_dir and fpm_gem_home that you can add to PATH and GEM_PATH, and by default on shared installs it will fetch fpm from RubyGems. If you prefer a repository build you can set ALIEN_FPM_GIT_URL to install from git and use ALIEN_FPM_GIT_BRANCH or ALIEN_FPM_VERSION to select a branch or version. This makes it easy for other Perl code to rely on a usable fpm executable while leaving installation and version choices to simple environment variables.

Business::ISBN::Data is a small data-only companion for Business::ISBN that provides the official ISBN range assignments extracted from the ISBN Agency's RangeMessage.xml. Business::ISBN will load it automatically so most users do not need to touch it, but you can point the module at a newer or alternate RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable before loading Business::ISBN. If no external file is available it falls back to embedded data and also looks in the current working directory to help with app bundlers. You must use Business::ISBN 3.005 or later because the data structure changed to correct an ISBN-13 issue. The module includes guidance for regenerating the embedded data, is maintained on GitHub, and is distributed under the Artistic License 2.0.

Test::QuickGen is a lightweight Perl toolkit for creating random test data such as monotonic numeric ids, ASCII and UTF-8 strings, sanitized UTF-8 strings that keep only letters, numbers and whitespace, multiword strings, random integers in a range, optional (nullable) values and random picks from a list. The id generator yields a process‑local counter that increases from zero and the various generators let you control length and character sets while producing uniform randomness suitable for testing and fuzzing. The module is fast, has minimal dependencies, and exposes convenience import tags so you can pull just the helpers you need into test scripts. These generators are not cryptographically secure and are intended only for testing and data generation.

MARC::Convert::Wikidata::Object is a Perl data object that models a bibliographic work or edition extracted from a MARC record for use with Wikidata conversions. It provides a clean API to hold and retrieve common bibliographic attributes such as title, subtitle, edition info, authors, editors, translators, ISBNs and ISSNs, publishers, series, page counts, publication dates, external identifiers and digital copies, plus specialized roles like illustrators, narrators and photographers. The module is intended for library and metadata workflows where you want a structured, validated representation of a book or edition before turning it into Wikidata statements and it performs type and array checks on inputs to keep data consistent. It is part of the MARC::Convert::Wikidata ecosystem and relies on a few small CPAN utilities for validation and error handling. Note that a few fields such as language formatting and some date handling are noted as TODO in the documentation.

Business::CAMT is a Perl toolkit for working with ISO20022 CAMT cash management XML messages such as CAMT.053 used by banks and accounting systems. It reads validated CAMT XML into predictable Perl data structures, can create messages from Perl hashes, and can write messages back out as XML or emit JSON or Perl dumps for inspection. The module handles schema versions with configurable matching rules, offers options to use readable long tag names and to enable Math::BigFloat for very large amounts, and reuses a compiled schema object to avoid expensive recompilation. Not every historic schema version is included so you may need to tune the schema matching policy for some files and the author notes higher-level abstractions and converters are planned but need sponsorship. If you integrate banking cash‑management files in Perl this module gives a practical, standards-aware foundation to parse, produce and inspect CAMT messages.

DateTime::Format::Lite parses and formats datetimes using familiar strptime-style patterns and returns lightweight DateTime::Lite objects, making it a compact alternative to DateTime::Format::Strptime for projects that prefer fewer dependencies. You can set locale and time zone, supply a zone_map to disambiguate abbreviations, and the module resolves timezone abbreviations live against an included IANA tzdata SQLite database so lookups stay current. Common formatting and parsing paths are XS-accelerated when a C compiler is available at install time with a pure-Perl fallback otherwise. Errors are exposed via an error object or can be made fatal, one-shot convenience functions strptime and strftime are provided for quick use, and the formatter can be serialized for transport or storage.

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.