CPANscan

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.

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.

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.

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.

Data::Log::Shared provides a fast, append-only write-ahead log stored in shared memory for Linux with 64-bit Perl, letting multiple processes append variable-length entries concurrently and readers replay or tail the log from any offset. It offers a simple API to append entries, read or iterate entries, wait for new entries, and use either file-backed or memfd-backed storage, making it well suited for audit trails, event sourcing, and cross-process debug logging. The log retains all committed entries until you explicitly truncate or reset, and truncation is a lock-free logical discard that does not reclaim physical space so you must size the log appropriately and perform resets only during maintenance. Note that the shared mmap region is writable by any process that opens it, so do not share backing files with untrusted code.

App::sdif is a small toolset for making diffs far easier to read on the terminal by combining three utilities: sdif prints diffs side-by-side with configurable margins, prefixes and color maps so you can scan changes at a glance, cdif adds inline visual highlighting that shows word‑ or character‑level differences inside changed lines, and watchdiff repeatedly runs a command and visually emphasizes what has changed between runs. It is designed to plug into workflows like git by installing sdif as your pager and supports many options for how differences are tokenized and shown including a mecab-backed tokenizer for better splitting of East Asian text, configurable color tables and visibility controls for special characters, and truncation controls for very long lines or hunks. The package handles diff3 and conflict markers and works with process substitution and /dev/fd inputs on most systems, and it can be tuned with per-user rc files to fit your terminal and pager setup. Recent releases added a --limit option to truncate long sections or skip expensive word diffs for huge lines and updated runtime requirements to improve detection of /dev/fd paths. If you read a lot of diffs in a terminal and want clearer, per-word visual cues or an automated watch-and-highlight view of changing output, App::sdif is likely relevant.

IPC::Manager provides a simple, flexible way to pass messages between processes on the same machine by hiding the transport behind a consistent API. You start a datastore with ipcm_spawn and share the small info string it returns so other processes can ipcm_connect and send or receive message objects or plain hashrefs, with JSON as the default serializer but pluggable serializers supported. The module can use multiple local transports such as filesystem message files, atomic pipes, Unix sockets, or database tables so you can pick a temporary in-memory style bus or a persistent store backed by SQLite, MariaDB, MySQL, or PostgreSQL. It also includes helpers for forking services and workers and options to control cleanup behavior and shutdown signaling, though nested services require care to avoid a race where a caller tries to contact a child before it has finished connecting. Overall it is a pragmatic, protocol-agnostic toolkit for coordinating and exchanging messages between local Perl processes.

SPVM::Resource::RE2 packages the Google RE2 regular expression library for use in SPVM projects, bundling the RE2 2023-02-01 source and headers and building them with C++17 so you can call RE2 APIs from SPVM native code. Add $config->use_resource('Resource::RE2') to your SPVM builder configuration, include re2/re2.h in your C++ source, and then use RE2 functions such as PartialMatch directly from your SPVM extension. The resource preserves RE2's emphasis on speed and safe, non-backtracking regex evaluation, and is provided under the MIT license by YuKi Kimoto, making it a convenient way to get a production-grade regex engine into SPVM native modules.

Command::Run is a small, dependency-free Perl utility for running external commands or Perl code references and capturing their output, error stream, and exit status in a simple object interface. You can feed stdin, capture stdout and stderr separately or merge them, access the captured output as a file descriptor path like /dev/fd/N for passing to other programs, and use a fluent method-chaining API to build and reuse runners. When given a code reference it normally runs it in a forked child, but an optional nofork mode runs the code in-process and a raw mode avoids costly encode/decode layers, delivering large speedups for lightweight functions. The module is intentionally lightweight compared with IPC::Run and similar toolkits, making it a good choice when you want straightforward command execution and I/O capture without pulling in large dependencies.

Async::Redis is a modern asynchronous Redis client for Perl built on Future::IO that exposes an async/await friendly API and works with a variety of event loops. It supports automatic reconnection with exponential backoff, connection pooling, pipelining and auto-pipelining, pub/sub with automatic subscription replay, transactions, TLS, OpenTelemetry tracing and metrics, and is fork safe for prefork servers. You can call all standard Redis commands as async methods, register and run cached Lua scripts with EVALSHA optimization, and use Async::Redis::Pool for parallel throughput while the client safely coordinates concurrent commands on a single connection and surfaces typed error classes for connection, timeout, protocol and Redis errors. Be aware of a few limitations documented by the author, notably that hostname resolution is synchronous during connect, IPv6 URI hosts are not yet supported, and some low level mode-changing commands can interfere with the response model if misused. If you need a full featured, event-loop agnostic nonblocking Redis client for Perl that integrates observability and production features like reconnects and pooling, Async::Redis is a strong fit.

Langertha::Knarr is a Perl-based universal LLM hub that lets you expose any local or remote model over the common LLM HTTP protocols used by OpenAI, Anthropic, Ollama and agent ecosystems like A2A, ACP and AG-UI so clients built for any of those stacks can talk to your backend without changes. It runs as a standalone async server or as a PSGI app, supports real-time token streaming, passthrough proxying, per-request auth, Langfuse tracing and configurable handler backends so you can route requests to a single engine, a model router, remote agents or custom code. The module uses a pluggable three-layer design of protocol translators, handler implementations and transport, so it normalizes diverse wire formats, forwards generation parameters and surfaces tool calls and real usage statistics to clients. Recent releases add a single normalized Response value object to simplify handler output, improved propagation of generation parameters to engines, preserved tool_call/tool_use data across formats and nonblocking async tracing and streaming for more accurate counts and smoother real-time behaviour. If you need a drop-in gateway that speaks multiple LLM protocols and unifies heterogeneous backends for testing, proxying or local deployment, Knarr is designed for that use case.

ULID::Tiny is a compact, pure-Perl generator for ULIDs, the 128-bit, lexicographically sortable identifiers that are encoded as 26-character strings. It offers ulid() to create a new ULID with an optional millisecond timestamp or as raw 16-byte binary, and ulid_date() to extract the millisecond timestamp from an existing ULID. The module follows the ULID spec with a 48-bit timestamp and 80 bits of cryptographic randomness, uses Crypt::SysRandom for entropy, and ensures monotonic ordering within the same millisecond. Use ULID::Tiny when you want compact, sortable, collision-resistant IDs for databases, logs, or distributed systems and prefer a minimal, dependency-light pure-Perl implementation.

Langertha is a Perl library that gives you a single, consistent API for working with large language models from many providers, both cloud and local. It wraps about 24 engines including OpenAI, Anthropic, Ollama, Gemini and HuggingFace and exposes chat, streaming, embeddings, transcription, image generation, tool/function calling, and a stateful autonomous agent called Raider with plugins and history compression. The API works synchronously or with async/await and streaming callbacks, returns rich response metadata like token usage and rate limits, and integrates observability via Langfuse. Recent releases added a provider-agnostic Langertha::Content abstraction so image and mixed text+image prompts are normalized across engines and also fixed non-ASCII JSON handling. This is a work-in-progress but it is a strong choice if you need a Perl-native layer to unify multiple LLM providers or to build agents and instrument LLM calls.

Func::Util is a Perl utility library that provides a compact set of functional programming helpers, fast type and collection predicates, and common data transforms implemented in XS/C so many operations run far faster than equivalent pure-Perl code. It offers zero-overhead custom ops for basic predicates and ops like identity, is_array, is_defined, boolean normalization, numeric checks, array/hash length and first/last access, and string tests, plus pure-C specialized array comparisons (first_gt, any_ge, all_lt, final_lt, etc.) that avoid Perl callback overhead. Higher-level XS functions include memoization, pipeline/compose, partial application, lazy/force, safe navigation (dig), null coalescing, tap, and utilities for pick/omit/pluck/uniq/partition and faster literal string replacement, all aimed at writing clearer, faster data-processing code. The module also provides a callback registry and C API so other XS modules can register C-level predicates or export functions for maximal speed, while still supporting named Perl callbacks for convenience. If you need concise functional primitives or high-performance predicates in Perl, especially in performance-sensitive code, Func::Util is likely relevant; note that operations that call arbitrary Perl coderefs are still limited by normal call overhead and cannot match the pure data operations in speed.

Colouring::In::XS is an XS-accelerated Perl module for parsing, converting and manipulating colors in familiar CSS and numeric formats. You can create color objects from hex, rgb/rgba, hsl/hsla or array refs and then convert them to hex, rgb(a), hsl, hsv, CSS strings or Term::ANSIColor values, and the object stringifies to an appropriate CSS representation. It also provides a wide set of manipulation helpers such as mix, lighten, darken, fade/fadein/fadeout, tint, shade, saturate, desaturate and greyscale, plus validation for color strings, and it offers both object methods and exported convenience functions for simple tasks. Because it is implemented with XS it runs much faster than the pure Perl implementation, making it a good choice for web tooling, command line utilities or any Perl code that needs high-performance color processing.

XML::PugiXML is a Perl binding for the pugixml C++ XML parser that gives you a fast, DOM-style API with full XPath support and easy methods for loading, editing and serializing XML. The module automatically upgrades inputs to UTF-8 and returns UTF-8 flagged strings, offers compiled XPath expressions for repeated queries, and provides node and attribute handles that keep the parent document alive so handles remain valid even after the original document variable goes out of scope. It includes fine-grained parse and format flags, type-aware attribute accessors, and is benchmarked substantially faster than XML::LibXML for parsing, traversal and serialization, while pugixml avoids processing external entities so you are protected from XXE by default. Different document instances may be used concurrently in threads but concurrent access to the same document is not safe. Recent updates improved stale-handle detection, added NODE_* type constants and Attr::set_name, and hardened XPath exception handling for greater stability.