CPANscan

AEP is a lightweight container entrypoint utility that runs your service inside Docker and optionally coordinates multi-container startup using a simple lock server/client protocol, making it easy to enforce startup order for docker-compose stacks or closely-coupled Kubernetes pods. You can use it just to launch and auto-restart a process with configurable retry and delay behavior or run it as a lock server that releases clients in a specified sequence, including parallel groups using "||". Clients report readiness with flexible triggers such as a fixed delay, exact text or regex matches on output, a TCP connect probe, or an external script, and communication happens over TCP or Unix sockets with JSON messages so you do not need shared volumes by default. Configuration can come from environment variables, a YAML file, or command line arguments and is merged in a configurable order. AEP also provides a docker-health-check mode that returns JSON status for monitoring, plus quiet and verbose modes for controlling output.

DateTime::Lite is a drop-in, lightweight alternative to DateTime that preserves the familiar API while trimming dependencies and improving some performance and memory tradeoffs for short-lived scripts and command line tools. It gives you full date and time construction, arithmetic, formatting and comparisons, CLDR-based locale support for any BCP 47 tag, and accurate time zone handling by reading TZif binaries from a bundled SQLite zone database and evaluating POSIX footer rules when needed. The module ships an XS layer to accelerate hot paths and an optional process-level memory cache in DateTime::Lite::TimeZone to match or exceed DateTime for repeated zone lookups, while also providing a pure-Perl fallback for systems without a C compiler. Error handling is non-fatal by default and returns exception objects instead of dying, and serialization is supported for Storable, Sereal and CBOR. Use this if you want near-complete DateTime compatibility with fewer runtime dependencies, faster startup for short-lived programs, or safer far-future timezone calculations. This is the initial v0.1.0 release and highlights include the full DateTime 1.66 API port, a compact SQLite-based timezone store, XS performance optimizations, and an opt-in memory cache for time zones.

EV::cares is a small XS module that gives Perl programs a high-performance asynchronous DNS resolver by wiring the c-ares library directly into the EV event loop so socket I/O and timers run at the C level with no Perl-level event overhead. It supports concurrent lookups and provides convenience methods for common tasks such as address resolution (resolve and getaddrinfo), reverse lookups, search-domain queries with auto-parsing for A, AAAA, MX, SRV, TXT, NS, SOA, PTR, NAPTR and CAA records, raw DNS queries, and full getnameinfo and gethostbyname compatibility. You can tune servers, timeouts, retries, ports, EDNS size, local binding to a device or address, an optional result cache, and hot-reload system resolv/hosts state with reinit. Queries use callbacks that receive a c-ares status code and result data, exceptions in callbacks are caught and reported as warnings, and it is safe to cancel or destroy the resolver from inside a callback. The module requires c-ares 1.22.0 or newer (via Alien::cares) and is well suited to evented servers and networked applications that need low-latency, concurrent DNS resolution. This 0.01 initial release implements the core query types, raw query support, configuration controls, and direct EV integration.

MIDI::RtMidi::FFI is a thin, cross‑platform Perl binding to the RtMidi realtime MIDI C library that gives Perl programs direct access to MIDI input and output across ALSA, JACK, CoreMIDI and Windows multimedia backends. It exposes the RtMidi C API via FFI so you can list and open ports, create virtual ports, send and receive raw MIDI messages, and hook callbacks or integrate MIDI into event loops, and a higher‑level OO wrapper is available as MIDI::RtMidi::FFI::Device. The module requires librtmidi 4.0.0 or later and as of v0.10 requires Perl 5.26 or newer, uses MIDI::Stream for message encoding and decoding, and adds a useful RtMidiIn->get_fh method that provides a nonblocking IO::Handle for clean event‑loop integration. Note that v0.10 introduced some incompatible changes so existing subclasses of Device may not behave the same and callback data passing is no longer supported, but these changes also split input and output into distinct classes and improve overall message handling. If you need low‑latency, portable MIDI I/O from Perl and are comfortable installing librtmidi, this module is a practical way to connect your Perl programs to MIDI hardware and software.

Term::Form is a small Perl library for creating interactive, terminal-based forms so you can prompt for and edit a list of fields directly in a console session. You give it an array of arrays where each entry is a prompt and an optional default value and then call fill_form (or use the object-oriented interface) to let the user edit those values; fill_form returns the modified array structure when the user confirms or undef if they choose to go back. It supports common cursor and control-key editing, read-only rows, skipping items by regex, optional color and screen-clearing, marking truncated fields with a trailing tilde, and a few platform-specific options for Win32 codepage handling. The module expects a monospaced ANSI-capable terminal and Perl 5.10.1 or newer and has split out its readline behavior into Term::Form::ReadLine while remaining compatible with recent Term::Choose releases.

e is a compact, performance-minded toolbox that makes Perl one-liners and interactive debugging much faster and more convenient. It bundles a playground of helper commands such as repl for breakpoints, trace and watch for stack and reference inspection, prof and n for lightweight profiling and benchmarking, quick format converters and printers (j, yml, csv, x, p, d, dd, table), UTF-8 helpers, file and URL wrappers (f, l), simple HTTP calls (g, post), collection and set utilities (c, set), and several ways to run tasks in parallel (runt, runio, runf) or in series. The module is optimized to keep startup cost low by deferring work until features are used and is geared toward interactive, exploratory workflows and scripting. Be aware that it can overwrite existing functions with the same names so import order matters and runf uses forked processes which incur startup overhead and is capped at about 20 workers.

Runtime::Debugger is a lightweight interactive REPL you can drop into a running Perl program to inspect and experiment with code inside the actual lexical scope, making it easy to peek at my and our variables, call functions and probe objects without leaving the context you are debugging. It provides DWIM tab completion that understands lexicals, hashes and method access, persistent command history, convenient short commands for printing and dumping data structures like d dd and p, and a levels_up option to evaluate at a specific caller level; version 1.13 added a vars command to list available variables. You use it simply by adding use Runtime::Debugger and calling repl or by invoking perl -MRuntime::Debugger -E 'repl', and it is aimed at cases where Devel::REPL or the standard debugger cannot see local lexicals. Known limitations the author calls out are that you cannot create new lexical my variables from the REPL and Control-C can sometimes leave the terminal in a wonky state, and you will need a system readline library installed for interactive editing.

Mail::Message is a Perl class that represents RFC2822 and MIME email messages as first class objects, keeping header and body as separate components and providing easy access to fields, decoded content, multipart parts, and common operations like get(), decoded(), build(), reply(), forward(), bounce(), print(), write() and send(). It is the mail-agnostic core used with Mail::Box for folder-specific behavior and can coerce or convert messages from MIME::Entity, Mail::Internet, Email::Simple and related formats so you can parse, inspect, construct and transmit emails from Perl without wrestling with low-level details. The module handles encoding and decoding, timestamp and label/flag management, and offers helpers for constructing replies and forwards via companion Construct::* modules while exposing methods to estimate size and traverse nested parts. This release series is mature and actively maintained as part of Mail-Message 4.05, which standardizes the message_id parameter name and fixes header folding and string output to always end with a newline, and the author notes a remaining limitation to address automatic transfer-encoding choices for body lines longer than 997 characters.

Mail::Box::POP3 is a Perl module that lets your program treat a remote POP3 mailbox as a Mail::Box folder so you can list, read and manage messages using the Mail::Box framework while the underlying POP3 transport is handled by Mail::Transport::POP3. It supports common authentication modes including APOP, plain LOGIN and OAuth2 (with a special OAUTH2_SEP mode for some Microsoft services), configurable server, port and SSL options, and can transparently re-establish connections when servers support UIDs. The module focuses on retrieval: POP3 does not provide subfolders, folder creation or general server-side writing, so you can fetch headers and bodies and remove messages but you cannot create or fully manage folders on the server. It is part of the Mail-Box family and integrates with its message and body types. Note that releases 4.0 and up use an updated exception model and are not fully backward compatible with older v3 series, and the recent 4.x updates include migration to the Log::Report exception handling and minor bug fixes.

Mail::Box is an object-oriented toolkit for working with mail folders in a uniform way, letting your Perl program read, write, search and manipulate mailboxes regardless of how they store messages. It provides a Mail::Box::Manager to open folders and subclasses that handle common formats like single-file mbox, per-message directories such as Maildir or MH, and remote stores like POP3 or IMAP, while offering conveniences such as delayed body parsing, locking, add/copy/move operations, subfolder handling and tied array/hash access for iterating messages. The module exposes a high-level API for message lookup by index or message-id, batch operations, and safe write/close semantics so it is useful for mailbox conversion, mail clients or automated mail processing. Note that some backends are read-only or partially implemented and that version 4 introduced a new exception model (Log::Report) and is not fully backward compatible with older 3.x behavior, so review the upgrade notes if you are migrating.

App::Test::Generator automates creation of fuzz and corpus-driven test harnesses from formal input/output schemas so you can add broad black‑box tests to Perl modules without hand‑writing every case. You supply a YAML or Perl schema describing a routine's parameters, return types, constraints and optional transforms and the tool produces Test::Most .t scripts that combine randomized fuzzing, deterministic boundary tests, static corpus checks, and optional property‑based tests via Test::LectroTest, with semantic generators for realistic data like emails, UUIDs and timestamps and options for reproducible runs. It integrates with mutation testing and a test dashboard so surviving mutants can drive new test stubs or augmented schemas, supports functional or OO call styles, handles positional and named args, and can inject per‑type and per‑field edge cases automatically. Recent updates added formal TER1/TER2/TER3 coverage metrics in the dashboard and new generate_index.pl flags to emit timestamped mutant TODO stubs and runnable augmented YAML schemas for surviving mutants. Note that the distribution uses a nonstandard licence for commercial use and asks commercial users to contact the author.

HTTP::BrowserDetect parses an HTTP User-Agent string and tells you what browser, browser version, rendering engine, operating system, device type (mobile or tablet), and whether the client is a robot or an HTTP library. You create an object with a user agent string or let it read HTTP_USER_AGENT from the environment and then call intuitive methods like browser(), browser_version(), os(), os_version(), mobile(), tablet(), device(), engine(), robot() and robot_id() to drive feature flags, analytics, logging, or bot filtering. It also provides granular helpers for major/minor/beta parts of versions, many convenience boolean tests for specific browsers, OSes and devices, and a device_string and human-readable names for display. The module is careful about robot impersonation and will often report both the actual bot and the browser it pretends to be. Some older methods are deprecated in favor of clearer names and robot-related helpers are being consolidated, and you should remember that detection depends on the User-Agent string so it can be spoofed. The project is actively maintained on CPAN and GitHub and includes an online demo at browserdetect.org.

Text::PDF is a Perl library for reading and modifying existing PDF files that comes with handy command line utilities for common tasks such as making booklets, removing edits and stamping text on every page. You can use it either from scripts to inspect and change PDF structure or directly via the included programs pdfbklt, pdfrevert and pdfstamp for quick jobs. The module is practical for developers and sysadmins who need programmatic PDF manipulation without relying on heavy GUI tools and it is distributed under the same license as Perl. Recent maintenance moved the source to GitHub and focused on bug fixes and small feature additions, so it remains a useful, maintained choice for basic PDF editing tasks.

Perl::Critic::Policy::Security::RandBytesFromHash is a linting rule for Perl::Critic that finds a common but unsafe pattern where programs try to produce random bytes by hashing predictable inputs such as rand, time, process id, reference addresses or internal counters. The policy explains why hashing those seeds with functions like MD5 or SHA gives a false sense of security and can be guessed by attackers, and it points developers toward secure alternatives such as Crypt::URandom, Crypt::SysRandom or Crypt::PRNG. It flags calls that look like hash functions or joins built from insecure sources and may sometimes report the same construct more than once. The module is aimed at catching legacy and new code that uses this risky shortcut and requires Perl 5.24 or later; the package is newly released as v0.1.0.

Geo::IPinfo is the official Perl client for the IPinfo service that makes it easy to enrich an IP address with geolocation and related metadata. You can look up IPv4 and IPv6 addresses to get city, region, latitude/longitude, ASN, company, carrier, hostname, domain lists, privacy and abuse flags, country and currency data, and more, and the module returns those results as convenient objects you can query from your Perl code. It supports optional API tokens to lift the default free rate limit, offers a faster geo-only endpoint when you only need location data, lets you fetch single fields, and includes configurable caching and country name localization. The library is maintained by ipinfo.io and is useful for web apps, analytics pipelines, fraud detection, and any Perl project that needs reliable IP intelligence. Recent releases have expanded support for IPinfo service tiers including Lite, Core, and Plus and added features such as residential proxy detection to help with more advanced commercial use cases.

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.