CPANscan

Redis::Fast is a high-performance Perl client for Redis that wraps the hiredis C library to provide a Redis.pm‑compatible API with much lower overhead, making synchronous operations about 50% faster and pipelined workloads up to four times faster in the author's benchmarks. It supports the usual Redis commands, pipelining and async callbacks, publish/subscribe, sentinel discovery with optional sentinel passwords, UNIX domain sockets, optional UTF‑8 encoding control for better throughput, auto‑reconnect and a customizable reconnect_on_error hook useful for managed services like Amazon ElastiCache, and recent releases add SSL/TLS support for encrypted connections. If you need a drop‑in, faster replacement for Redis.pm that handles large batches, background callbacks and resilient reconnections, Redis::Fast is a strong choice, and the latest updates include a hiredis bump and fixes to avoid constructor failures when SSL support is not installed.

Log::Tiny is a lightweight Perl logging library that gives you Log::Log4perl-style features with minimal fuss. You create a logger with Log::Tiny->new and point it at a filename, an existing filehandle, or "-" for STDOUT, then log by calling methods named for your categories like $log->DEBUG("message") or by using the ":easy" export to call INFO and ERROR as functions. Messages are formatted with a simple percent-code format that includes timestamps, caller file/line/sub, process and user IDs and more, and you can customize formats per instance. It supports ordered severity levels with a min_level threshold, a log_only whitelist, lazy evaluation of messages via code references and a would_log predicate to avoid expensive work, and convenience helpers that log then warn or die in the Log::Log4perl style. Caller-depth is configurable for wrapped logging helpers and version 1.3 added the ":easy" process-wide logger exports, lazy-message evaluation, would_log, the LOG* helpers, and a %D{...} strftime timestamp option.

IO::KQueue is a thin, low‑level Perl wrapper around the BSD kqueue system call that lets Perl programs efficiently monitor sockets, files, processes and signals for events. It exposes the kqueue API via an IO::KQueue object with EV_SET to register filters and kevent to poll for events with a millisecond timeout or blocking behavior, returning kevent structures as arrayrefs containing ident, filter, flags, fflags, data and udata fields. Because it mirrors the system call closely, it is best suited for developers who are comfortable with the kqueue man page and need scalable, event-driven IO in Perl on BSD-like systems. Recent maintenance fixed the fflags type and a bug that could push NULL into internal arrays, and the module is now maintained by John Barrett.

Data::RingBuffer::Shared provides a fixed-size circular buffer in shared memory for Linux systems running 64-bit Perl. It stores numeric values as either 64-bit integers or doubles and offers a simple API to write values that always succeed and overwrite the oldest entries when full, plus readers can access data by relative position or by absolute sequence number. The implementation is lock-free so multiple writer and reader processes can share the same buffer without blocking, and readers never observe torn writes because each slot carries a publication sequence and partial writes are skipped. The module also supports waiting for new data, dumping the ring contents, and integrating with eventfd for notifications. Use it when you need a fast, crash-tolerant, nonblocking rolling window for things like metrics, sensor streams, or debug traces.

Data::Reservoir::Shared is a compact shared-memory tool for keeping a fixed-size, random sample of items from a potentially unbounded stream so you can sample logs, telemetry, or large data sets without storing everything. It implements standard reservoir sampling for uniform draws and offers a weighted A-Res variant so heavier items are kept more often. Multiple processes can all feed and read the same reservoir via a backing file, an inherited anonymous mapping after fork, or a memfd, and a shared RNG and futex-based rwlock keep concurrent producers consistent. You feed items with add or add_many and read the current sample with sample or get, and you can clear, seed the RNG for reproducible tests, inspect stats, sync to disk, or unlink the backing file. Items are stored inline and truncated to a configurable byte size (default 256), so you should pass encoded byte strings and be aware of the truncation. The module is Linux-only and requires 64-bit Perl. The implementation includes dead-process recovery for locks but documents two practical limitations: PID reuse is not detected and extremely large numbers of concurrent readers can create a rare reader-slot exhaustion scenario.

Data::ReqRep::Shared is a Linux-only, 64-bit-Perl module that implements a high-performance shared-memory request/response channel so multiple clients and workers can exchange requests and receive per-request replies through a single shared memory file without a broker or per-connection sockets. It offers two variants: Str for variable-length byte-string payloads with a mutex-protected circular arena and UTF-8 flag preservation, and Int for lock-free int64 requests and responses that is faster for simple numeric workloads. Replies are routed back via a fixed pool of response slots that use per-slot futexes and a generation counter to avoid ABA and allow targeted wakeups, and the API supports synchronous and asynchronous patterns, eventfd integration for event loop wiring, file-backed or memfd/anonymous creation, and tuning knobs for queue capacity, in-flight slots, and response size. The module includes crash-recovery mechanisms such as PID-tracked stale mutex recovery and automatic reclamation of slots held by dead clients. Recent releases focused on security and robustness, notably creating backing files with mode 0600 by default to limit access and adding bounds checks and recovery fixes around response handling.

Data::RadixTree::Shared provides a compact, high-performance compressed radix (PATRICIA) tree that lives in shared memory on Linux and maps raw byte-string keys to 64-bit unsigned integer values. It uses edge compression so lookups and inserts run in time proportional to key length and it supports longest-prefix queries, which makes it well suited to routing tables, dispatch tables, autocomplete back ends and any application that needs the most specific stored prefix for a query. Multiple processes can share one tree via a backing file, a memfd or by inheriting an anonymous mapping across fork and readers run in parallel while writers are serialized by a futex-based rwlock with dead-process recovery. Note that keys must be provided as bytes not wide-character strings, capacity for nodes and label bytes is fixed at creation and an insert will fail if the pool or arena is exhausted, and deletes are lazy so space is only reclaimed by clear. This module is Linux-only and requires 64-bit Perl, and backing files default to owner-only permissions unless you request otherwise.

Data::Queue::Shared provides very fast, bounded multi-producer multi-consumer queues backed by mmap’ed shared memory for Linux and 64-bit Perl, making it easy to pass integers or variable-length messages between processes without heavy IPC overhead. Its Int variants use a lock-free Vyukov algorithm for peak throughput on integer job ids or counters while Str queues store bytes in a circular arena protected by a futex-based mutex so you can push arbitrarily sized messages with efficient arena reuse. You can create file-backed queues, anonymous fork-inherited queues, or memfd-backed queues whose file descriptor can be passed to other processes, and the module supports blocking waits with timeouts, batch push/pop operations, eventfd notifications for event-loop integration, and crash-safe recovery of stale Str mutexes. Capacity is fixed and rounded to a power of two and Str queues let you tune the arena size to trade memory for maximum message size. If you need maximum lock-free scaling for fixed-size payloads the documentation recommends the related Data::Deque::Shared::Str, and the module protects backing files with sensible default permissions. Use this when you need high-throughput, low-latency shared-memory queues between processes on Linux.

Data::Pool::Shared is a Linux-only, 64-bit Perl module that provides a fixed-size, cross-process object pool in shared memory so programs can allocate, use, and free numbered slots much like a simple memory allocator for IPC. It offers a raw byte pool plus typed variants (I64, I32, F64, Str) that expose atomic primitives such as CAS, exchange and add for lock-free concurrent updates, and it uses a CAS-based bitmap with futex blocking when the pool is full for high performance under contention. The module supports batch allocation/free, zero-copy read access via SVs, raw pointers for FFI or OpenGL, memfd and file-backed mappings, fork inheritance, and a recover_stale routine to reclaim slots held by dead processes. Backing files are created with restrictive permissions by default and attach-time header validation prevents mismatches between handles. The recent 0.08 release fixed a use-after-free issue in set(), strengthened header and size validation, and made several robustness and guard-behavior fixes, making it a solid choice for high-throughput, low-latency shared-memory object pools in Perl.

App::Regather is a small, pluggable Perl framework and command line tool for periodically collecting information and triggering actions based on that data. It uses a simple configuration system and a plugin API so you can add behaviors like running scripts, maintaining lists, reading config files, or performing DNS updates with nsupdate while built-in logging captures what happened. If you need an extensible way to automate recurring maintenance tasks or respond to changing system state, App::Regather gives you a lightweight, modular foundation that is easy to extend with your own plugins.

OpenSearch::Client is an unofficial Perl client that lets Perl applications communicate with OpenSearch clusters to perform indexing, searching and basic cluster operations. It was forked from Search::Elasticsearch when the OpenSearch API diverged, so it preserves the familiar Perl client interface and defaults to connecting to localhost:9200 while supporting remote nodes and the OpenSearch API surface. Documentation is available via OpenSearch::Client::Manual and a companion distribution, OpenSearch::Client::Hash, can produce BCrypt, Argon2 and PBKDF2 password hashes for user setup. The module is actively maintained under the Apache 2.0 license and is a straightforward choice when you need a Perl-native way to work with OpenSearch.

Net::SNMP::QueryEngine::AnyEvent is a lightweight AnyEvent-based client for the snmp-query-engine daemon that lets Perl programs perform non‑blocking, multiplexed SNMP queries and manage per-destination options via simple callback APIs. It provides get, gettable, info, dest_info, setopt and the newer getopt calls, plus utility methods like when_done and wait for integrating with an event loop. The client queues requests while the daemon connection is down and will retry connecting automatically by default, calling request callbacks with failure if an in‑flight query was lost; you can customize reconnect timing or disable reconnects. Version 1.1.0 adds on_connect and on_disconnect constructor callbacks so you can react to connection events and re-establish per-destination state, and introduces the getopt method for querying destination options. This module is a good fit when you need asynchronous SNMP access in an AnyEvent application and already use or can deploy an snmp-query-engine daemon.

LWP::Protocol::https is a small plug-in that enables LWP::UserAgent to fetch HTTPS URLs by using HTTP over SSL/TLS, so you do not call it directly but install it to give LWP builtin https support. It honors LWP::UserAgent ssl_opts such as hostname verification and lets you supply SSL_ca_file or SSL_ca_path for certificate validation, and when verification is enabled it will fall back to the CA bundle provided by Mozilla::CA unless you override it. The module was split out of libwww-perl so applications can simply depend on it rather than on its lower-level SSL libraries. Recent releases improved proxy handling to support TLS-enabled (https://) proxies and contain small test-suite fixes to make installation more robust.

Litavis is a fast CSS preprocessor and compiler for Perl that implements its parsing and compilation engine in C and exposes it through XS, designed as a successor to the pure-Perl Crayon with an emphasis on correctness and performance. It accepts CSS from strings, files, or directories and supports nested selectors with flattening, parent selector references, preprocessor variables, mixins, map variables, compile time colour functions, cascade aware deduplication, and both minified and pretty output. Typical use is to create a Litavis object, parse one or more inputs, then compile or write the result to a file, and reset when you need a fresh state. The distribution also installs reusable C header files so other XS modules can embed the same engine, and it preserves CSS custom properties and functions like var and calc by passing them through unchanged. The recent 0.03 update adds portability fixes to improve builds on Windows and MinGW.

Hazy is a tiny Perl-based CSS framework and preprocessor that scans a source folder of simple template files and compiles them into combined CSS files, producing both a readable stylesheet and a minified version. It offers a minimal syntax for variables, shorthands and reusable blocks so you can declare colors, margins and snippets once and reference them across files, and it is configured by pointing Hazy at a read directory, a write directory, a target filename and the file extension to find. Hazy is aimed at small projects and developers who want a lightweight, easy to use tool to generate static CSS without the complexity of larger preprocessors.

Crayon is a Perl-based CSS preprocessor and compiler that lets developers write more maintainable stylesheets by using variables, scoped values, reusable mixins and maps, and nested rules that expand into standard CSS. It includes a set of color and transformation functions like lighten, darken, tint and greyscale, supports inline and block comments, and can output either minified or human friendly "pretty" CSS. Crayon also tries to deduplicate identical declarations across selectors so the final stylesheet is smaller and easier to manage. You interact with it through a simple API to parse strings or files and to compile the internal structure back to CSS or a file. The project has been succeeded by Litavis for those who prioritize speed and correctness, but Crayon remains a straightforward option for Perl programmers who want Sass-like features without leaving the Perl ecosystem.

Apache::Session::Generate::Random is a small driver for Apache::Session that supplies secure, system-sourced random session IDs so your web app can avoid predictable or weak identifiers. It plugs in as the Generate component when tying an Apache::Session or Apache::Session::Flex store and uses the operating system’s randomness facilities (via Crypt::SysRandom) to produce hard-to-guess IDs. If you need stronger session identifiers than simple counters or naive RNGs this module is a drop-in way to improve session security while remaining compatible with older Perl versions. Recent updates added a companion for Apache::SessionX and refreshed distribution metadata and packaging.

Crypt::SysRandom::XS is a small, fast XS-based Perl module that gives you cryptographically secure random bytes from the operating system via a single function, random_bytes($count), which returns a string of $count unpredictable bytes. It selects the best native source available at build time, for example getrandom on Linux, arc4random on BSD and macOS, BCryptGenRandom on Windows, and RDRAND as a final fallback, so your code can get system-quality randomness without platform-specific plumbing. The API is minimal and portable, making the module useful for generating keys, nonces, tokens, or seeds for higher-level crypto libraries, and recent releases include important correctness and security fixes, notably disallowing negative length requests to address CVE-2026-2597.

ExtUtils::CppGuess is a small utility for Perl module authors who need to compile C++ code alongside Perl extensions, helping pick a C++ compiler that is compatible with the C compiler Perl was built with and emitting the correct flags for ExtUtils::MakeMaker or Module::Build. It detects common compiler families such as GCC, Clang, MSVC and Sun Studio, respects the CXX environment variable, and lets you add extra compiler or linker flags while providing ready-made options like CCFLAGS and OTHERLDFLAGS or Module::Build settings. The module can also produce a runnable compiler command, return the appropriate include filename for iostream portability, generate small compatibility macros for standard headers and namespaces, and supply standard-specific flags up to C++23. It is intended to simplify cross-platform build setup for XS or XS-adjacent C++ code, although there is a noted edge case with very old Perls and older ExtUtils::CBuilder releases where detection may have problems.

Eshu is a fast XS-based Perl module and command-line tool for fixing indentation and generating syntax-highlighted HTML for a wide range of languages including C, Perl, XS, XML/HTML, CSS, JavaScript/TypeScript, Python, Go, Rust, Java, PHP, Ruby, Lua, Bash, SQL, YAML, JSON and POD. It adjusts leading whitespace by understanding language-specific constructs so braces, heredocs, strings, comments and other syntax are handled correctly while leaving code content untouched. You can call per-language methods or auto-dispatch by filename or explicit language, configure tabs or spaces and indent width, run it on single files or entire directories, preview diffs or run in CI check mode with the bundled eshu tool, and use the included vim plugin for editor integration. Highlighting produces HTML with span classes for token types so you can style output. File processing skips binary or very large files and relies on extension-based detection when needed. Eshu is aimed at developers and maintainers who want a quick, reliable way to normalize indentation and add lightweight syntax highlighting across many file types.

Dancer2::Plugin::Feed is a lightweight Dancer2 plugin that lets you generate RSS or Atom feeds from your web app without dealing with raw XML. It wraps XML::Feed and XML::Feed::Entry and exposes create_feed plus convenience shortcuts create_atom_feed and create_rss_feed. You pass feed metadata either in your Dancer2 config or as parameters and provide entries as an arrayref of hashrefs with keys like title, link, summary, content, author, issued and modified. The plugin sets the appropriate Content-Type header for the chosen format and surfaces format-related errors via exception roles so you can handle them in route code. If you want quick, configurable feed generation integrated with Dancer2, this module does the job while delegating the XML heavy lifting to XML::Feed.

Devel::Required is a small developer tool that automatically updates your distribution's README and POD with the modules and versions you declare in PREREQ_PM when you run ExtUtils::MakeMaker, saving you from manually copying dependency lists into documentation. You load it in an eval before calling WriteMakefile and it will look for specific marker headings in text or pod files and replace those sections with the VERSION and REQUIRED MODULES information taken from the generated Makefile, or you can tell it which files to use via text and pod options. It can also inject installation guidance for projects that maintain separate maint and blead branches. This module is intended for authors' machines only because it will modify files in-place and it works by wrapping the calling package's WriteMakefile routine.

CGI::BrowserDetect is a lightweight Perl helper for web applications that need to identify a client’s browser, operating system, device type, language and country from HTTP headers. It builds on HTTP::BrowserDetect and takes your User-Agent and Accept-Language header values to return data via a detect method or convenience methods such as device_type, lang and cnty, so you can tailor content or behavior for different browsers, phones or locales. It is simple to drop into CGI or other server-side code and will consult Accept-Language when the User-Agent does not provide locale information. The most recent release is a small maintenance update that removed PAX headers from the package.

UNIVERSAL::dump is a small debugging helper that injects readable inspection methods into every Perl class and object so you can call things like dump, peek, blessed or refaddr without editing your modules. By default dump returns a Data::Dumper representation or prints it to STDERR when used in a void context which makes quick debugging output convenient. You can enable selected method names or map custom method names to the built‑in inspectors and to fully qualified dump routines. It relies on Data::Dumper and uses Devel::Peek and Scalar::Util for the peek, blessed and refaddr behaviors when requested. Be aware that adding methods to UNIVERSAL prevents AUTOLOAD from catching those names and the module will die if you try to register the same method name with a different underlying routine.

BATsh is a pure-Perl bilingual shell that lets a single script mix Windows cmd.exe batch syntax and Unix sh/bash syntax and run them line by line with a shared variable store, so you can call CMD-style commands and then switch to shell functions, pipelines and arrays without launching an external shell. It provides a command-line runner and REPL, supports running inline source and files, preserves exit status across mode boundaries, and includes practical features like CP932 (Shift_JIS) auto-detection for Japanese Windows scripts. Builtins for both CMD and SH are implemented in Perl and external programs are invoked via the host OS, so common Windows or Unix utilities work where they exist. The module runs on Perl 5.005_03 or later and is useful when you need cross-platform or mixed-syntax scripting in a single file. Note that a few complex or platform-specific commands are not reimplemented and some advanced behaviors have limitations compared with the native shells.

setenv is a tiny Perl pragma that lets you set or unset %ENV entries at compile time so you can inject predictable environment variables during program startup or tests. You invoke it like use setenv FOO => 1, BAR => 2 to set values during compilation or use no setenv or no setenv qw(FOO BAR) to clear variables. It is deliberately minimal and dependency free, intended as convenient syntactic sugar for debugging and build scenarios rather than a full runtime environment manager. The module was authored by Elizabeth Mattijsen and was adopted for maintenance in 2019 by Robert Acock.

Coerce::Types::Standard is a helper library that builds on Types::Standard to provide ready-made coercion types for common data conversions, making it easy to turn strings into arrays or hashes, flatten or merge nested structures, switch between hashes and arrays, handle HTML entity encoding and decoding, parse and manipulate URIs, count elements, and encode or decode JSON. Each coercion type can be configured with a simple "by" parameter to control behavior such as split delimiters, selection modes like keys or values, or encoding options, so you can wire these conversions directly into attribute definitions or validation layers. If you work with typed attributes or need consistent, reusable rules for transforming incoming data into the Perl structures your code expects, this module gives a compact, declarative way to do that.

Stats::LikeR brings a broad collection of R-like statistics and tidy-data tools to Perl, packaged as an XS-backed library for much faster numeric work. It understands multiple data-frame shapes (array-of-arrays, array-of-hashes, hash-of-arrays, hash-of-hashes) and provides familiar operations such as aggregation/group_by, merge/concat/rbind, pivot_table/melt, reshaping helpers, many statistical tests (t, ANOVA, chi-square, Fisher, Wilcoxon, Kruskal, KS, etc.), regression and GLM, PCA, interpolation and binning, and utilities like colnames/rownames/vals/value_counts. It also reads and writes delimited files and XLSX workbooks, supports in-place column transforms and column-wise assignment, and aims to match R/pandas behavior where useful while keeping Perl idioms. The module is actively maintained with many recent fixes and speedups, notably moving the numeric interpolate core into XS for large speed gains and a 0.26 fix for a long-double issue, so it is a good choice if you want R-style data manipulation and statistics inside Perl with production-oriented performance and robust error handling. Be aware a few R conveniences are intentionally limited here, for example its ANOVA routines produce Type-I (sequential) tables and predict has constraints around factor-level reconstruction, which the author documents.

PDF::Make is a Perl toolkit for creating, editing, and reading PDF files. It offers a recommended high-level, chainable Builder API that handles layout, page management, word wrap, font metrics, images, and common document tasks for quick report and form generation. For users who need full control it also provides a low-level XS API that maps directly to PDF concepts and content streams. The distribution includes parsers and extractors for reading existing PDFs, font and image support, interactive features like links and AcroForms, security features including encryption and digital signatures, and utilities such as attachments, watermarks, redaction, and linearization. It has minimal runtime dependencies beyond Object::Proto and is a good fit for Perl projects that need reliable programmatic PDF manipulation.

Hash::Typed provides ordered, typed hash containers for Perl that let you declare what keys a hash must have and what types their values must be. You can create a Hash::Typed object or tie a hash to it, enable strict and required-key checks, use type constraints from Types::Standard or supply custom validator coderefs, and even nest Hash::Typed instances for structured data. Assignments or instantiations that do not satisfy the declared constraints raise errors, which helps with input validation, configuration handling, and enforcing clearer data contracts. Recent updates include improved test coverage to 100 percent and a minor packaging cleanup.