CPANscan

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.

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.

Tlaloc lets you attach invisible "wetness" metadata to Perl scalars so they behave like ephemeral, decaying state without changing the scalar's actual value. Each wet scalar has a wetness level from 0 to 100 that decreases by an evaporation rate (default 10) on every access, where an access can be an explicit call to wetness(), is_wet(), or is_dry(), or any Perl read of the variable such as interpolation or numeric conversion. The module provides simple controls to wet (add 50), drench (set to 100), dry (remove the magic), and get or set the evaporation rate, and it also offers tied wrappers for arrays and hashes so element operations can trigger evaporation too. This is handy for implementing short-lived flags, freshness/TTL semantics, or other transient metadata on values without redesigning data structures. Note the usual magic caveats: attach only to variables not literals, magic is per-SV so copying a scalar does not copy its wetness, and it is not thread-safe across interpreter threads.

App::MARC::Field008 is a small Perl application base class for a command‑line tool that reads MARC records (including MARCXML), extracts the leader and the fixed 008 field, and prints human‑readable interpretations of those machine‑encoded cataloging elements so you can inspect record length, type, encoding, dates and other fixed-field metadata. It is aimed at librarians, catalogers and developers who need a quick way to view the standard MARC leader and 008 meanings without diving into the raw bytes. The module is a lightweight wrapper that uses existing MARC and Unicode libraries to parse records and format their fixed-field values for display. This is the initial public release.

Data::Stack::Shared is a Linux-only, 64-bit-Perl module that gives you a fast shared-memory LIFO stack for passing typed values between processes. It supports multi-producer, multi-consumer workloads with lock-free compare-and-swap coordination on the stack top and a per-slot publication state to ensure safe handoff, while futexes provide efficient blocking waits and timeouts. You get typed variants for 64-bit integers and fixed-length strings, multiple backing options including anonymous, memfd and file-backed regions, and a familiar API for non-blocking and blocking push/pop, peek, size/capacity queries, a concurrency-safe drain, eventfd notifications and simple stats. The module is aimed at low-latency interprocess communication but remember the mmap region is writable by any process that opens it so do not share with untrusted parties. In the latest 0.03 release the file format was bumped to v2 and a per-slot state machine was added for robust MPMC safety along with stricter fd validation, an idempotent eventfd and other reliability improvements.

Data::Queue::Shared provides high-performance, bounded multi-producer multi-consumer queues that live in file-backed or anonymous shared memory on Linux and requires 64-bit Perl. It includes lock-free integer queues (Int, Int32, Int16) using the Vyukov algorithm for very fast concurrent push and pop, plus a Str variant that stores variable-length byte strings in a circular arena protected by a futex mutex and supports blocking waits and PID-based stale-lock recovery. The API covers nonblocking and blocking ops with timeouts, batch push/pop, peek, deque operations for strings, memfd-backed creation and fd passing, optional eventfd integration for event-loop watchers, and diagnostic stats. Typical use cases are cross-process job queues, counters, message passing, and other low-latency high-throughput IPC scenarios. Be aware that integer variants truncate to their bit width, the Str queue serializes producers under heavy contention so throughput can drop, and the total bytes storable in Str queues are limited by the arena size.

Data::Heap::Shared is a Linux-only Perl module that implements a binary min-heap priority queue in shared memory so multiple processes can push and pop integer (priority, value) pairs concurrently. It provides mutex-protected push and pop with sift-up/sift-down, futex-backed blocking pops with optional timeout, constructors for memfd or an existing file descriptor, and eventfd support for notifications, plus convenience methods for size, capacity, clear and statistics. The implementation includes PID-based recovery for stale mutexes and targets high throughput in multi-process workloads, but the author warns that if a process crashes while holding the mutex the heap data may become partially inconsistent so you should clear and rebuild after a recovery in critical use. Note that it requires 64-bit Perl, works only on Linux, and the shared memory region is writable by any process that opens it so do not expose it to untrusted parties.

Data::Deque::Shared is a Linux-only, 64-bit Perl module that implements a double-ended queue in shared memory so multiple processes can push and pop items at either end with minimal locking. It uses a ring buffer with CAS-based per-slot publication and futex-backed waiting so producers and consumers can operate concurrently and efficiently, and it offers both integer and fixed-max-length string variants plus file-backed or memfd-backed shared memory. The API is familiar: push_front/back, pop_front/back, blocking-with-timeout variants, size and capacity queries, and a concurrency-safe drain for orderly draining. Recent releases added a per-slot MPMC state machine and bumped the on-disk format to v2 for true multi-producer/multi-consumer safety, so old v1 files will no longer open; anonymous and memfd usage are unaffected. Note that the mmap region is writable by any process that opens it, so do not share backing files with untrusted parties.

MARC::Field008::Print is a lightweight formatter that converts Data::MARC::Field008 objects for printed materials into readable, line-oriented text suitable for display, logging or debugging. It extracts common fixed-field elements like dates, place of publication, material type, language and content indicators and renders them as human-friendly labels or raw values depending on your preference. You create an instance with options to set the output language using ISO 639-1 codes, enable or disable ANSI color, and choose descriptive labels, and its print method returns either a single joined string or a list of lines based on context. The module supports localization, validates its parameters, and uses Term::ANSIColor only if color output is requested.

App::ptimeout is a small Perl module that implements the ptimeout command-line utility to run external programs with a built-in time limit, letting you start a process and ensure it is stopped if it exceeds a specified wall-clock timeout, which is handy for scripting, automation and watchdog tasks where hung or runaway commands must be constrained. The module is written by David Cantrell and is available under either the GNU GPLv2 or the Artistic License.

MARC::Field008::L10N is a tiny localization helper for code that works with MARC field 008, offering language-specific translations of common labels and messages via Locale::Maketext. You request a translation handle with get_handle and optionally pass an ISO 639-1 language code, and then call maketext on that handle to get the localized string; get_handle returns undef when the requested language is not available. It is useful for library and metadata applications that need simple, consistent localization of field 008 text without building a full i18n system. The module is a minimal first release, depends on Locale::Maketext, is BSD-licensed, and the source is available on GitHub.

Module::Signature was a simple toolkit for adding OpenPGP-style cryptographic signatures to CPAN distributions via a SIGNATURE file so authors could sign tarballs and users could verify integrity with the cpansign command or via a small API. It integrated with common build tools to add signing to make dist, provided options for keyserver lookup, cipher selection and verbosity, and returned clear status codes for missing or bad signatures and manifest mismatches; older signatures used SHA1 by default and authors are encouraged to regenerate them with stronger digests. Important caveat, however, is that Module::Signature has been deprecated because key management practices and keyserver infrastructure changes have eroded the security guarantees it aimed to provide, and maintainers are advised to remove SIGNATURE files while users should migrate to more secure, actively maintained signing workflows.

MARC::Field008 is a focused utility for working with the MARC 008 fixed-length control field used in library catalog records. It converts a raw 008 string into a structured Data::MARC::Field008 object and can serialize those objects back to the 40-character MARC 008 representation, including specialized handling for different material types such as books, music, maps, visual materials and computer files. The constructor accepts a MARC leader object and options to enable strict parsing, verbose output, or to ignore data errors so you can adjust validation to your needs. The module enforces field length and required parameters and will raise clear errors for malformed input, and it relies on companion Data::MARC::Field008 classes for material-specific fields. Source and documentation are available from the project repository on GitHub.

WorePAN is a lightweight tool for building a small, test-friendly subset of CPAN so you can run tests or assemble a DarkPAN without mirroring the entire archive. It copies selected distribution files from a CPAN mirror, BackPAN archive, or a local mirror into a minimal directory layout with the basic index files you need, and it works on Windows as well as Unix. You can specify exact file paths or distribution names, add files programmatically, update indices, and walk each unpacked distribution to inspect META or module files, which makes it handy for automated test suites and targeted dependency checks. It is not meant to replace a full CPAN mirror but to give fast, reproducible access to only the modules you need, and it supports offline operation when desired. A recent 0.19 update added an option to include developer releases when you need them and the project already uses secure transport for downloads.

Data::RingBuffer::Shared provides a simple, fast fixed-size circular buffer in shared memory for Linux systems running 64-bit Perl, letting multiple processes publish numeric values into a rolling window without per-consumer state. It comes in typed variants for 64-bit integers and double precision floats, and writes always succeed by overwriting the oldest entry when full while returning a sequence number for later lookup. Readers can fetch the latest value or historical entries by relative index or absolute sequence, dump the whole ring, query size and capacity, or block until new data arrives using wait_for and optional timeouts, and the module also exposes eventfd support for efficient notifications. Typical uses include metrics rings, sensor streams, rolling windows and debug traces where a simple, nonblocking shared buffer is enough. Note that the mmap is writable by any process that opens it so you should not share backing files with untrusted users. Recent updates add memfd sealing, a dedicated futex word and a v2 layout with per-slot publication seqlocks for MPMC-safe reads, plus idempotent eventfd handling and wider architecture CI.

Data::Buffer::Shared provides lightweight, fixed-size buffers stored in file-backed or anonymous shared memory so multiple processes can read and update numeric arrays or fixed-length strings with low overhead. It offers type-specialized variants for integers, floats and fixed byte strings and exposes lock-free atomic single-element get/set and common atomic counters and bitwise ops for integers, plus seqlock-guarded bulk reads and futex-backed read/write locking for larger or batched operations. You can create buffers from files, memfd descriptors, or anonymously, use zero-copy mmap-backed scalar views or raw pointers for FFI, and perform batch updates, notifications and explicit locking when needed. The module is Linux-only and requires 64-bit Perl, and it is designed for predictable, presized storage rather than dynamic resizing. Recent updates added a new_from_fd constructor that duplicates the supplied file descriptor, improved writer waiting and stale-lock crash recovery for the rwlock, made eventfd handling idempotent, added some convenience aliases and stricter unlink behavior, and broadened CI to aarch64. If you need fast, shared, typed arrays or counters between processes and can accept fixed capacity, this module is a compact, high-performance option.