CPANscan

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.

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.

Data::BitSet::Shared provides a fixed-size bitset that lives in shared memory on Linux and is designed for 64-bit Perl, letting multiple processes read and atomically modify individual bits without locks. It supports file-backed storage, anonymous fork-inherited memory, memfd objects that can be passed between processes, and attaching to an existing file descriptor, and offers lock-free per-bit operations such as set, clear, test and toggle that use CAS on 64-bit words. The module also supplies queries like count, any, none and first_set, bulk operations to fill or zero the set, stringification and diagnostic stats, and is handy for shared flags, membership tracking, bloom-filter backing or allocation bitmaps. Be aware that the bulk fill/zero operations write full 64-bit words and are not safe to race with concurrent per-bit CAS operations, and the mmap region is writable by any process that opens it so do not share backing files with untrusted parties. Recent 0.02 updates added memfd sealing and improved header validation along with better aarch64 CI and test parity.

App::cpm is a fast command-line CPAN installer for Perl modules that focuses on reliable dependency handling. It stages and prepares dependencies first and then performs the final installation, installing the requested distributions and their runtime dependency closure. That two-phase approach makes installs more stable and more predictable, which is useful for larger dependency graphs and when running installs in parallel. If you want a quick, dependency-aware installer as an alternative to tools like cpanminus or Carton, cpm is worth trying and a tutorial is available as App::cpm::Tutorial.

BATsh is a self-contained bilingual shell interpreter written in pure Perl that lets you write and run scripts combining Windows cmd.exe style commands and Bourne/bash style commands without invoking an external shell. Scripts are divided into CMD sections (first token all uppercase) and SH sections (first token contains a lowercase letter) and both modes share a common variable store so variables set in one mode are immediately visible in the other. The distribution implements a wide range of common cmd and sh constructs, making it useful for cross-platform scripting, testing batch logic, or embedding shell-like behavior into a Perl program, and it runs on Perl 5.005_03 or later using only core modules. The author notes some limitations: the CMD interpreter lacks certain cmd.exe extensions and delayed expansion, the SH interpreter does not support pipelines, redirection, background jobs or here-documents, and section boundaries are determined by token case.

Socket is the low-level Perl module that exposes operating-system socket constants and small helper functions needed for raw network programming. It gives you the AF_*/PF_* and SOCK_* family/type constants, SO_*/IPPROTO_* and many TCP/IP and IPv6 socket option names, packing and unpacking routines for sockaddr structures for IPv4, IPv6 and UNIX domain sockets, address conversion functions (inet_pton, inet_ntop, inet_aton, inet_ntoa), getaddrinfo/getnameinfo for modern name and service resolution, multicast membership packers and a few convenience CR/LF constants. It is the foundation used by the IO::Socket family when you need direct control over socket calls and options, but most application code is better served by higher level modules such as IO::Socket::IP. Note that not all newer symbols are exported by default so it is best to explicitly list what you import. Recent releases modernised the documentation formatting and fixed a subtle bug in pack_ip_mreq_source.

IO::Async::Loop::EV provides an EV-backed implementation of the IO::Async event loop so you can use the familiar IO::Async API while taking advantage of EV's performance and features. You instantiate an IO::Async::Loop::EV, add timers, filehandle watchers, signal handlers and other IO::Async objects, and run the loop just as you would with the standard IO::Async loop. It is useful as a drop-in backend when you want the IO::Async ecosystem but need the efficiency or additional capabilities of EV, and it requires the EV module to be installed.

Overload::FileCheck lets you intercept and fake Perl file-test operators like -e, -f, -d and the stat/lstat calls so your tests can pretend files exist, are directories, have particular modes or timestamps, or behave in other custom ways. You register simple Perl callbacks at import time or runtime and return one of a few well documented constants to indicate true, false, or "fall back to Perl", or you can supply full fake stat arrays or hashes and use provided helpers such as stat_as_file and stat_as_directory. The module also offers a mock_all_from_stat mode that synthesizes all common -X checks from a single stat hook, tracing helpers for audit-style logging, and a new scope-guard API (mock_file_check_guard) plus a stat_as_fifo helper and support for a CHECK_IS_NULL return in the most recent release. This tool is aimed at unit testing rather than performance sensitive production use and you should install mocks early in your program. Note that certain operators that rely on content heuristics, notably -T and -B, may need their own custom hooks rather than being fully simulated from stat alone.

Parallel::Subs is a small Perl module that makes it easy to run subroutines in parallel and collect their return values. It gives you an object interface to queue anonymous subs or named jobs, control concurrency by CPU count, an explicit max process count, memory-per-job or per-job timeout, and then execute those tasks using forks while optionally running callbacks in the parent to process each child's result. You can chain add and wait_for_all calls for succinct code, retrieve results by job name or as an ordered list, and use a beta optimized mode that groups jobs to reduce forks but currently does not support callbacks. Memory-based limits require Linux and Sys::Statistics::Linux::MemStats. This module is a lightweight choice when you want simple, fork-based parallelism for independent tasks without pulling in a heavier framework.

Getopt::Guided is a Perl module for parsing short command‑line options according to the POSIX getopts guidelines and designed for authors of command‑line utilities who want predictable, standards‑compliant behavior. It works as an iterator over @ARGV, supports simple flags, negatable flags, incrementable flags, multi‑value list options, and map options of the form key=value, and it collects results into a name→value hash where list options become arrayrefs and map options become hashrefs. The companion processopts() lets you bind parsed options to scalars, arrays, hashes, or callback functions so you can implement semantics like “version takes precedence over help”, readopts() can preload defaults from an rcfile, and print_version_info() implements a standard version output. The routine restores @ARGV and clears results on parse errors so your script can fail cleanly. Recent releases added explicit HASH destination support and a map option indicator so key=value options can be captured directly into hashes, making this module especially useful when you need robust, POSIX‑style short option handling with flexible destinations and clear error behavior.

Colon::Config is a lightweight parser for simple key value files that use a single-character separator, colon by default. It provides read to return an ArrayRef of alternating keys and values and read_as_hash for a convenient HashRef, and it lets you choose which field to extract when values contain multiple separators and change the separator character if needed. The parser ignores comment lines beginning with # and trims whitespace after the separator. For speed it uses an XS C backend when available and automatically falls back to a pure Perl implementation otherwise, and you can inspect which backend is active via $Colon::Config::BACKEND. The module is ideal for quickly parsing passwd-like or simple config files and small CSV-style data, and the only noted limitation is that support for custom end-of-line characters is listed as a TODO.

Time::Str is a compact Perl utility for converting between human-readable date/time strings and machine-friendly values, offering three main routines: str2time to parse strings into Unix timestamps (including fractional seconds), str2date to return parsed components as a hash, and time2str to format timestamps back into strings. It supports a wide set of standards such as RFC3339/RFC2822, HTTP dates, ISO 8601/W3C, SQL (ISO9075), ASN.1, Common Log Format, Git and more, plus a permissive "generic" parser that handles many real-world variants. The module gives fine control over fractional seconds with precision and a nanosecond override to avoid floating-point rounding errors, and accepts timezone offsets and UTC designators; str2time requires a numeric offset or UTC designator and will croak on unresolved abbreviations while str2date will preserve an abbreviation for external resolution. A few formats are parse-only or always output GMT or omit fractions by design, so check the format docs if you need offsets or subsecond output. Overall Time::Str is a practical choice when you need reliable, standards-aware parsing and formatting of dates and times across diverse inputs and outputs.

Graphics::Framebuffer is a Perl library for drawing directly to a Linux console framebuffer, giving you a compact, software-based graphics API for pixels, lines, shapes, fills, gradients, TTF text, image loading, blitting and simple animations without needing X or a heavyweight GUI stack. It supports 32/24/16‑bit framebuffers and an emulation mode for offscreen testing, exposes many intuitive methods (plot, line, circle, polygon, blit_transform, ttf_print, load_image, play_animation and more), and can use Imager and optional Inline::C acceleration for much faster image operations while leaving pure Perl fallbacks when a compiler is not available. The module is console-only and expects an open-source framebuffer driver (proprietary DRM drivers like Nvidia/AMD usually will not work), and 24/32‑bit modes are recommended because 16‑bit requires costly conversions and can be slower. If you need to target small devices or test without hardware, emulation mode gives a memory framebuffer you can dump to files. Recent releases simplified VirtualBox handling by removing automatic babysitting and adding IS_VBOX and LAST_FLUSHED variables so you can detect VirtualBox yourself and manage screen flushing as needed.