CPANscan

MARC::Convert::Wikidata is a conversion helper that turns MARC bibliographic records into Wikibase item objects you can load into Wikidata. It was developed for the National Library of the Czech Republic so many mapping rules are catalog-specific, but it exposes callback hooks for language, people, publisher, series and cover lookups so you can adapt mappings to other environments. You instantiate it with a MARC::Record and then ask it to detect record type (monograph, audiobook, periodical), extract external identifiers, or produce a Wikibase::Datatype::Item representing the bibliographic item. The module relies on a set of item-specific helper classes and is practical when you need automated, scriptable MARC-to-Wikidata conversion while retaining control over library-specific translations and lookups.

Geo::Address::Parser::Country is a small helper for normalising the trailing piece of a place string into a canonical country name, aimed at messy genealogy and imported address data where country names are abbreviated, historical, or inconsistent. You give it Locale::US, Locale::CA (English and French) and Locale::AU objects and optionally a Geo::GeoNames object, then call resolve with the last comma separated component and the full place string; it tries a direct lookup of common variants, recognises US states, Canadian provinces and Australian states and will append a country suffix when appropriate, falls back to Locale::Object::Country and GeoNames if available, and returns the resolved country plus the possibly modified place string, any warnings and an unknown flag. It is tolerant of poor data but currently expects the country or state to be the final comma separated component and a normalise_place helper for inserting missing commas is planned. Note two known caveats from the author: the direct lookup maps "NL" to the Netherlands which can conflict with Newfoundland and Labrador, and Geo::GeoNames objects may need a thin wrapper because of AUTOLOAD masking of can('search'). The most recent release made a CI fix.

CPAN::Maker is a command-line toolchain for turning a Perl project into a CPAN-ready distribution. You drive it with make-cpan-dist.pl or its bash wrapper and a YAML buildspec, and it will discover module dependencies, generate a Makefile.PL, collect your modules, scripts, tests and extra files, and build a tarball ready for publishing. It supports automatic dependency resolution (scandeps or Module::ScanDeps::Static), optional recommended, build and test dependencies, and options to control versioning and which files are packaged, so it is handy for authors who want to automate packaging instead of handcrafting manifests. The author notes that dependency scanners are not perfectly reliable so you should review the generated requires lists. In the recent 1.7.2 release support for Module::CPANfile and Module::ScanDeps::Static was added and packaging was improved to include .pm and .pod files while skipping scanning of POD files.

Numeric::Vector is a Perl module that gives you fast, SIMD-accelerated one-dimensional numeric arrays for heavy numeric work by storing 64-bit floating point values and automatically using the best CPU instruction set available at compile time (AVX2, AVX, SSE2, NEON, or a scalar fallback). It supports both an object-oriented API and a functional style with nvec_* imports, lets you build vectors from arrays or generators like range and linspace, and convert back to Perl arrays. You get elementwise arithmetic, in-place variants, overloaded operators, common math and trig functions, reductions such as sum, mean, variance, dot, norm and cosine similarity, BLAS-style operations like axpy and fma, and utilities for sorting, masking, selection, cumulative ops and predicates like isnan and isfinite. Comparisons produce mask vectors and boolean reductions like any and all are provided, and importing installs true XS subroutine aliases to avoid wrapper overhead. The module is focused on dense double-precision numeric work and is presented as an initial public release.

Perl::Critic::PJCJ is a small set of Perl::Critic rules that help teams keep Perl code readable and consistent by enforcing quoting conventions and line length limits. It offers a policy to prefer simple and consistent string quoting and to avoid unnecessary quote operators, plus a policy to flag lines that exceed a configurable maximum length with a sensible default of 80 characters. The rules are configurable and easy to enable from a .perlcriticrc or the command line, and recent updates added per-file line length overrides via .gitattributes and a way to exempt specific long lines with regex patterns. The module also improves its suggestions for tricky quoting cases and fixes false positives for escaped backslashes, making the guidance more practical for real code. If you want lightweight, configurable checks for quoting style and line width as part of a Perl code quality workflow, this package is a good fit.

Data::ReqRep::Shared provides a high‑performance request/response channel for interprocess communication on Linux using a single shared‑memory file, letting multiple clients send requests and multiple workers reply without a broker or per‑connection sockets. It comes in two variants: Str for variable‑length byte payloads using a mutex‑protected circular arena, and Int for lock‑free int64 requests and responses that is roughly 1.5x faster in single‑process benchmarks. The API is simple: servers recv/recv_wait (including batch receives for Str) and reply by slot id, while clients use synchronous req/req_wait or asynchronous send/get with lightweight per‑request response slots and cancel support. The module integrates with event loops via optional eventfds, supports file‑backed, anonymous, and memfd shared memory, and includes crash recovery features such as PID‑based stale mutex detection, automatic reclamation of dead clients' slots, and generation counters to avoid ABA hazards. Tunables let you size the request ring, response slot pool, and fixed response payload size for Str workloads, and the author provides benchmarks showing competitive cross‑process throughput versus pipes and sockets. Note that this is Linux‑only and requires 64‑bit Perl; the initial 0.01 release implements both Str and Int paths, targeted per‑slot futex wakes, dual eventfd support, and memfd/anonymous creation modes.

Net::CIDR::Lite is a compact Perl module for merging, compressing, and searching large sets of IP address ranges in CIDR or hyphenated formats for both IPv4 and IPv6. You create an object, add CIDR blocks, single IPs or hyphenated ranges, and then retrieve a minimized list of CIDR blocks or short hyphenated ranges while the module coalesces overlapping and contiguous ranges for you. It also provides membership checks via find (with an optional binary-search mode), a prep_find optimization for repeated queries, and a Spanner helper to test many IPs against multiple labeled range sets in one pass. The module is designed as a faster alternative to Net::CIDR when working with many ranges, but it does only basic validation so you should validate inputs to your needs. Recent releases include important security hardening, with version 0.23 fixing IPv6 parsing and IPv4-mapped length issues (CVE-2026-40199 and CVE-2026-40198) and earlier updates disallowing IPv4 octets with leading zeroes.

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.