CPANscan

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.

Data::ReqRep::Shared is a Linux-only, 64-bit-Perl module that implements a fast shared‑memory request/response channel so many clients can send requests to many worker processes and receive routed replies without a broker or one socket pair per connection. It comes in two flavors: Str for variable-length byte strings using a mutex-protected circular arena and fixed-size response slots, and Int for single int64 values with a lock-free Vyukov queue for higher single-process throughput. Servers create or open a shared channel and loop on recv/recv_wait then reply, while clients use simple synchronous req/req_wait calls or async send/get with per-request slots and cancellation. The design includes targeted per-slot futex wakeups, generation counters to avoid ABA problems, PID-based recovery for crashed holders, optional eventfd integration for event loops, and options for file-backed, memfd, or anonymous shared memory. Tuning knobs let you trade memory for concurrency and payload size, and the module bundles crash-safety and recovery features so it is suitable for high-throughput MPMC IPC workloads. Recent 0.03 updates hardened robustness with arena underflow guards, stricter file descriptor validation, improved destroy handling, idempotent eventfd behavior and aarch64 CI fixes.

Data::HashMap::Shared provides very fast, type-specialized hash maps stored in file-backed shared memory so multiple Linux processes can read and write the same table without copying data between them. It offers specialized variants for integer and string key/value combinations, lock-free read paths and atomic increments for high-throughput workloads, optional LRU eviction and per-key TTL for cache semantics, and a keyword-style XS API or traditional method calls. The module supports sharding for parallel writes, anonymous mmap and memfd-backed maps for flexible IPC and passing fds between processes, and a rich cursor and diagnostics API for iteration and monitoring. It is Linux-only and requires 64-bit Perl, and PID-based stale-lock recovery does not work across different PID namespaces so cross-container sharing is not supported. Recent releases added anonymous mmap and memfd/new_from_fd support along with improved sharded iteration and more robust rwlock recovery.

Data::Graph::Shared provides a Linux-only, 64-bit Perl implementation of a directed, weighted graph stored in shared memory so multiple processes can access and mutate the same graph concurrently. Nodes are allocated from a bitmap pool and edges are kept as adjacency lists in a separate pool, with mutations protected by mutexes and PID-based stale-lock recovery. The API supports creating file-backed, anonymous, or memfd-backed graphs, adding and removing nodes and weighted edges, iterating neighbors, reading and setting node data, and querying counts and capacities, and it exposes an eventfd for integration with event loops so processes can be notified of updates. A design choice favors O(1) node removal that only clears a node and its outgoing edges and leaves incoming edges dangling unless you call remove_node_full which does full splicing in O(N+E). Benchmarks show it can handle millions of operations per second in single-process tests, making it suitable for high-performance interprocess graph access, and you should not share backing files with untrusted processes because the mmap region is writable by any process that opens it.

Data::Sync::Shared provides a small suite of cross-process synchronization primitives for Linux that live in mmap'ed shared memory and use futexes for efficient blocking, and it requires 64-bit Perl. It includes a counting semaphore for resource limits, a barrier for N-way rendezvous, a reader-writer lock for concurrent-read or exclusive-write access, a condition variable with a built-in mutex for predicate waiting, and a Once gate for one-time initialization, with file-backed, anonymous (fork-inherited), and memfd modes so you can share descriptors across processes. All blocking operations support timeouts, guards offer scope-based auto-release, eventfd hooks integrate with event loops, and crash safety is handled by PID-based stale-lock detection and recovery. Note that the shared region is writable by any process that opens it, so do not share backing files with untrusted parties. Recent updates added a write-preferring RWLock with improved waiter handling and POSIX-like broken-on-timeout semantics for the barrier, plus robustness fixes around sync and destruction.

Data::Pool::Shared is a Linux-only Perl module that gives you a fixed-size object pool in shared memory so multiple processes can allocate, use, and return slots without a heavyweight locking scheme. It exposes raw byte slots and typed variants (I64, I32, F64, Str) with atomic primitives like CAS, exchange, and add, supports futex-based blocking when the pool is full, and provides batch allocation/free, zero-copy read via SVs, raw pointers for FFI or OpenGL, and guard objects that auto-free slots on scope exit. The pool records allocator PIDs and includes recover_stale to reclaim slots owned by dead processes, and it can be backed by a file, an anonymous mapping, or a memfd for safe FD passing; there is also eventfd integration for event-loop wakeups. Note that the mmap region is writable by any process that opens the backing file so you should not share it with untrusted processes. The recent 0.03 release tightens file descriptor validation, makes recovery counters use 64-bit values, and makes eventfd handling idempotent, along with minor test and CI fixes.