CPANscan

JSON::Schema::AsType converts a JSON Schema into a Type::Tiny type so you can validate Perl data structures against JSON Schema rules, perform quick true/false checks, and get short or verbose explanations for validation failures. It supports multiple schema drafts with 2020-12 as the default and exposes methods to fetch or register remote schemas, resolve $ref references, validate a schema itself, and retrieve the compiled Type::Tiny type. You can customize type behavior such as treating strings and numbers in the usual Perl loose way by disabling strict_string, and you can add new vocabulary roles to implement custom keywords and constraints. The module passes most JSON Schema test suites but the author notes known limitations around numeric precision depending on the local Perl build, always-on Unicode regex mode for patterns, and some reference-related tests in newer drafts. If you want schema-driven validation integrated with Perl's Type::Tiny ecosystem and a way to extend schema capabilities, this module is a practical fit.

Shannon::Entropy::XS is a small, fast Perl extension that computes the Shannon entropy of a string and returns the result in bits via a simple entropy() function, making it handy for estimating randomness, scoring password strength, or analyzing data distributions. It provides a drop-in, C-backed alternative to the pure-Perl Shannon::Entropy module and is aimed at situations where you need to calculate entropy for many strings or inside tight loops. Benchmarks show it runs orders of magnitude faster than the pure-Perl implementation, and a recent release added a custom opcode that further increased throughput from about 5.95M/s to about 7.63M/s in microbenchmarks, so it is a good choice when performance matters.

Filesys::Fuse3 is a Perl interface to libfuse3 that lets you implement full filesystems in user space by writing simple callback functions and calling Filesys::Fuse3::main to mount them, making it easy to expose virtual files and directories, proxy real filesystems, or build networked mounts all from Perl. It exposes the usual FUSE operations such as getattr, open, read, write, readdir and many others, offers configurable mount and behavior options including single or multithreaded modes, and ships example scripts to get you started. The project was recently forked from the original Fuse module and updated for fuse3 compatibility, so it reflects libfuse3 API changes and no longer implements a few older callbacks like getdir, ftruncate and fgetattr. If you need to prototype or deploy custom filesystem logic in Perl and want to target modern FUSE, this module is directly relevant.

App::DBBrowser is a simple interactive command-line program for exploring SQLite, MySQL, and PostgreSQL databases. It gives you a quick, terminal-based way to connect to a database, browse schemas and tables, inspect rows and column definitions, and run ad hoc SQL without writing a script. It is handy for developers and administrators who need fast, hands-on access to data and structure on local or remote servers and works with standard Perl database drivers. The project is free software distributed under the same terms as Perl 5.10.0.

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.

Term::TablePrint is a small Perl utility for displaying an array-of-array table in a terminal and interactively browsing it with keyboard or mouse controls. It supports familiar navigation keys for scrolling and paging, a regex search prompt, an optional expanded single-row view that prints each column on its own line, and options to hide or choose columns when the table is wider than the terminal. The module automatically adjusts or truncates columns to fit the terminal, aligns numbers, can filter or hex-encode binary fields, optionally shows ANSI colors, and provides a progress indicator for very large tables. You can call it as a simple functional helper print_table or use it in an OO style, and the first row of your input is treated as column headers. Note that it expects decoded strings, a matching STDOUT encoding and a monospaced terminal, and it requires Perl 5.16 or newer. Recent updates improved the binary-to-hex conversion and fixed number fraction formatting.

Jacode is a lightweight Perl module that detects and converts Japanese character encodings so you can handle mixed or legacy text reliably in scripts and applications. It understands common encodings such as Shift_JIS, EUC-JP, JIS and UTF-8, offers helpers to detect a string's encoding and to convert in one call, and preserves compatibility with older jcode-style APIs for easy migration. The module targets Perl 5.00503 and later and is useful if you work with email, logs, legacy files or systems where multiple Japanese encodings appear. Recent maintenance focused on robustness and quality, with a refactor that split init routines for clarity, expanded test coverage and encoding checks, added a security policy, and removed dead code to make the converter more maintainable and trustworthy.

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.

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.