CPANscan

MARC::Validator is a compact Perl toolkit for validating MARC bibliographic records by discovering and running field-specific plugins. It provides a simple API to list available validators and ships plugins that spot common cataloging issues such as malformed ISBNs, duplicate control numbers, mismatches between leader/008 and field content, missing index or illustration indicators, genre tags like comics or manga, and UDC syntax in field 080. The module uses Module::Pluggable to find plugins, produces readable reports and recommendations from each check, and is aimed at library developers and cataloguers who need automated, field-level validation of MARC data. The project is actively maintained and the recent 0.18 release tightened UDC (080) checking and fixed a plugin detection bug.

Business::UDC is a lightweight Perl class for parsing, tokenizing and validating Universal Decimal Classification (UDC) strings, returning an abstract syntax tree, a list of tokens, the original source string and any parsing error. Instantiate it with a UDC string and then call is_valid to check syntax or ast and tokens to inspect the parsed structure, which makes it handy for library cataloging tools, import/validation pipelines and any system that needs to interpret UDC notations. The module focuses on syntax-level processing rather than classification logic, and the recent 0.04 release added detection of embedded spaces that are not allowed in UDC input and expanded tests for invalid strings.

MARC::Leader is a small utility for working with the leader portion of MARC bibliographic records. It converts a 24-character MARC leader string into a Data::MARC::Leader object and can serialize that object back into a leader string, so you can parse, inspect and rebuild record leaders in scripts and data pipelines. The module validates leader length and numeric fields and reports errors for malformed values, and it offers an optional verbose mode and integration with Data::MARC::Leader and helper printers for readable output. Recent updates added stricter numeric error reporting and a few robustness fixes, making it a reliable choice when you need programmatic access to MARC leader data.

Medusa is a lightweight Perl module that adds automatic auditing to subroutines simply by tagging them with the :Audit attribute. When enabled, it logs each call with its arguments and the return values so you can trace data flow, debug problems, or meet compliance requirements without altering your business logic. It is configurable at import time with options for logger class, log level and output file and it supports custom logger classes that implement a constructor and error/info/debug methods. Use is as simple as adding use Medusa to a package and annotating the subs you want audited, making it a practical way to get runtime visibility into method calls.

XS::JIT is a lightweight runtime JIT compiler that lets Perl programs compile and load C/XS code on the fly, making it a good fit when you generate C dynamically and need faster compile-and-load cycles than Inline::C. It skips Inline::C's parsing and xsubpp steps and invokes the C compiler directly, generates XS wrappers or aliases for XS-native functions, and caches compiled modules for quick reuse. The module exposes a simple compile API plus helpers to generate the full C source without compiling, check the cache, and return the proper INC and LIB flags so other XS code can link against its C API. It also provides macros to simplify argument handling and compatibility shims for code written for Inline::C. Recent releases improve error reporting by capturing compiler and linker stderr and fix Windows, Cygwin, and macOS linking issues so builds are more reliable across platforms.

Text::PO is a Perl library for reading, editing and writing GNU gettext PO and POT files and it also ships tools to export those translations to JSON and a small JavaScript loader for browser use. You can parse a PO, inspect or modify entries as objects, dump the result back to a .po text or serialize to a string, produce a hash or JSON for integration with other tooling, and synchronize or merge PO data with existing files or filehandles. The distribution includes a companion Text::PO::MO for .mo binary files and command line scripts for converting between PO, MO and JSON, and the parser supports optional nonstandard include directives with recursive, relative-path handling and circular-include protection. The module stores all state per object so it is thread-safe and offers convenience features such as meta handling, plural-form support, and save-as-JSON for faster loads and JavaScript consumption. Recent 1.0.0 work tightened plural handling and removed a global that could affect thread safety while improving the underlying globals handling, making the module more robust for concurrent use.

CPAN::Maker is a command-line tool and small toolchain for turning a Perl project into a CPAN-style distribution by locating your modules, scripts and tests, resolving dependencies, generating a Makefile.PL and assembling a tarball ready for upload. It prefers a YAML buildspec that describes paths, dependency files, extra files and metadata and can run the supplied make-cpan-dist bash wrapper to clone git repos, run dependency scanners (scandeps or Module::ScanDeps::Static), copy test and executable files and build the final tarball, while direct invocation will at minimum emit a Makefile.PL for you to tweak. The tool supports fine-grained options for dependency lists, min Perl version, inclusion of extra files, and logging, and environment variables let you preserve the generated Makefile.PL, skip tests or enable debug output for troubleshooting. In the recent 1.8.0 release the utility gained support for creating man-links so executables can point to a module's man page and fixed how script man pages are generated, making it a good fit if you want a repeatable, configurable way to prepare and package Perl modules for CPAN.

XML::PP is a tiny, pure-Perl XML parser intended for simple parsing jobs where heavier libraries are unavailable or cannot be installed. It provides a parse() method that produces a straightforward tree of nodes with names, namespaces, attributes and children, and a collapse_structure() helper that converts that verbose tree into a compact hash much like XML::Simple does, with repeated child elements collected as arrays and empty text nodes omitted. You can create the parser with options such as strict mode, warning-on-error, and a pluggable logger, and it supports basic namespace and attribute handling. The author recommends this only for lightweight scenarios and suggests using XML::Simple or XML::LibXML for most real-world needs, so reach for XML::PP when you need a dependency-free, easy-to-install parser for small tasks.

Physics::Ellipsometry::VASE is a Perl module for fitting optical thin-film models to variable-angle spectroscopic ellipsometry data, letting you extract film thicknesses and optical constants by matching model predictions for Psi and Delta to measurements. It reads simple whitespace tables or the native J.A. Woollam VASE format and will use provided uncertainty columns as fit weights, you provide a model routine that computes Psi and Delta from wavelength, angle, and parameters, and the module handles the Levenberg-Marquardt optimization via PDL::Fit::LM, numerical Jacobian estimation, and returns fitted parameters along with covariance and model values. It also offers multi-angle plotting through PDL::Graphics::Gnuplot and includes example scripts for common models, and note that the documented "layers" setting is informational only so your model function must encode the actual layer stack.

Iterator::Flex is a Perl framework for building and using stateful, feature-rich iterators that can rewind or reset, serialize their state, report or throw on exhaustion, and expose history like current and previous values so you can write more predictable streaming code and adapters that wrap other iterators. It ships with a set of common iterator implementations and adapters and has documentation for both using and authoring custom iterators, making it useful when you need more than a simple next() loop, for example to chunk, buffer, zip, permute, gather, or otherwise adapt streams of values. The distribution is still described as alpha quality, but it is actively maintained and recent releases fixed several edge-case bugs and improved exhaustion and capacity validation; note it is released under the GPLv3 license. If you need rewindable, restartable, or serializable iteration semantics in Perl, this module is likely relevant, otherwise stick to simpler iterator utilities.

Plack is the standard Perl toolkit for PSGI that acts like "superglue" between web frameworks and web servers, making Perl web applications portable and easy to run on many backends. It provides server adapters so the same application can run under CGI, FastCGI, standalone HTTP servers, or Apache without code changes. Plack also includes middleware and a simple DSL to compose and wrap apps, a command line runner called plackup, a convention for .psgi application files, request and response helper objects, and testing helpers so you can build, extend, deploy, and test web apps in a consistent way. If you write or deploy web applications or frameworks in Perl and want a server-agnostic, composable stack similar to Ruby Rack or Python WSGI, Plack is the relevant toolkit.

EV::Memcached is a high-performance asynchronous memcached client for Perl built on the libev event loop and implemented in pure XS so no external C client library is required. It implements the memcached binary protocol directly and supports pipelining, multi-get via GETKQ with a NOOP fence, and fire-and-forget quiet commands for maximum throughput. The client works over TCP or Unix sockets, offers optional SASL PLAIN authentication, configurable timeouts, flow control via a max_pending limit and a local waiting queue that can optionally replay across reconnects, and predictable lifecycle semantics where every pending callback is guaranteed to fire with a disconnect reason on teardown. Callbacks follow a simple (result, err) convention and exceptions inside callbacks are trapped so the libev loop is not unwound. Note that keys and values are treated as raw byte strings so you must encode and decode UTF-8 yourself and that SASL requires a memcached build with SASL support. If you need nonblocking, evented access to memcached from Perl or AnyEvent applications, this module provides an efficient, controllable client tuned for high throughput.

Starman is a fast, production-ready preforking PSGI/Plack web server for UNIX that runs any PSGI-compatible Perl application and manages a pool of worker processes for high concurrency and low latency. It uses a C/XS HTTP header parser for speed, supports HTTP/1.1 features like chunked transfer, keep-alive and pipelining, can listen on TCP or UNIX domain sockets, and integrates with Server::Starter for zero-downtime deploys while offering signal-driven controls for graceful restarts and dynamic worker scaling. Starman supports preloading for copy-on-write friendly memory usage, exposes the psgix.informational callback for sending 103 Early Hints, and is designed to sit behind a front-end proxy such as nginx for best results with slow clients. SSL support exists but is considered experimental and the server is explicitly UNIX-only. A recent important update fixes an HTTP request smuggling issue by giving Transfer-Encoding precedence over Content-Length in line with RFC 7230, addressing CVE-2026-40560.

Mojo::SQLite::Database::Role::InsertHelpers is a tiny add-on for Mojo::SQLite that gives your database object simple helper methods for common SQLite insert patterns, namely insert_or_ignore to perform INSERT OR IGNORE and skip rows that would violate constraints, and insert_or_replace (with insert_or_update as an alias) to perform INSERT OR REPLACE and overwrite conflicting rows. You enable it with with_roles on your Mojo::SQLite::Database and then call the methods with a table name and a hashref of column=>value pairs, which makes error-avoiding inserts and basic upsert-like workflows much easier to write. Be aware that using OR REPLACE can be destructive because it replaces the entire row and will clear fields you do not explicitly set, so use it only when full replacement is intended.

Qhull is a thin Perl interface to the well known Qhull geometry tools, letting you run convex hull computations, Delaunay triangulations and Voronoi diagram operations from Perl code. The current release is alpha quality and delegates work to Qhull::PP, which calls the qhull executable rather than linking the qhull library directly. That means you get Qhull's full capabilities but the module's API is still in flux and its option handling follows qhull's native style, so you may need to consult the qhull manual to use advanced features. If you need to integrate robust computational-geometry routines into scripts or prototypes and are comfortable with a wrapper around the external program, this module provides a straightforward way to do that.

Net::CIDR::Set is a Perl module for representing and manipulating collections of IP addresses and ranges using familiar set operations such as union, intersection, complement and difference. It accepts CIDR blocks, explicit address ranges or single addresses, automatically merges overlapping ranges and can handle both IPv4 and IPv6 sets though they cannot be mixed in one set. Common tasks like membership checks, adding or removing ranges, merging sets and testing subset or superset relations are provided, and you can iterate over individual addresses, compact CIDR blocks or arbitrary ranges and export results as arrays or as a compact string with several formatting options. The module is stable and practical for tasks like private address checks or network summarization, and recent work has modernized testing and tooling; a prior release also fixed a security issue that disallows IPv4 quads with leading zeros (CVE-2025-40911).

EV::MariaDB is a non-blocking MariaDB/MySQL client for Perl that plugs into the EV event loop and uses the MariaDB Connector/C non-blocking API to run database work without stalling your event loop. It provides asynchronous connect, query, and prepared-statement workflows with callback-based results, optimized query pipelining for higher throughput, streaming row-by-row reads for very large result sets, server-side prepared statements with BLOB streaming, and async transaction and connection utilities, plus optional automatic UTF‑8 handling and column metadata. The API distinguishes pipelineable query calls from exclusive operations so you can safely queue many reads while reserving certain calls for idle moments, and it includes helpers such as escape and graceful async close. Note that multi-statement queries only return the first result set to the call callback while secondary results are drained and errors from those statements go to the connection error handler. The module is well suited to event-driven, high-concurrency applications and the recent 0.06 release focuses on bug fixes, input guards, and a POD documentation overhaul.

Alien::cmake4 is an Alien distribution that makes the CMake 4.x build tool available to Perl builds by finding a system installation or downloading and installing a binary or building from source when necessary. It exposes simple helpers so you can add the CMake bin directory to PATH and get the executable name for invoking CMake from Perl code, and it integrates with the Alien::Build ecosystem for automated dependency management. By default it will try a binary share install on common platforms like Windows, macOS and mainstream Linux and will fall back to a source build on other systems, and you can control behavior with the ALIEN_INSTALL_TYPE environment variable or force a source build with ALIEN_CMAKE_FROM_SOURCE. This is useful if your project or an Alien plugin requires a consistent CMake 4.x runtime across machines or CI, and it aims to be the preferred, up to date way to supply CMake to Perl-based build workflows.

Git::Server is a drop‑in replacement for a standard SSH Git server that gives you far more flexible server-side hooks and fine-grained access control than stock Git. It lets you enforce per-repo and per-branch rules, restrict who can rewrite history or push specific files, whitelist commit author emails or client IPs, and trigger webhooks or instant deployments on pushes. The distribution also includes convenience tools such as a git-client wrapper, git-deploy for automated deployments, git-verify for sanity checks, and a proxy.url feature to mirror or sync repositories to remote targets from the server side. Setup is simple using SSH authorized_keys to invoke the server command, and the module auto-configures hooks and ACLs on first access. The project is actively maintained on GitHub and recent releases have tightened security and reliability for proxy syncing and improved repository verification and deployment handling.

PGPLOT::Device automates the tedious work of turning a user or programmatic choice into a valid PGPLOT device string so applications can consistently open interactive or hardcopy plots. It understands interactive devices like /xs and /xw and can auto‑increment window ids when you request multiple windows, and it also handles hardcopy specifications of the form filename/device with automatic file extensions and printf-style variable interpolation using ${var:format}. You create the object from a user spec, optionally supply variables or override filenames at runtime, and then call next or current to get the device string to hand to pgbegin or a PDL::Graphics::PGPLOT::Window. Utility methods let your code ask whether the device is interactive, ephemeral, constant, or would change on the next call so you can decide whether to prompt the user or reopen windows. The module notes that PGPLOT::Device::PGWin is often easier for interactive usage and that it does not yet know which output formats can hold multiple pages, so formats like PNG may produce multiple numbered files.

Business::CAMT reads, writes and validates ISO20022 CAMT cash-management XML messages and turns them into usable Perl data structures or JSON so you can process bank account statements and related payment data in your apps. It supports creating CAMT messages from Perl hashes, writing them back to XML, and offers flexible schema version matching when namespaces do not exactly match the distributed XSDs. You can toggle readable long_tagnames for clearer Perl structures and enable Math::BigFloat for very large amounts. The distribution includes templates and example scripts to get you started, and the module will auto-load and compile the required schemas as needed, though not every historical schema version is bundled so you may need to select a compatible version with the provided matchSchema rules. Recent updates clarified the module's scope and added the latest schemas to improve compatibility.

Music::ScaleNote is a compact Perl helper for moving a pitch within a musical scale or by semitones and returning a Music::Note object for the result. You configure a scale name and starting scale note and then call get_offset to move by scale degrees or step to move by half-steps, with support for ISO and MIDI note formats and an option to prefer flats over sharps. It is useful for algorithmic composition, scale-aware transposition, and MIDI generation because it hides the details of scale positions while exposing simple options for offsets, formats and verbosity. The module works with Music::Note and Music::Scales, provides sensible defaults, and the latest 0.0805 release updates MIDI handling to use the new MIDI::Util::midi_format() function.

MIDI::Util is a compact toolbox of helper routines for working with MIDI from Perl, especially alongside MIDI::Simple, that makes common tasks like building a score, setting tempo and time signature, converting note names and durations, inspecting internal MIDI tables, and turning a MIDI::Simple score into event lists quick and straightforward. It also includes convenience for playback and soundfont use by emitting timidity configuration snippets and calling timidity or fluidsynth to play generated MIDI files, plus utilities to compute ticks and microseconds per tick for accurate timing. Nothing is exported by default so you explicitly import only the helpers you need, and the module is aimed at developers who generate, analyze, or play MIDI programmatically rather than low‑level MIDI protocol work. The recent 0.1305 update tightened up midi_format so it only substitutes MIDI-specific s/f accidentals when you pass the flag and fixed a few documentation typos. If you write scripts that create or manipulate MIDI sequences in Perl and want small, well scoped helpers to avoid reimplementing common plumbing, this module is likely relevant.

EV::Redis is an asynchronous Redis client for Perl that uses the fast C hiredis library together with the libev event loop to deliver high-throughput nonblocking access to Redis. It is a drop-in, backward-compatible replacement for EV::Hiredis and adds features you expect in production: automatic reconnection with configurable backoff and attempt limits, flow control via max_pending and local queuing with waiting timeouts, optional TLS support when built with SSL, and RESP3 server push handling via an on_push callback. Commands are issued with command or by calling Redis commands directly and can be handled with callbacks or run in fire-and-forget mode for maximum throughput, and pub/sub callbacks are persistent to receive ongoing messages. The module exposes connection and command timeouts, socket tuning options like keepalive and TCP_USER_TIMEOUT, and helpers to cancel or resume queued commands; it integrates cleanly with AnyEvent when EV is used as the backend. Note that EV::Redis treats all data as bytes and does not perform UTF-8 encoding or decoding for you, so you must encode and decode multibyte strings yourself. Overall EV::Redis is a low-latency, production-ready client for event-driven Perl applications that need speed and control over connection and queuing behavior.

Parallel::DataPipe is a lightweight framework for speeding up item-by-item data processing by running your processing callbacks in multiple forked worker processes and merging results back in the main thread. You feed it an input iterator or array, provide a process routine that runs in child processes and an output/merge routine that runs in the parent, and it handles queuing, IPC serialization and worker management for you. It also supports chaining multiple pipes into a Unix-like pipeline so you can build multi-stage parallel workflows without buffering entire datasets in memory, and it will by default try to match the number of workers to available CPU cores while letting you override that for IO-bound workloads. Data passed between processes is serialized automatically with Sereal if available and falls back to Storable, and you can supply custom freeze/thaw routines for special payloads. Be aware that the processing callback runs in child processes so it should avoid touching parent-only resources and that complex shared state will not be propagated back to the parent. Recent releases fixed subtle IPC framing bugs and short-read/write edge cases and improved performance and memory efficiency for large payloads by using safer sysread/syswrite handling and preallocated buffers, making inter-process transfers more robust and faster.

EV::Pg is a non-blocking PostgreSQL client for Perl that plugs libpq's async API into the EV event loop so your database I/O never blocks the reactor. It provides parameterized queries and prepared statements, pipeline mode for high-throughput batching, single-row and chunked-row streaming, COPY IN/OUT support, LISTEN/NOTIFY handling, async cancel, structured error fields, and protocol tracing, with convenient helpers for escaping, describing results, and connection metadata. Callbacks deliver either results or an error and the API exposes connection and pipeline control methods so you can manage long-lived or high-performance event-driven database access. The module requires libpq and EV, needs libpq version 14 or later and some features require libpq 17 or later.

Geo::IP2Proxy is a pure-Perl library for doing fast reverse lookups of IP addresses against IP2Proxy BIN databases to detect VPNs, open and web proxies, Tor exit nodes, search engine robots, data center ranges, residential proxies and other privacy or enterprise networks while returning useful metadata like proxy type, country, region, city, ISP, domain, usage type, ASN and AS name, threat tags, provider name and a numerical fraud score. It works from a local BIN file so you can open the database and call simple methods such as isProxy, getProxyType or getAll to get a one-shot report for IPv4 or IPv6 addresses. The underlying IP2Proxy database is updated daily and full datasets require a subscription, though IP2Proxy publishes sample BIN files and a limited free monthly LITE database for basic open-proxy detection. If you need to gate access, reduce fraud risk or add proxy-aware logic to authentication and logging flows, this module provides a lightweight, dependency-free way to integrate that intelligence into Perl applications.

LRU::Cache is a compact, high-performance Least Recently Used in-memory cache for Perl, implemented in C to provide O(1) get, set, peek, exists and delete operations and automatic eviction of the least recently used item when the cache reaches its capacity. It offers a familiar object API plus an optional function-style API that skips method dispatch for roughly a 2x speedup in tight loops, and published benchmarks show tens of millions of operations per second for common actions. Common features include promoting on get, non-promoting peek and exists checks, deletion, clearing, listing keys in recency order, and querying size and capacity, so it is a good fit for Perl programs that need a small, fast local cache. The module is free software and is distributed under the same terms as Perl.

Heap::PQ is a compact, C-backed binary heap for Perl that gives you fast min or max priority queues with three APIs: an OO interface, a functional API with compile-time ops for extra speed, and a raw array API for maximum performance. It supports the usual heap operations—push, pop, peek, peek_n—plus bulk insert, search and conditional delete, and a numeric-only NV variant that avoids Perl scalar overhead for tight loops. For complex items you can pass a Perl comparator or, for even better performance, give a dot-separated key path so the numeric key is extracted at push time and comparisons stay in C. Recent releases improved comparator performance and fixed compatibility issues with newer and debug Perl builds so the module is both faster and more robust across Perl versions. Use Heap::PQ when you need efficient priority-queue behavior or heap-based algorithms such as task scheduling, leaderboards, or selecting the top K items.

SPVM is a statically typed programming language that uses a Perl-like syntax to give Perl programmers a familiar look and feel while adding static typing and performance features. It supports ahead-of-time and just-in-time compilation, can produce standalone executables, and exposes C and C++ bindings so you can integrate native libraries. You can call SPVM methods directly from Perl and reuse many Perl standard functions and modules, and the language includes features such as native threads, goroutines, type inference and static analysis to help build high performance software. The project is still pre-1.0 and does not yet promise backward compatibility, but documentation, tutorials and examples are available on GitHub for learning and adoption.