CPANscan

Algorithm::UrataniTakeda implements the Uratani-Takeda multiple-string search algorithm to let you find many patterns in a text quickly by combining ideas from Aho-Corasick and Boyer-Moore, with behavior similar to Commentz-Walter. You construct it with a list of patterns and then either call search with a callback that is invoked for each match, use matches to collect all matches, or use first to get the first match. The callback may return false to stop further searching. This is an experimental implementation that requires Perl 5.26 or later, the initial release is on GitHub, and issues or test cases should be reported there.

Object::Pad is a modern CPAN module that gives Perl a concise, class-and-role syntax built around lexical fields that act as private object members. It supplies class and role keywords, automatic construction with named parameters via field :param, field declarations with reader/writer/mutator/accessor helpers and default or deferred initialisers, methods with a lexical $self and automatic signature parsing, and BUILD and ADJUST phasers for construction-time hooks. The module also supports private lexical methods, anonymous and lexical classes, role composition, and multiple instance representations including native, blessed-hash and magic forms, making it useful both for new pad-based code and for interoperating with classic Perl classes. Object::Pad is a test bed and preview of Perl core's forthcoming class feature so it can be used to write forward-compatible code, but some recently added capabilities are still experimental and may emit warnings or change over time. Use it when you want clean, encapsulated object syntax in Perl and you welcome a feature-rich, actively evolving implementation.

ExtUtils::Typemaps::Magic supplies a T_MAGIC typemap for XS authors that acts as a drop-in replacement for T_PTROBJ but keeps the underlying C pointer out of the Perl-visible SV by storing it in attached magic. That makes the pointer invisible to pure-Perl code and prevents it from being serialized and deserialized, which is usually desirable because such pointers would not be valid after deserialization. You bring it into your build by merging the typemap into your project's typemap or by embedding it at build time, and it includes related helpers such as T_MAGICBUF. You still need to provide a DESTROY method to free the native buffer and this approach is not automatically safe across thread cloning. The recent 0.010 release added *_magic and *_arg extra variables to input maps to give you more flexible argument handling.

Crypt::Passphrase::Linux is an encoder plugin for Crypt::Passphrase that produces and verifies password hashes in the same formats used by Linux crypt, making it easy to work with sha512, sha256, md5, apache_md5 and traditional DES password entries. You can choose the hash type and tune the work factor by setting rounds, which defaults to 656000 and is ignored for DES, and the module also accepts legacy crypt values so existing hashes keep working. It integrates simply via Crypt::Passphrase->new(encoder => { module => 'Linux', type => 'sha512', rounds => 656_000 }). The current release switched salt encoding to crypt64 and added DES support.

Compress::Raw::Lzma is a low‑level Perl wrapper around the liblzma library that gives direct, in‑memory access to LZMA/XZ compression and decompression. It provides encoder and decoder classes for easy, alone, stream and raw modes so you can compress or decompress data either in a single call or streamed in chunks. The interface is buffer oriented and built around code and flush methods with options to control appending, buffer size, memory limits and integrity checks. You can build custom filter chains including LZMA1/LZMA2, BCJ filters for executables and delta filters, set dictionaries and tweak compression presets and match finders for fine tuned performance. The module also exports the usual status constants and version reporting functions. It is primarily intended as the backend for IO::Compress::Lzma, IO::Compress::Xz and related modules but is perfectly usable directly when you need precise, low‑level control over compression behavior.

Compress::Raw::Bzip2 provides a thin, low-level Perl binding to the libbzip2 compression library so you can perform in-memory bzip2 compression and decompression directly from Perl. It exposes compressor and decompressor objects with options for block size, work factor, append or consume behavior, and memory-limiting decompression, and it returns bzip2-style status codes for fine-grained control. The module also exports bzip2 constants and a function to report the underlying library version. It is the foundation used by the higher-level IO::Compress::Bzip2 and IO::Uncompress::Bunzip2 modules, so use it when you need direct, efficient access to libbzip2 features and control, and use the IO::Compress wrappers when you prefer simpler file or stream handling.

Compress::Raw::Zlib is a thin, low level Perl binding to the zlib or zlib-ng libraries that gives you direct control over in memory compression and decompression via Deflate and Inflate objects, exposing options such as compression level, window bits, dictionaries, buffer sizing, append behavior and checksum tracking with crc32 and adler32. The module returns native zlib status codes so you can manage streaming, flushing, resetting and tuning of streams, and it provides helpers to combine checksums and detect whether it was built against zlib or zlib-ng. It also includes a LimitOutput mode to avoid unbounded memory growth when inflating pathological inputs. Choose this module when you need precise, low level access to zlib features or maximum performance, and use the higher level IO::Compress/IO::Uncompress family if you prefer simpler file and archive handling.

Webservice::Rosary::API is a lightweight Perl client for the public Rosary API that needs no authentication and makes it easy to fetch full recitation text or generate direct MP3 download URLs for today's, yesterday's, tomorrow's or a random Mystery. It provides simple methods like mp3Link to get an audio URL, details to retrieve the full decade text, day to map a weekday to its traditional Mystery, and clear_cache, and it installs an interactive commandline tool called "avemaria" that can either print a Mystery or lead you through the recitation with configurable pacing and live controls. The module ships with sensible defaults such as a 10 second HTTP timeout, an injectable user agent for testing, conservative error handling with optional stale-cache fallback, and a small per-instance in-memory cache (300 second default) while still ensuring truly random requests are fresh. Recent releases added robust tests and improved HTTP error handling, fixed day validation and MP3 response edge cases, enhanced cache behavior, and expanded the CLI with scroll mode, timing controls and real-time pause/speed keys. Use this if you want to add Rosary audio or guided-text recitations to scripts, bots, or commandline workflows without dealing with raw HTTP and JSON parsing.

Business::Payr is a lightweight Perl client for the Payr payments API that lets your application onboard tenants with tenancy and KYC details, create short‑lived embedded payment sessions, rotate server API tokens, and verify incoming webhooks. It handles authentication and HTTP transport so you call simple methods like onboard_user to submit user and tenancy data, create_payment_session to receive a 15‑minute session object that includes an iframe_html helper for embedding the Payr payment interface, and rotate_token to issue a replacement server API token while the old token remains valid for a short grace period. The distribution also includes Webhook helpers with HMAC‑SHA256 signature verification and typed accessors for payment payloads, supports sandbox hosts for testing, and raises exceptions containing API validation details on error. This is the initial release series and v0.02 contains a small fix to the documentation (POD).

dozo is a small, user-friendly wrapper around Docker that lets you run shells and commands inside containers without writing long docker run lines. It automatically handles common details like mounting your project or home directory, inheriting useful environment variables (locale, proxies, API keys), mapping ports and volumes, and setting up interactive TTYs so git and other tools behave as expected. dozo is git-aware and preserves relative working directories, supports a persistent "live" container mode to keep installed tools and state between invocations, loads defaults from .dozorc, and can forward X11 or mount the Docker socket for Docker-in-Docker use. The default image is geared toward document translation and text processing, but you can specify any image. dozo is implemented as a Bash utility and requires Bash 4.4 and the getoptlong.sh helper, so it is a good fit for developers who want a simple, repeatable way to use containerized tools without wrestling with Docker command syntax.

PostScript::Columns is a compact Perl tool that turns plain text into a printable PostScript document by packing the content into as many columns as will fit and adding a customizable header and footer. You invoke it with pscolumns and provide options for page margins (in points), header and footer text and fonts, body font and size, and the body text; header and footer fields are tab-separated into left, center and right areas and may include $p and $pp for current and total page numbers. The module only uses the bundled monospace PostScript fonts (NimbusMonL variants) and you may need to tweak margins for different printers. Noteworthy recent changes include matching the margin argument order to CSS, raising the left/right margin defaults to 20 points, and adding a page label consistent with DSC.

Math::NumSeq provides a common base class for generating and iterating over mathematical number sequences in Perl, letting you create sequence objects that yield index/value pairs via a next method and be rewound or queried for the current position. It is designed to cover anything from trivial sequences like squares to complex or infinite sequences such as primes, and many concrete subclasses are supplied for common sequences, so you usually use Math::NumSeq::Foo rather than this base class directly. The API also exposes optional capabilities when available, including random access to the i'th element, membership testing, value-to-index lookups and approximate index estimates, and it carries descriptive metadata like human-readable descriptions, value bounds, OEIS A-numbers, and characteristic flags to help tooling. The implementation tries to handle big integer types where needed and to iterate progressively for efficiency, but some of the advanced methods are optional and may not be implemented for every sequence, so callers should check for their presence before using them.

Mail::DMARC is a Perl library that implements DMARC email authentication and reporting so mail servers and filters can decide whether a message is legitimately from the domain it claims. It supports the current DMARCbis standard and the original spec including organizational domain discovery and policy tags. You give it basic SMTP metadata plus SPF and DKIM results and call validate to get a Result object that shows pass or fail and the policy disposition so MTAs, spam filters, or other tools can accept, quarantine, or reject mail. It also handles reporting workflows: sending and receiving aggregate reports, storing them in a SQL-backed report store compatible with SQLite, MySQL, and PostgreSQL, and viewing reports via included CLI and HTTP tools. The module is available as a pure Perl implementation and as an XS wrapper around libopendmarc and aims for correctness, maintainability, and easy integration with minimal extra dependencies when reporting is not used.

Devel::Camelcadedb is the Perl-side component that lets JetBrains IDEs like IntelliJ IDEA, via the Camelcade plugin, connect to and control a running Perl program for interactive debugging. It manages the debugger connection so you can set breakpoints, inspect variables and step through code from the IDE, and provides simple helpers to connect or reconnect, check the connection, disconnect, and temporarily disable or re-enable debugger hooks. It can also integrate with template engines by accepting a hook that maps template source lines to evaluated code so breakpoints work inside templates. The module has evolved to handle complex data structures including references and cyclic data, supports taint mode and common web deployment scenarios, and offers a developer mode for verbose output. The latest release improves variable display by rendering numeric scalars without quotes for clearer, more accurate inspection in the IDE.

SPVM::Go brings the lightweight concurrency model of the Go language to SPVM by providing goroutines and channels so you can write asynchronous code in a familiar Go style. It integrates with libuv to suspend goroutines for timers, IO, and channel operations instead of busy-waiting, which keeps CPU usage very low and allows thousands of concurrent goroutines in a single process. The API offers simple primitives for spawning goroutines, creating buffered or unbuffered channels, performing select operations, sleeping and waiting on IO with timeouts, and includes helper components such as wait groups, signal handling, time and context types. A few scheduler and IO wait functions must be called from the main thread and will throw exceptions if used otherwise, and IO timeouts raise specific errors for handling. If you need Go-style concurrency for IO-heavy or highly concurrent workloads in SPVM, SPVM::Go is a practical, efficient option and the project is available on GitHub under an MIT license.

HTTP::Tiny::Paranoid is a drop-in, safer subclass of HTTP::Tiny that checks every hostname with Net::DNS::Paranoid before connecting and aborts requests to hosts that are rejected. By default it blocks private network ranges to help prevent accidental or malicious access to internal services, and you can tweak its behavior with class methods to set blocked_hosts or whitelisted_hosts. It is especially useful when fetching URLs from untrusted sources because it reduces the risk of server-side request forgery and DNS-based attacks. Recent updates add protection against DNS rebinding by allowing an overridable peer address to be checked and include a basic test suite to improve reliability.

Linux::Event is a Linux-only, XS-first asynchronous I/O framework that gives you an epoll-based reactor plus a family of high-level objects for streams, listeners, datagrams, timers, signals, wakeups and process lifecycle management. You implement network behavior by subclassing Linux::Event::Stream or Linux::Event::Datagram, create a Linux::Event::Loop, attach connections either at construction or with Loop->add, and let the loop drive nonblocking reads, buffered writes, native framing, TLS handshakes, deadlines, and backpressure for you. The distribution also provides native UDP and Unix datagram support with recvmsg/sendto semantics, pidfd-based process notifications and async stdio, a declarative OpenSSL TLS policy, and helpers for framing and structured errors, so it is well suited to high-performance servers and clients that need tight integration with Linux primitives. Building and running it requires a Linux runtime with pidfd support, certain libc helpers and OpenSSL 1.1.1 or newer. The recent 0.103 release focused on robustness and lifecycle safety by making raw loop registration handles inert after cancellation or replacement, improving recovery from callback exceptions, and tightening Stream flow-control and descriptor handling to avoid tricky reuse and shutdown races.

SPVM::R ports core R language features into the SPVM Perl environment so you can work with R-style data structures and numeric operations without leaving Perl. It provides N-dimensional arrays in many native types including integers, floats, complex numbers, strings and datetimes, plus NA support and a full set of elementwise and reduction operations such as arithmetic, trigonometry, exponentials, logs, sum, mean, cumulative functions and dot products. It also includes matrix routines with column-major layout and a data frame implementation that supports adding typed columns, slicing, sorting, and conditional row selection. The module comes with operation-specific namespaces for convenience, examples and a tutorial on GitHub, making it a practical choice for SPVM developers who need R-like data manipulation, statistical primitives or matrix math integrated into Perl code.

SPVM::Net::SSLeay is an SPVM binding to OpenSSL that mirrors Perl's Net::SSLeay and gives SPVM programs direct access to TLS/SSL functionality and OpenSSL data structures such as SSL, SSL_CTX, X509, EVP, BIO, PEM and many others. You can create SSL methods and contexts, attach them to socket file descriptors, perform handshakes, read and write encrypted data, handle certificates and ALPN, and register callbacks for events from the OpenSSL layer. It includes many helper classes and error types to make OpenSSL features available from SPVM code and uses a thread-safe mapping layer so native OpenSSL callbacks can find their corresponding SPVM objects. LibreSSL is supported and OpenSSL 1.1.1 is required. In the latest release the module raised its SPVM requirement to 0.990196, simplified its build by renaming config files to .build and producing a single DLL file, making installation and distribution cleaner.

OpenMP::Environment is a small Perl utility for managing OpenMP and GNU libgomp environment variables by reading and modifying %ENV, making it easy to prepare the runtime settings you need before launching OpenMP programs or to coordinate with in-process OpenMP code via OpenMP::Simple. It exposes getter, setter, and unsetter methods for the canonical OMP_* and GOMP_* names recognized by GCC libgomp, validates simple and stable syntaxes while passing through complex grammars unchanged, and offers convenience features like assert_omp_environment and human-readable summaries. The module is particularly handy for benchmark drivers, parameter sweeps, HPC launchers, test harnesses, and any workflow that needs to change thread counts, affinity, allocators, or related settings for child processes or for code loaded into the current Perl process. Version 1.3.0 adds support for OMP_ALLOCATOR, OMP_AFFINITY_FORMAT, OMP_DISPLAY_AFFINITY, and comma-separated OMP_NUM_THREADS for nested levels, and it is deliberately conservative about validation so it stays compatible with libgomp’s more complex option grammars.

Speak is a lightweight Perl module that converts text into spoken audio using Google’s TTS and plays it on your speakers. It accepts a message as a string, a filehandle, or falls back to the clipboard and lets you set the language and a persona via environment variables or a small config file. Persona-based voices can be routed through an MCP server and local voice files, though that feature is marked experimental. The module supports logging and a simple mute mechanism and depends on common CPAN modules such as Clipboard, LWP::UserAgent, and URI::Escape, so it is a practical choice when you need fast, scriptable text-to-speech in Perl.

MooX::Tag::TO_HASH is a small Moo role that adds a predictable way to convert your Moo objects into plain Perl hashes by tagging the attributes you want exported. You mark fields with a to_hash option when you declare them and the role installs a TO_HASH method that builds a hash using optional alternate keys and per-attribute flags such as if_exists, if_defined, and no_recurse. Nested arrays and hashes are walked and object values are converted via their own TO_HASH when available unless you disable recursion for a given attribute. Attributes inherited from parent classes or roles are handled automatically and you can make final adjustments by providing a _modify_hashr or modify_hashr method to mutate the result in place. The module warns against using method modifiers to alter TO_HASH because that can behave unexpectedly with role inheritance. Recent releases fixed a bug where adding a to_hash or to_json flag while overriding an attribute in a subclass could cause a runtime error.

App::FuguWeb is a small tool that turns a Perl project's existing man pages, POD sidecars, and Markdown files into a single static documentation site. It calls standard renderers (mandoc, lowdown, pod2man) and wraps their output in one shared chrome, writing a flat output directory with a single stylesheet named style.css. You configure the site with a .fuguwebrc file using the Fugu::Config grammar and keep content and assets in a source directory so a simple fuguweb build produces the site with no other build recipe. The project deliberately has no templating language and no JavaScript, so the output is minimal and dependency-light. The distribution also exposes a few utility functions and constants for escaping HTML and attributes, listing directories in a deterministic byte-sorted order, and checking whether a path lies below a root, plus commands to build and check the built site. Use App::FuguWeb when you want a reproducible, low-friction way to publish the documentation your Perl project already maintains.

HTML::D3 is a small Perl helper for quickly producing D3.js charts by emitting the HTML and JavaScript needed to display bar charts, line charts, multi-series line charts and variants with tooltips, animated tooltips, legends and interactive legends. You create an object with optional width, height and title, pass simple arrayref data structures, and the module returns ready-to-use HTML/JS snippets for embedding in a web page or template, with a convenience method that returns an embeddable fragment (svg_id and html) for use in Mojolicious or similar layouts where you want to manage the page wrapper yourself. It is aimed at Perl developers who want to generate visualizations without hand-crafting D3 code and expects you to include the D3 library in your page when using fragments. Recent updates in v0.08 added Params::Get, Object::Configure support, a test dashboard and the render_line_chart_snippet helper, plus a tidy-related bug fix for tooltip escaping. The module is provided as-is under GPL2 and is useful when you need simple, programmatic D3 charts from Perl without deep front-end work.

JSON::Validator::Schema::Troglodyne adds Troglodyne LLC's custom type extensions to the JSON::Validator::Schema::OpenAPIv3 validator so you can declare and validate a couple of useful types in your OpenAPI schemas. It supplies an email type that uses Data::Validate::Email::is_email to check addresses and a callback type that documents a string as the fully qualified name of a Perl subroutine. The module exists because the upstream validator lacks a formal hook for injecting custom formats, so it relies on the validator's dynamic _validate_type_* dispatch mechanism and may break if that internal behavior changes. If you build or consume OpenAPI schemas in Perl and need straightforward email or Perl callback validation, this module provides a lightweight, ready-made option and issues can be reported on the project GitHub.

CGI::Lingua is a Perl utility for adding language and locale awareness to web applications by negotiating the best language and regional variant to present to a user. You provide the list of supported RFC-1766 language tags and the module uses Accept-Language, optional user-agent cues, and IP-based geolocation backends to return human-friendly language names, two-letter language and country codes, sublanguage names, text direction, CLDR-style plural categories, a best-match translation file path, and best-guess locale and timezone information. It integrates with CHI for caching and accepts logger and CGI::Info-like objects so you can plug it into existing apps. The author notes some important caveats such as embedded plural rules that truncate fractional values and do not replace Locale::CLDR, country lookups that fall back to slow WHOIS queries unless a local geo module is installed and caching is enabled, is_rtl covering only primary-script RTL languages, and the logger parameter must be a blessed object with warn/info/error methods. If you need a practical, configurable way to detect and adapt to visitors language and regional preferences in CGI apps, CGI::Lingua is a solid choice.

File::ContentStore is a small utility for deduplicating files by content using hard links, storing one copy of each unique file under a name derived from its content digest and hard-linking duplicates to that copy. It can link individual files or recursively process directories, lets you pick the digest algorithm and verify for hash collisions, and can make stored files read-only so accidental edits do not alter all aliases. The module provides maintenance helpers such as fsck to find orphaned or corrupted entries and now includes stats() and stats_summary() to quantify how many files are linked and how much space the store saves. It will skip files on a different filesystem rather than failing, and you should be aware that hard-linked files share the same inode so changes or permission updates affect all linked copies.

Mojolicious::Plugin::BarefootJS makes it easy to use the BarefootJS server runtime inside a Mojolicious app by registering a "bf" helper that lazily creates a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo. It lets you render BarefootJS-compiled templates as native Mojolicious templates so controllers and views can use BarefootJS features with minimal setup. If you need the same runtime outside Mojolicious, BarefootJS::Backend::Xslate provides a Text::Xslate-driven option. Install the plugin to add the helper and supporting hooks and streamline using BarefootJS templates in your Mojolicious application.

BarefootJS::Backend::Xslate is a small adapter that lets the BarefootJS runtime render Kolon-style Text::Xslate templates, so you can use BarefootJS templates in any PSGI/Plack app or even a standalone script without tying into a web framework. You give it template directories or a ready-made Text::Xslate instance and it provides the runtime-facing operations the engine expects, such as render_named, encode_json, mark_raw and materialize, while building Xslate with HTML auto-escaping and support for helpers that emit raw markup. It is designed to work with the @barefootjs/xslate compile-time adapter which emits ".tx" templates that call the runtime as a bf object, and it lets you override Xslate options or the JSON encoder if you need custom behavior. The module is actively maintained and available under the MIT License.

BarefootJS is a lightweight server-side runtime for marked templates generated from JSX/TSX that lets compiled templates call back into Perl at render time. It is framework- and template-engine-agnostic, delegating tasks that depend on the rendering environment such as JSON marshalling, raw-string marking, JSX children materialization, and named-template invocation to a pluggable backend so the same runtime can drive different hosts. Shipable backends connect it to common Perl stacks like Text::Xslate for PSGI/Plack or Mojolicious via a plugin, and the core itself only depends on Perl core modules so no template engine or web framework is loaded unless a backend requires one. If you compile your front-end templates to marked templates plus client JS and need a consistent, minimal Perl runtime to render them server-side, BarefootJS provides the bridge you need and is released under the MIT License.