CPANscan

Couch::DB is a Perl module designed as a high-level client for interacting with CouchDB databases, providing a simplified and abstracted interface compared to other existing implementations. It allows developers to easily create and manage connections to CouchDB clusters, databases, and clients, while handling various API calls through a more intuitive object-oriented approach. The module supports multiple authentication methods, version management, and includes features for generating unique identifiers and managing pagination of results. Recent updates in version 0.201 include changes to the `searchAnalyze()` method parameters and a split of the `compact()` method into `compactViews()` and `Design::compactViews()`, alongside improvements in documentation organization and code styling. This makes Couch::DB a robust choice for developers looking to integrate CouchDB functionality into their Perl applications.

Number::ZipCode::JP is a Perl module designed for validating Japanese zip codes according to the regulations set by Japan Post Holdings Co., Ltd. It allows users to create instances of zip codes, set their values, and check their validity against specified categories, such as area-specific or company-specific zip codes. The module provides methods for constructing zip code objects, importing validation categories, setting zip code values, and verifying their correctness. With its straightforward interface, Number::ZipCode::JP is an essential tool for developers needing to ensure the accuracy of Japanese postal codes in their applications.

MooX::Role::HasLogger is a Moo role that adds a read-only "logger" attribute to any consuming class, enabling easy logging capabilities. The logger is lazily instantiated and is based on the Log::Any logger object, with the consuming class's name as its category. This module also provides type definitions through MooX::Role::HasLogger::Types, allowing for flexible customization of the logger's interface. Notably, version 0.002 introduced the LoggerAny type, which requires logger objects to implement a "category()" method, enhancing the module's extensibility. This role is particularly useful for developers looking to integrate logging functionality seamlessly into their Moo-based classes.

Meow is an experimental Perl module that offers a fast and minimalist object-oriented system, designed to streamline the creation and management of objects with read-write and read-only attributes. It allows developers to define attributes with various specifications, including types, default values, coercion, triggers, and builders, while supporting multiple inheritance through the "extends" feature. Meow provides a Perl-style constructor for object instantiation and includes an innovative mechanism for importing accessor functions that optimize performance by enabling inline operations, significantly speeding up attribute access. With its focus on efficiency and simplicity, Meow is ideal for developers looking to implement a lightweight object system in their Perl applications.

The Acme::Selection::RarestFirst Perl module implements a "rarest-first" selection algorithm designed for distributed systems, enhancing data availability by prioritizing items with the lowest occurrence in a global dataset. Users can create a selector instance, update item availability based on peer participation, and efficiently select the next item to request that is not already owned. The module provides methods to update availability counts, pick the rarest item while optionally considering priority weights, and retrieve the current availability of specific items, making it a valuable tool for managing resource requests in peer-to-peer networks.

MetaCPAN::Client is a robust and feature-rich Perl module designed to interact seamlessly with the MetaCPAN API, providing a user-friendly interface for accessing various resources such as authors, distributions, modules, and more. With its DWIM (Do What I Mean) capabilities, it simplifies complex queries and enhances usability by allowing users to perform searches using both simple identifiers and detailed search specifications. The module supports advanced features like caching with CHI, making it suitable for applications that require efficient data retrieval. Recent updates include the addition of support for the CVE index, enhancing its functionality for security-related queries. Overall, MetaCPAN::Client is an essential tool for Perl developers looking to leverage the extensive MetaCPAN ecosystem effectively.

The SIRTX::Datecode module is designed for efficient interaction with SIRTX datecodes, which encode dates from 1582 to 2440 into a compact 16-bit format while allowing for variable precision and numeric ordering. With this module, users can easily create datecode objects from various input formats, including ISO-8601 strings, epoch values, and existing datecode objects. It provides methods to convert datecodes to and from different formats, compare them, and check their properties, such as precision and whether they are in UTC or floating. Additionally, it supports creating null datecodes and retrieving individual date components like year, month, and day. This module is particularly useful for applications that require compact date representation and manipulation within the specified range.

The "Device::Serial::SLuRM" Perl module facilitates communication using the SLµRM protocol over a serial port, enabling reliable bidirectional messaging between devices. It provides a Future::IO-based interface for sending and receiving NOTIFY and REQUEST packets, while also allowing for the handling of retransmissions and timeouts to ensure message integrity. Users can easily configure the module with the appropriate device path and baud rate, and it supports metrics tracking for monitoring communication performance. This module is particularly useful for applications that require robust communication over potentially unreliable serial links, making it an essential tool for developers working with serial devices and microcontrollers.

"IPC::MicroSocket" is a Perl module designed to facilitate minimalistic communication between clients and servers over local UNIX sockets, supporting both request/response and publish/subscribe messaging patterns. With this module, clients can send requests to a server, which processes them and returns responses, potentially in an asynchronous manner. Additionally, clients can subscribe to specific topics, allowing them to receive messages broadcasted by the server. The module operates with raw byte strings, requiring users to handle any necessary encoding or serialization for more complex data types. It serves as a lightweight alternative to more complex messaging systems, making it ideal for simple use cases where minimal overhead is desired.

The "noop" Perl module offers a highly optimized no-operation function that performs no actions and returns no values, making it extremely fast and efficient. Designed for use as a default callback or placeholder, it allows developers to specify a function that effectively does nothing, which can be particularly useful in scenarios where a callback is required but no operation is desired. The module is implemented at compile time as a single custom operation, ensuring minimal overhead. With its straightforward purpose and lightweight nature, "noop" is an ideal choice for developers looking to streamline their code without unnecessary complexity.

Tie::Hash::KeysMask is a Perl module that allows developers to create tied hashes with customizable key aliasing through a mask function. This functionality is particularly useful for scenarios where key case sensitivity needs to be controlled, enabling access to hash elements without regard to the case of the keys. By defining a mask function, such as converting keys to lowercase or uppercase, users can ensure that different representations of the same key map to the same value in the hash. The module inherits from Tie::Hash::Create, providing additional flexibility in managing tied hashes. With Tie::Hash::KeysMask, developers can easily implement case-insensitive hash access or other custom key transformations, enhancing the usability of their data structures.

Algorithm::TimelinePacking is a Perl module designed to efficiently arrange overlapping time intervals into non-overlapping lines, making it ideal for Gantt-style visualizations such as conference schedules, project timelines, and resource allocation. Utilizing a greedy first-fit approach, the module takes a set of time intervals and organizes them into the minimum number of lines while ensuring that no two intervals on the same line overlap. Users can specify a minimum gap between intervals and an optional width for scaling the output, allowing for flexible visualization options. The module is particularly useful for applications like visualizing Hadoop MapReduce job execution timelines, making it a versatile tool for managing and displaying time-based data.

Sub::StrictDecl is a Perl module designed to enhance code reliability by enabling compile-time checks for undeclared subroutines. By using this module, developers can catch errors related to mistyped subroutine names or forgotten imports before the code is executed, which is particularly useful for identifying issues in rarely tested code paths. The module employs a lexically-scoped pragma that allows developers to enable or disable checking as needed, ensuring flexibility in various coding scenarios. Recent updates in version 0.005 have improved the test suite's compatibility with newer Perl versions and refined the internal API for operation checking, enhancing the module's overall robustness and usability.

Acme::MCP is a Perl module that provides a simple server implementation for the Model Context Protocol (MCP), enabling the exposure of Perl modules, local data, or internal tools to AI agents via a standardized JSON-RPC 2.0 interface. With Acme::MCP, developers can easily register tools that AI agents can invoke, specifying unique identifiers, descriptions, and required argument schemas, along with the corresponding code to execute. The server operates by listening for JSON-RPC requests on standard input and sending responses to standard output, making it compatible with typical MCP hosts. Notably, the initial release (v1.0.0) marks the module's debut, confirming its existence and functionality as a basic MCP server.

Acme::Bitfield is a Perl module designed for efficiently tracking large sets of boolean flags using a compact bitmask representation, adhering to the BitTorrent (BEP 03) bit-ordering convention. This module allows users to easily set, clear, and check the status of individual bits, making it ideal for applications that require managing large collections of boolean values, such as peer-to-peer file sharing. With methods for counting set bits, retrieving the size of the bitfield, and exporting raw binary data for network transfer, Acme::Bitfield simplifies the manipulation of boolean sets while handling the necessary bit-ordering adjustments transparently. Notably, the module reached its initial release in January 2026, marking its official availability for use.

StreamFinder is a Perl module designed to extract raw streamable URLs from a variety of media sources, including radio stations, video platforms, and podcasts. By providing a webpage URL from supported sites, users can retrieve actual stream URLs, titles, descriptions, and cover art icons, enabling playback in preferred media players without the clutter of ads and trackers typically associated with web browsers. The module supports numerous platforms through specific submodules, such as StreamFinder::Youtube and StreamFinder::Apple, and offers various options for customization, including secure stream retrieval and logging capabilities. Notably, recent updates have improved handling for sites like Rumble and Bitchute, ensuring better metadata extraction and stream quality management. StreamFinder is intended for integration into other Perl applications rather than as a standalone tool, making it a versatile choice for developers looking to enhance media streaming functionalities.

The `App::Test::Generator` Perl module is designed to automate the creation of fuzz and corpus-driven test harnesses based on formal input/output specifications for routines or methods. By utilizing configuration files in YAML format, this module generates comprehensive test cases that include random fuzzing, edge cases, and static corpus tests, thereby enhancing the robustness of your test suite. It supports both command-line and programmatic usage, allowing developers to easily integrate automated testing into their workflows. With features like deterministic edge case generation and property-based testing capabilities, `App::Test::Generator` helps identify boundary errors and invalid data handling, making it an invaluable tool for ensuring the reliability of Perl applications.

The SIRTX::VM module is designed for interacting with SIRTX VM code, providing a robust interface for developers working with this virtual machine environment. Inheriting from Data::Identifier::Interface::Userdata, it offers a variety of methods to facilitate the manipulation and execution of VM code. The latest version, v0.12, introduces experimental support for open with ports, enhances the logicals list by adding the ac/accumulator, and introduces synthetic directives for reading and writing character data in various byte sizes. This module is particularly useful for developers looking to work with SIRTX VM code efficiently, leveraging its growing set of features and improvements.

Sub::HandlesVia is a versatile Perl module designed to provide an alternative implementation of the `handles_via` feature found in object-oriented frameworks like Moo, Moose, and Mouse. It allows developers to delegate method calls to underlying data structures, such as arrays or hashes, enhancing the encapsulation and usability of object attributes. By using Sub::HandlesVia, you can easily define methods that manipulate these data structures without exposing their internal details. This module is particularly useful for those who want a consistent approach across different object-oriented toolkits. Recent updates include the addition of new methods like `Array:peek` and `Array:peekend`, as well as improved performance through the use of Sub::HandlesVia::XS when available, making it a robust choice for modern Perl applications.

Test::RedisServer is a Perl module designed to facilitate the testing of applications that rely on Redis by providing a simple way to run a Redis server instance during tests. It allows developers to create and manage a Redis server instance programmatically, with options to configure server settings, control automatic startup, and specify a temporary directory for configuration files. The module integrates seamlessly with testing frameworks like Test::More, enabling users to verify Redis interactions, such as executing commands and checking responses, while ensuring that the server is properly started and stopped as part of the test lifecycle. This makes it an invaluable tool for developers looking to ensure the reliability of their Redis-dependent applications in a controlled testing environment.

The "IO::Async" Perl module provides a robust framework for asynchronous event-driven programming, enabling developers to handle filehandle I/O operations, timers, signals, and child processes in a non-blocking manner. It allows for the creation of complex applications that can manage multiple I/O tasks concurrently without the need for threads, making it ideal for network servers and other I/O-intensive applications. The module includes various classes such as IO::Async::Stream for managing bidirectional data streams, IO::Async::Timer for scheduling events, and IO::Async::Process for handling child processes. Recent updates have improved the handling of separate I/O readiness notifications and introduced a more comprehensive Future API for managing asynchronous operations, enhancing the module's capabilities for modern Perl applications.

Dist::Zilla is a powerful Perl module designed for building and managing distributions of Perl code intended for upload to CPAN (Comprehensive Perl Archive Network). Unlike other tools such as ExtUtils::MakeMaker or Module::Build, Dist::Zilla focuses solely on the distribution process rather than installation, allowing developers to impose stricter requirements and utilize advanced features tailored for authors. It provides a flexible framework for configuring various aspects of a distribution, including metadata, dependencies, and file management, through a plugin architecture. Recent updates, such as version 6.037, have improved user experience by addressing warnings related to undefined inputs during prompts and enhancing the handling of dependency listings, ensuring a smoother workflow for developers. For more information and tutorials, users can visit the official website at dzil.org.

Net::Server is a versatile and extensible Perl server engine designed to facilitate the creation of various types of servers, including single connection, forking, and preforking servers, as well as support for multiplexing and inetd modes. It provides full IPv6 support, SSL socket capabilities, and a range of customizable hooks for user-defined behavior. The module allows for easy configuration through command-line arguments, configuration files, or method calls, and includes built-in logging options. Recent updates in version 2.016 enhance compatibility with platform-specific IPV6 settings and improve error handling, making it a robust choice for developers looking to implement server functionality in Perl applications.

MooX::XSConstructor is a Perl module that acts as a bridge between Moo and Class::XSConstructor, enabling the creation of faster object constructors for Moo classes when possible. By analyzing class attributes, it determines if a class can benefit from an XS-based constructor, which can significantly enhance performance for simpler classes. While it supports common Moo attributes and extensions, it gracefully avoids complications arising from more complex configurations. Recent updates have improved the module's functionality, including better detection of foreign classes and the addition of an XS DESTROY method, ensuring broader compatibility and efficiency. This makes MooX::XSConstructor an essential tool for developers looking to optimize their Moo-based applications.

XML::Sig::OO is a Perl module designed for creating and validating XML signatures, leveraging the capabilities of libxml2 (XML::LibXML). It allows users to sign XML documents with various key types, including RSA and DSA, and supports multiple signatures within a single XML structure. The module provides a straightforward interface for signing XML data, validating signatures, and handling certificate management, making it particularly useful for applications that require secure XML communications, such as SAML assertions. Recent updates have improved functionality, including the addition of support for EC14N transforms and enhancements to error handling, ensuring robust performance in diverse scenarios.

XS::JIT is a lightweight Just-In-Time (JIT) compiler for XS code in Perl, designed for scenarios where dynamic C code generation and runtime compilation are required. Unlike Inline::C, XS::JIT bypasses C code parsing and directly invokes the compiler, resulting in faster compilation and execution times. It allows users to compile C code, install functions into Perl namespaces, and offers a C API for integration with other XS modules. Recent updates have improved compatibility with C89 standards and added support for linking against external libraries, enhancing its utility for developers needing efficient and flexible XS code execution.

The `Net::Multicast::PeerDiscovery` Perl module provides a robust mechanism for local peer discovery using UDP multicast, originally designed for BitTorrent applications but applicable to any peer-to-peer or local-first software. It enables applications to find neighboring peers on the same local area network (LAN) without relying on a central registry or internet access. The module supports both IPv4 and IPv6 multicast, ensuring compliance with RFC 6724 and handling link-local addresses appropriately. Key functionalities include broadcasting discovery messages, listening for incoming multicast packets, and registering callbacks for discovered peers. The module is designed to be user-friendly, allowing developers to easily integrate peer discovery into their applications. Notably, the initial release of version 1.0.0 in January 2026 marked the module's official availability.

Net::uTP is a Perl module that implements the Micro Transport Protocol (μTP), designed for efficient, congestion-controlled data transfer over UDP. Originally developed for BitTorrent, this general-purpose module is ideal for applications requiring high-throughput and minimal impact on other network activities, such as VoIP or gaming. Key features include LEDBAT congestion control to manage network traffic, selective acknowledgments for efficient packet loss recovery, and automatic out-of-order packet reassembly. With methods for initiating connections, sending and receiving data, and handling retransmissions, Net::uTP provides a robust framework for developers looking to leverage μTP's capabilities. The module recently reached its initial release version 1.0.0, marking its official availability for use.

The SPVM::Resource::Zlib module provides a resource interface for integrating the zlib compression library within the SPVM (Simple Perl Virtual Machine) environment. This module allows developers to easily utilize zlib's functionality for data compression and decompression in their SPVM applications by configuring it in their project setup. By including the necessary zlib headers and source files, users can leverage zlib's capabilities directly in their SPVM code, facilitating efficient handling of compressed data formats. The module is designed for use with the GNU C99 language specification and is compatible with zlib version 1.3.1, ensuring robust performance and reliability.