CPANscan

Langertha::Skeid is a lightweight control plane for routing requests across multiple LLM nodes while recording normalized token and cost usage so you can build consistent tenant billing and observability. It runs as an API edge that routes by model, health and capacity, forwards to cloud or local engines, and provides pricing and usage.report calls so totals can be read per key, model and time window. Usage storage is pluggable with built-in jsonlog (recommended, no DBI), SQLite and PostgreSQL backends, or you can supply callbacks or subclass methods to integrate with your own telemetry pipeline. Admin routes are protected by a bearer token and the proxy is nonblocking for production traffic. The recent 0.002 release removes a dependency on Langertha::Knarr and now talks directly to Langertha core value objects for cost and usage, keeping the hot path performance unchanged and including a small bugfix in response translation.

Langertha::Knarr is a universal LLM hub and proxy that lets you expose any backend language model or agent to standard LLM HTTP clients and agent ecosystems, so a single Knarr instance can speak OpenAI, Anthropic, Ollama and agent protocols like A2A, ACP and AG-UI at the same time. It is modular with pluggable protocol translators, backend handlers and transports, so you can route requests to local Langertha engines, per-session agents, remote agent clients, or simple HTTP passthroughs, and you can add tracing or JSONL request logging by wrapping handlers. Knarr is built for real-time streaming and native async integration, ships as a ready Docker image for quick setup, supports multi-listen sockets, optional API-key authentication, and includes a PSGI adapter for traditional Plack deployments with the caveat that PSGI buffers streaming. The recent 1.000 release is a major rewrite that replaces the old Mojolicious core with an IO::Async + Net::Async::HTTP::Server + Future::AsyncAwait foundation, consolidates six wire protocols by default, and introduces the new pluggable handler architecture and decorator-based tracing and logging. If you need a single, flexible gateway to bridge clients and heterogeneous LLM backends or to present remote agents as OpenAI/Anthropic-style endpoints, Knarr is likely relevant.

Task::BeLike::PERLANCAR::Used is a Task-style meta distribution that bundles the personal set of CPAN modules and command-line apps the author installs on a fresh Perl setup, so you can replicate their environment in one go. It is intended to be run with the perlancar cpanm wrapper and will pull in a very large list of utilities, developer tools and helper libraries to bootstrap a new perlbrew or system Perl, which makes it handy if you want the same toolset as the author. Running it can take a long time and may produce some install failures where dependencies or retired modules are missing, so treat it as a convenient starting point rather than a guaranteed turnkey installer.

Test2::Bundle::Numerical is a small Test2 bundle that makes it easy to write floating point tests that behave correctly across different Perl builds, including those using quadmath or long double NV types. It simply loads the numerical Test2 plugin and exports numeric-aware test helpers so you can do tolerant comparisons, ULP checks, bit-level comparisons, and NaN or infinity checks while still using familiar test functions like ok and is. If you write numeric code or libraries that must pass on varying floating point implementations this bundle saves you from platform-specific test failures. This is an initial alpha release intended to validate the approach.

smallnum::XS is a drop-in XS (C) implementation that gives Perl programs transparent, fixed-precision numeric behavior so arithmetic results are automatically rounded to a compact display form. Loading the module causes numeric operations to yield values at the module's configured resolution so that 10 + 20.452433483 becomes 30.45 by default and passing an import argument like '0.1' or '1' changes the decimal resolution to one place or integer math respectively. Because it is implemented in XS it runs significantly faster than the pure-Perl smallnum module, making it a good choice when you want consistent, lightweight numeric formatting with low overhead. The module is available on CPAN, documented via perldoc, maintained by LNATION, and distributed under the Artistic License 2.0.

App::MARC::List is a lightweight base class for a command‑line tool that extracts and lists values from MARC records, including MARCXML. It exposes a simple interface with new and run where run reads an input file plus a field tag and optional subfield code from the command line and prints matching values, and it returns 0 on success or 1 on error. The module understands leader and control fields and can report value frequencies with the -f option while validating field definitions and input files. The latest release added an explicit check for the input file and several fixes to sorting and frequency output.

Aion is a modern, compact object system for Perl 5 that makes it easy to declare classes and roles with concise "has" properties and rich attribute options. It supports read/write/ro/wo permissions, required and constructor-less attributes, lazy defaults and builders, coercions, triggers, cleaners, custom accessors, predicates and clearers, plus role composition with with, requires and req. Aion includes a flexible type system and method signature checking via the :Isa attribute, and it adds extensible aspects so roles can introduce new attribute behaviors. It also provides dependency injection via the eon aspect working with the Aion::Pleroma container for autowiring services. If you know Moose, Moo or Mouse you will find Aion familiar but leaner and focused on extensible aspects and DI. The recent release improved pleroma autoinitialization by replacing the package variable with an Aion->pleroma accessor.

JSON::SL is a streaming, incremental JSON decoder for Perl that uses an embedded C parser to let you extract pieces of a JSON document as they arrive instead of waiting for the whole payload. You tell it what to watch for using JSONPointer-style paths, or enable an "object drip" mode to receive completed nested objects in depth-first order, and feed partial data repeatedly to get matched values immediately along with their path context. It exposes the partial object graph via a root callback, supports options like UTF-8 handling and max size limits, and aims to simplify common streaming use cases without the boilerplate of a SAX-style callback API. Notes and caveats from the author include that full-string decoding is still slightly faster with JSON::XS, threads are not well supported, input should be UTF-8 or ASCII compatible, wildcard matching with the caret is all-or-nothing, and the object tree can contain placeholder undefs; a recent maintenance fix also corrected negative-number parsing for the Tuba event-oriented interface.

JSON::YY is a Perl interface to the high-performance yyjson C library that provides fast JSON encoding, decoding, and in-place document manipulation. It offers three layers of API: a minimal-overhead functional/keyword API for encode_json and decode_json calls, an OO API with JSON::XS-like configuration and chaining, and a Doc API that exposes a mutable JSON document tree addressed by JSON Pointer paths so you can read or surgically modify large JSON blobs without materializing full Perl structures. The Doc API supports typed value constructors, iterators, file read/write, RFC 6902 patch and RFC 7386 merge patch operations, and a zero-copy readonly decode mode for fast reads of medium and large payloads. Benchmarks show meaningful speed gains over JSON::XS in many encode scenarios and large-document workflows. Limitations include no implemented canonical (sorted-key) writer and inability to encode NaN or Infinity values. If you need a fast, low-overhead JSON tool with powerful path-based editing and familiar configuration options, JSON::YY is a strong choice.

CLI::Osprey is a lightweight, pure-Perl toolkit for wiring command-line parsing into Moo/Moose/Mo objects. You declare attributes as command-line options with the option keyword and use new_with_options to build your app from argv; options are parsed with Getopt::Long::Descriptive and the module automatically produces short help, full help and man pages. It has built-in support for nested subcommands implemented either as separate classes or inline coderefs, keeps command-line names separate from Perl attribute names, and supports common option features like short flags, negatable and repeatable options, required flags and custom formats. Unlike MooX::Options it avoids mandatory XS dependencies and requires explicit subcommand registration for more predictable behavior, and it offers controls such as abbreviated long options, on_demand loading of subcommands, and preservation of argv. A few features from MooX::Options are not built in, such as native JSON option parsing or config-from-file helpers, but the author documents simple workarounds so this module is a practical, portable choice for building structured command-line apps in Perl.

Crypt::TimestampedData is a compact Perl library for reading, writing, and manipulating TimeStampedData (.TSD) files as specified by RFC 5544. It provides simple methods to decode and encode TSD blobs, extract embedded original content and RFC 3161 TimeStampToken(s), and build new .tsd files from a marked file plus timestamp tokens, and it ships with handy command line scripts for creating, inspecting, and extracting TSDs. The implementation is intentionally minimal and uses Convert::ASN1 while treating CMS structures and timestamp tokens as opaque DER blobs, so full CMS or timestamp verification should be handled by specialized libraries if you need it. The module is cross platform and requires Convert::ASN1. The recent 0.02 release added a SECURITY.md and CPAN metadata to align with coordinated vulnerability disclosure practices.

Music::Drummer is essentially a friendlier, searchable alias for the MIDI::Drummer::Tiny module that exists to make MIDI drumming functionality easier to find by using drum-related naming and keywords. It does not add new features but exposes the same simple API so you can instantiate a drummer object and use basic MIDI drumming controls such as a count-in and other playback actions provided by the underlying module. Choose this package if you want a clear, discoverable Perl module name for working with drum-related MIDI tasks without having to learn a different interface.

Museum::Rijksmuseum::Object is a lightweight Perl client for the Rijksmuseum object-metadata API that makes it easy to search the collection, retrieve full object records by objectNumber, and obtain image tile metadata for individual works. It requires an API key and a culture setting (for example "en" or "nl") and mirrors the Rijksmuseum API parameter naming so you can pass search options like page, page size, and image-only filters directly. Note that the Rijksmuseum has removed the API this module wraps, so for ongoing bulk harvesting you should use the OAI-PMH interface instead, and Museum::Rijksmuseum::Object::Harvester already uses OAI-PMH and continues to work with an updated base URL. The module is intentionally thin and focused on passing through the museum API rather than providing heavy helpers, though recent maintenance fixed Unicode handling in JSON decoding.

Data::PubSub::Shared is a Linux-only, 64-bit-Perl pub/sub implementation that uses mmap'ed shared memory to broadcast messages between processes with extremely low latency. Publishers write into a ring buffer and each subscriber has its own read cursor so many readers can independently consume the stream without blocking publishers. There are two main flavors: Int variants that offer lock-free, multi-producer publish via atomic fetch-and-add for simple numeric signals, and a Str variant that stores variable-length byte strings in a circular arena with mutex-protected publishing and lock-free readers. The module supports file-backed, anonymous (fork-inherited) and memfd-backed sharing, futex-based blocking waits and eventfd integration for event loops, batch publish/poll operations, per-subscriber overflow counting, and automatic recovery when a subscriber falls behind; note that the ring buffer never applies backpressure and will overwrite old messages when full. This is the initial release and it bundles high-throughput primitives, keyword helpers, and crash-recovery behavior for the string mode.

Term::Choose::Util is a small helper library that supplies ready-made terminal user interface widgets for letting a script’s user interactively pick directories, files, numbers or subsets from a list. You can call its functions directly or use the object interface, and it exposes many options to tune appearance and behavior such as color and mouse support, layout and ordering, margins and prompt text, cursor hiding and filesystem encoding handling so it plugs into command-line tools with minimal code. It provides focused utilities for browsing and choosing a directory, picking a file, selecting multiple directories, composing an unsigned number, choosing a subset from an array and presenting a simple settings menu that edits a config hash in place. The module expects Term::Choose and Perl 5.10.1 or newer and defaults to no exports, and recent releases include stability fixes such as preserving the caller’s supplied 'mark' option instead of altering it.

Term::Choose is a terminal UI helper that lets Perl scripts present an interactive list of choices so users can pick a single item or mark multiple items from the keyboard or mouse; it offers both a simple functional interface and an object-oriented API, supports paging, column layouts, optional ANSI color, default selections, filtering via regex, and many layout and accessibility tweaks like margins, max width/height and index-based returns. It understands Unicode print widths, works on Unix and Windows (with Win32::Console support), and can use Term::ReadKey for better input handling and an optional XS line-folding module for speed, while requiring Perl 5.10.1 or newer. The module is highly configurable for scripts and command-line tools that need a polished interactive picker, with options to pre-mark items, skip or protect items from selection, show footers or info lines, and treat ambiguous-width characters according to environment variables. Recent updates fix sizing and marking bugs, tighten available-width/height handling, introduce a new truncate_long_tabs line-fold option, raise the minimum terminal size to 4×2, and include backward-incompatible changes to tabs_info, tabs_prompt and tabs_bottom_text, so review those options when upgrading.

Net::Nostr is a Perl library that implements the Nostr decentralized social protocol and gives you both client and relay functionality so you can connect to relays, run a relay server, and build Nostr-aware apps and bots. It includes helpers for key management and event creation, WebSocket client and relay classes, message parsing and storage, encryption and signing, and a large collection of modules that implement many official NIP extensions such as authentication, encrypted payloads, channels, long-form content, media attachments, wallets and more. You can start with Net::Nostr::Key to manage identities and Net::Nostr::Event to create and verify events, then pick from higher-level modules for features you need. The distribution targets a recent NIP snapshot and supports dozens of NIPs, and notes that the older NIP-04 encrypted direct messages are deprecated in favor of NIP-44. If you are a Perl developer wanting to interact with the Nostr network or run a relay, this module provides a comprehensive, ready-to-use toolkit.

EV::Kafka is a high-performance asynchronous Kafka client for Perl that implements the Kafka binary protocol in XS and plugs directly into the EV event loop for low-latency, pipelined I/O. It gives you a cluster-aware Client with automatic metadata discovery and broker routing, a full producer with batching, acks modes, idempotent and transactional (EOS) support, and a consumer with manual assignment or consumer-group join/sync/heartbeat, plus admin APIs and a low-level EV::Kafka::Conn when you need direct broker calls. The module is pure XS with no librdkafka dependency and works with AnyEvent applications, but it treats all payloads as raw bytes so you must encode UTF-8 yourself and some features are subject to build or protocol limits such as optional LZ4/gzip support, lack of GSSAPI/OAUTHBEARER, synchronous DNS resolution, and capped non-flexible API versions. This 0.01 initial release ships the core produce/consume, transactions, TLS and SASL, multi-partition fetch, and basic admin operations.

EV::Nats is a high-performance, event-driven NATS client for Perl that plugs into the EV event loop and implements the NATS protocol in XS so you do not need an external C library. It gives you low-latency publish/subscribe and request/reply primitives with automatic inbox management, queue-group load balancing, wildcard subjects, header support, automatic PING/PONG keepalive, reconnection with subscription restore, write coalescing and publish batching, plus higher-level APIs for JetStream, key-value and object stores. The interface is callback-driven and includes conveniences like graceful drain, per-connection stats, slow-consumer detection and optional TLS and NKey/JWT auth when built with OpenSSL. Note that DNS resolution uses blocking getaddrinfo so use numeric IPs for latency-sensitive deployments, and TLS or Ed25519 NKey support requires OpenSSL at build time, with all data treated as raw bytes so UTF-8 should be encoded before sending.

BZ::Client is a Perl library that lets you talk to a Bugzilla server using the legacy XML-RPC web service, providing a simple object interface to log in with username/password or an API key, manage session cookies, make API calls, and control HTTP behavior such as proxies, timeouts and SSL verification. It includes conveniences like autologin, pluggable logging callbacks and an option to dump raw HTTP traffic for debugging, so you can script queries, create or update bugs, and interact with attachments without dealing with low‑level HTTP details. Important: this module targets the XML-RPC API used by Bugzilla 5.0 and earlier and has been marked deprecated to match Bugzilla’s API changes, so it is appropriate if you must support older Bugzilla installations but you should plan to migrate to the newer WebService::Bugzilla API for modern servers; the recent 4.91 release documents that deprecation while prior updates focused on reliability, unified error handling and better logging.

Weather::Meteo is a Perl module for fetching historical weather from the Open-Meteo archive API (back to 1940) by latitude, longitude and date. It offers an object-oriented interface that accepts ISO date strings or DateTime-like objects, lets you plug in a custom HTTP user agent or proxy, and includes built-in caching (CHI or a user-supplied cache, with a default in-memory cache expiring after one hour) plus optional rate limiting to avoid excessive API requests. The module will try to resolve time zones automatically if you provide a TimeZoneDB key and otherwise falls back to Europe/London. It is a practical choice for scripts or services that need reliable programmatic access to archived meteorological data and is distributed under the GPL2 license.

Term::CLI is a Perl library for building interactive command line interfaces by wrapping Term::ReadLine and adding a higher level, declarative way to define commands, options, and typed arguments with callbacks, tab completion, history, a configurable prompt and pager, and safe signal handling. It is designed to let you quickly assemble a REPL-style tool that supports command lookup and completion, history read/write, custom word-splitting and quote/escape handling, and cleanup hooks for actions like saving history on exit. The module works best with Term::ReadLine::Gnu but also supports Term::ReadLine::Perl, and it lets you specify I/O handles to avoid surprising UTF-8 behavior when the underlying readline implementation opens the TTY separately. Use Term::CLI when you want a ready-made framework for interactive command parsing and user-friendly terminal behavior in a Perl program.

PDL::LinearAlgebra is a collection of high‑level linear algebra routines for PDL arrays that wraps LAPACK and BLAS so you can do SVDs, eigenvalue problems, Schur and generalized Schur decompositions, QR/LQ/QL/RQ factorizations, Cholesky and LU factorizations, inverses, condition numbers, solvers for linear systems and least squares, norms, rank and null/orthonormal basis computations all with PDL's ndarrays and broadcasting semantics. It handles real and native complex data, supports in‑place operations where possible, and transparently transposes arrays when calling Fortran routines so you do not have to worry about column‑major layout. You can control error behavior with setlaerror/getlaerror and most routines return informative info or auxiliary results in array context. If you need the absolute fastest inner loop you can call the more specific PDL::LinearAlgebra::Real or PDL::LinearAlgebra::Complex interfaces directly. Recent updates changed how certain control parameters are passed to improve broadcasting support and fixed SVD and generalized SVD output quirks.

Data::Table::Gherkin is a lightweight Perl module for parsing Gherkin-style data tables into simple Perl data structures. You call the class method parse with either the table text or a readable filehandle and an optional has_header flag; when has_header is true each row becomes a hashref keyed by the header names and when false each row is an arrayref. The module supports common escapes so you can include newlines as "\n", literal pipe characters as "\|" and backslashes as "\\" inside cells. On success parse returns an object whose rows method returns an array reference of the parsed rows, and on error it carps and returns undef. This is the initial v1.0.0 release.

XAO::Web is a modular Perl framework for building dynamic content as part of the XAO suite. It cleanly separates templates from application logic so designers can work with plain HTML while developers extend or override system objects for site specific behavior without rewriting templates. The system works with CGI, mod_perl and PSGI and gains performance from caching in persistent environments. It is integrated by default with XAO::FS for database access but can be adapted to other storage backends. You can use it not only to generate web pages but also to produce mail messages or reports. The distribution includes a sample site and a simple project layout where a site provides a templates directory and a small Config module to customize behavior. XAO::Web is a good fit when you want reusable, pluggable components and the ability to host multiple independently customized sites while keeping templates free of embedded Perl.

Data::HashMap supplies 14 C-implemented, type-specialized hash map variants for Perl that trade Perl hash convenience for much lower memory use and much higher throughput, especially when you use the provided keyword API that bypasses Perl method dispatch. Each variant targets a specific key/value combination (various integer widths, strings, or raw SV* values) and supports common map operations, fast counter ops for integer values, LRU eviction, default and per-key TTL expiry, iteration and bulk operations, zero-copy read-only lookups for string-value variants, and binary freeze/thaw for non-SV* maps. It is designed for high-performance caching and counting workloads with options for approximate LRU promotion to reduce contention and predictable memory characteristics reported in the docs. Note the usual caveats: get_direct returns a pointer into the map that becomes invalid after any mutation, frozen data is native-endian and not portable between different architectures, some integer sentinel values are reserved and 64-bit variants require a 64-bit Perl. Recent changes in 0.07 fix TTL off-by-one expiry, harden freeze/thaw behavior, and resolve compilation issues on threaded Perls so TTL handling and serialization are now more reliable.

PDL (Perl Data Language) is a Perl extension for efficient, vectorized numerical computing and multidimensional array handling, designed for scientific and bulk data tasks such as processing large images and spectra. It provides fast, memory-efficient N-dimensional arrays with broadcasting, supports most native C numeric types including C99 complex numbers, and includes device-independent graphics and input/output modules for formats like FITS and common image files. PDL comes with an interactive shell, extensive tutorials and reference documentation, and a modular design that lets you load the full feature set with use PDL or pick a lighter startup with PDL::Lite, though the PDL::NiceSlice extended slicing syntax must be enabled separately. If you want MATLAB or IDL style array operations inside Perl, PDL is a mature and performant choice.

Test2::Harness is the engine that runs and manages test suites for the Test2 ecosystem, handling execution, TAP/Test2 event collection and aggregation so your test files can be run in parallel, retried, rerun, or under a persistent runner. It is meant to be used through the App::Yath command-line UI rather than directly, and it offers features you expect from a modern harness such as plugin hooks, resource management for shared or exclusive test resources, coverage and timing support, interactive and persistent modes, and facilities for rerunning failed or changed tests. The project has matured over years with many stability and usability improvements, and recent releases include AI-assisted bug fixes (carefully reviewed by the author) plus a new --resource-timeout option to better control resource waits. If you need a flexible, production-ready test harness that integrates tightly with Test2 and supports advanced workflows like persistent runners and resource-aware scheduling, Test2::Harness is likely relevant for you.

IPC::Manager is a lightweight framework for message-based interprocess communication on a single machine that makes it easy to send structured messages between local processes using a variety of transport backends and serializers. You create or spawn a data store, share the small connection string it returns, and any process can connect, send and receive IPC::Manager::Message objects; stores can be temporary and auto-removed or persistent for long-lived services. The module ships with multiple client protocols so you can choose filesystem pipes, atomic files, Unix sockets, databases or shared memory as the message carrier, and you can swap serializers (JSON is the default) to suit your payloads. It also includes helpers for forking named services and workers so you can build nested service processes that communicate over the same bus. Recent work reintegrated DBI and UnixSocket clients, added JSONFile and SharedMemory transports, introduced exec-services, and fixed several DBI/UnixSocket bugs while adding more tests and documentation. If you need a simple, pluggable way to pass structured messages between processes on one host, IPC::Manager is a practical choice.