CPANscan

OpenAPI::Modern is a Perl module designed to validate HTTP requests and responses against OpenAPI v3.0, v3.1, or v3.2 specifications. It provides a robust framework for ensuring that API interactions conform to defined schemas, allowing developers to create reliable and compliant web services. By utilizing this module, users can easily instantiate an OpenAPI object with a specified schema and URI, and then validate incoming requests and outgoing responses using methods that return detailed results, including any validation errors. This module is particularly useful for applications that require strict adherence to API specifications, enhancing the reliability and maintainability of web services.

App::LastStats is a Perl module designed to fetch and display Last.fm statistics for a specified user, allowing customization of the time period, output format, and number of artists shown. Users can easily retrieve their music listening data in various formats, including plain text, JSON, and HTML, by providing their Last.fm API key and secret. Recent updates have enhanced the module's functionality, notably adding artist URLs in JSON and HTML outputs, improving validation error messages, and ensuring better command-line option parsing. This makes App::LastStats a versatile tool for Last.fm users looking to analyze their listening habits.

Chess::Plisco is a powerful and efficient chess library for Perl, designed to facilitate chess programming with a focus on performance. It provides a comprehensive set of features including bitboard representation for the chessboard, move generation, legality checks, and support for various notations such as Forsyth-Edwards Notation (FEN) and Standard-Algebraic Notation (SAN). The library also includes a UCI-compatible chess engine, which has demonstrated competitive performance against engines written in more traditional programming languages. With capabilities such as pseudo-legal move generation, static exchange evaluation, and endgame table probing, Chess::Plisco is an excellent choice for developers looking to implement chess functionality in their applications while prioritizing speed and efficiency.

The "Test::Future::IO::Impl" module provides a suite of acceptance tests specifically designed for implementations of the "Future::IO" framework in Perl. By utilizing this module, developers can ensure that their custom implementations adhere to the expected behavior of various I/O operations, such as accept, connect, poll, send, and receive. The primary function, `run_tests`, allows users to execute a series of predefined test suites against their implementation, ensuring comprehensive coverage of the functionality. Recent updates in version 0.18 include enhancements to the polling tests to prevent false positives on certain handle types and improvements to the connect tests, particularly for Windows users, making it a valuable tool for maintaining robust I/O implementations.

Plack::Auth::SSO::OIDC is a Perl module designed to facilitate authentication against an OpenID Connect (OIDC) server within a Plack application. By extending the Plack::Auth::SSO framework, it allows developers to easily integrate OIDC-based single sign-on (SSO) capabilities into their web applications. The module provides a straightforward configuration interface, enabling users to specify essential parameters such as the OIDC discovery URL, client ID, and client secret, as well as handling session management for successful and failed authentication attempts. Notably, in the recent update (version 0.015), a new constructor argument, `store_oidc_response`, was introduced, allowing developers to optionally include long OIDC responses in the session, enhancing flexibility in handling authentication data.

The App::sdif module provides a suite of tools designed for enhanced file comparison, including sdif, cdif, and watchdiff. The sdif command outputs differences between two files in a side-by-side format, while cdif enhances this output with visual effects that highlight changes at the word or character level. Additionally, watchdiff allows users to repeatedly execute a specified command, displaying the output with visual emphasis on modified sections. This module is particularly useful for developers and users who need to analyze changes in files or code efficiently, and it can be easily integrated into a Git environment for streamlined version control.

The IO::Divert Perl module provides a powerful mechanism for temporarily redirecting STDOUT to an internal buffer, allowing developers to capture and process output from code blocks without modifying the original print statements. By utilizing a callback function, users can transform the captured output—such as adding prefixes or formatting—before it is printed back to the original STDOUT. This is particularly beneficial for post-processing output from legacy code or when consistent formatting is required across complex outputs. With options for character encoding and control over automatic printing, IO::Divert offers flexibility for various use cases, making it an essential tool for developers looking to enhance output handling in their Perl applications.

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, making it suitable for applications like HTTP and PSGI daemons. The module allows for easy configuration through command-line arguments, configuration files, or method calls, and it includes built-in logging options. Recent updates in version 2.017 have improved compatibility with various systems, enhanced test suite reliability, and addressed several bugs, ensuring better performance across different environments.

The `Net::HTTP2::nghttp2` module provides Perl XS bindings for the nghttp2 C library, enabling seamless integration of HTTP/2 protocol support into Perl applications. As one of the most robust implementations of HTTP/2, nghttp2 adheres to the relevant RFCs and is widely utilized in major software like curl and Apache. This module allows developers to create both HTTP/2 servers and clients, manage streams, handle frames, and implement features such as server push and WebSocket bootstrapping over HTTP/2. Recent updates have enhanced the module's capabilities, including support for streaming body callbacks in both request and response submissions, which is crucial for bidirectional communication in protocols like WebSocket. With comprehensive testing against the h2spec conformance tool, `Net::HTTP2::nghttp2` stands out as a reliable choice for developers looking to leverage HTTP/2 in their Perl applications.

The Linux::Event::Clock module offers a high-performance solution for managing monotonic time and deadline calculations specifically tailored for Linux event schedulers. By providing a cached clock that can be explicitly refreshed using the "tick" method, it allows for efficient deadline comparisons in scenarios where numerous checks are performed within a single loop iteration. All time calculations are handled in integer nanoseconds, ensuring precision and speed, making it an ideal choice for developers looking to optimize scheduling tasks in their applications.

The `Linux::Event::Timer` module serves as a lightweight wrapper around the `Linux::FD::Timer` (timerfd) functionality, designed for use in event-driven programming on Linux systems. It allows developers to create one-shot or periodic timers that can be easily integrated into an event loop without handling internal waiting or time calculations. With options for non-blocking behavior and clock selection, users can customize timer behavior upon instantiation. Recent updates have improved compatibility with the `Linux::FD::Timer` API, enhancing the `read_ticks` method to utilize the `->receive` function for more efficient timer expiration handling. This module is particularly useful for applications requiring precise timing and event management in a Linux environment.

The `ansicolumn` Perl module is designed to format and display text in a columnar format while being aware of ANSI escape sequences, making it particularly useful for terminal output that includes color and styling. This module allows users to customize the appearance of their output with various options, such as border styles, alignment, and pagination, enhancing the readability of command-line applications. Recent updates include the addition of a new feature in version 1.52 that prevents isolated lines at the bottom of pages, improving the overall layout of the output. With its flexible configuration options, `ansicolumn` is an essential tool for developers looking to present data clearly and attractively in terminal environments.

DPKG::Packages::Parser is a Perl module designed to efficiently parse the Debian 'Packages' file, providing a straightforward interface for extracting package information. Users can create a parser instance by specifying the file to be parsed and can choose to retrieve all fields or a specific subset, which enhances performance and reduces memory usage. The module allows for easy access to package details, such as descriptions, dependencies, and file names, making it a valuable tool for developers working with Debian package management. The initial release of this module was on February 8, 2026, marking its introduction to the Perl ecosystem.

Dist::Zilla::Plugin::Test::MixedScripts is a Perl module designed to enhance the testing capabilities of your distribution by ensuring that there are no mixed Unicode scripts in your code, which could lead to confusion or security vulnerabilities. By adding this plugin to your dist.ini file, it generates an author test that checks for potentially malicious or misleading Unicode characters, such as distinguishing between visually similar domain names that use different scripts. This module extends the functionality of Dist::Zilla::Plugin::InlineFiles, creating a test file (xt/author/mixed-unicode-scripts.t) that can be customized with various configuration options, including specifying which scripts to test and which files to include or exclude. It is particularly useful for developers looking to safeguard their code against deceptive practices that exploit Unicode character similarities.

LWP::UserAgent::Caching is a Perl module that enhances the standard LWP::UserAgent by providing robust, RFC-compliant HTTP caching capabilities. It effectively manages cache using directives from both HTTP/1 and HTTP/1.1, ensuring that responses are cached and invalidated correctly, even after non-safe requests. This module allows developers to create a caching user agent that respects traditional HTTP headers like 'Expires' while also implementing modern 'Cache-Control' directives. Recent updates have included improvements to header management and example usage, making it easier to integrate into applications. Overall, LWP::UserAgent::Caching is an essential tool for developers looking to optimize HTTP requests with effective caching strategies.

App::DataSizeSpeedUtils is a Perl module that provides a set of command-line utilities designed to facilitate the conversion and manipulation of data sizes and speeds using metric units. With commands such as `datasize-from-metric`, `datasize-to-metric`, `dataspeed-from-metric`, and `dataspeed-to-metric`, users can easily convert between different metric representations of data sizes and speeds, making it a valuable tool for developers and system administrators who need to work with data metrics in their applications or scripts. Released in September 2025, this module is open-source and encourages contributions from the community.

Perl::Version::Bumper is a Perl module designed to facilitate the updating of Perl code to declare a more recent version of the Perl language using the "use VERSION" directive. It streamlines the process by removing unnecessary feature and experimental warnings, ensuring that compatibility modules are only included when needed, and managing the safe bumping of code to higher versions. The module provides various methods for bumping Perl versions in PPI documents, strings of code, or files, with options for safe compilation checks to prevent errors. Recent updates include the removal of unfeatures disabled via 'experimental' and enhancements to documentation and test coverage, making it a robust tool for maintaining and upgrading Perl codebases.

Flat::Profile is a Perl module designed for efficient streaming profiling of CSV and TSV flat files, making it ideal for ETL (Extract, Transform, Load) processes and handling legacy data workflows. With a focus on memory efficiency, it allows users to iterate through rows of data with a single pass, providing practical diagnostics such as handling ragged rows and customizable null value policies. The module features methods for creating an iterator to process rows and for generating detailed reports that include metadata and statistics about the data structure, such as width mismatches and null semantics. This makes Flat::Profile a valuable tool for developers looking to analyze and validate flat file data in a streamlined manner.

The Alt::Params::Util::PLICEASE module offers a streamlined and efficient alternative to the Params::Util module, specifically designed for parameter checking in Perl applications. With a focus on simplicity and correctness, this module is intended for users who require a reliable way to validate parameters without the overhead of more complex solutions. Installation is conditional, requiring the user to set the "PERL_ALT_INSTALL" environment variable to "OVERWRITE," ensuring that it is only installed when explicitly desired. For those familiar with Params::SomeUtil, this module provides insights into the differences between the two implementations, making it a valuable tool for developers seeking enhanced parameter validation capabilities.

The `Excel::ValueReader::XLSX` Perl module is designed for efficiently extracting plain values from Excel workbooks in the XLSX format, prioritizing speed over comprehensive support for Excel's internal features like formulas and formatting. It offers a straightforward API that allows users to access worksheet and table data, either by name or numerical index, and includes iterator methods for processing large datasets row by row, which helps conserve memory. Users can choose between two backends for parsing: a fast regex-based approach or a safer, albeit slower, LibXML option. Recent updates have introduced iterator methods for retrieving rows one at a time and improved handling of tables with totals, enhancing the module's functionality for data processing tasks.

The `Image::ExifTool` Perl module is a powerful tool designed for reading and writing metadata from a wide variety of image and multimedia file formats. It supports a comprehensive range of file types, including JPEG, PNG, TIFF, and many others, allowing users to extract, modify, and write metadata such as EXIF, IPTC, and XMP information. The module can be used in both procedural and object-oriented styles, providing flexibility in how it is implemented. Users can easily retrieve specific metadata tags, set new values, and even create new metadata entries, making it an essential utility for photographers, developers, and anyone working with digital media. With extensive support for various manufacturers' maker notes and customizable options for handling character encodings, `Image::ExifTool` stands out as a versatile solution for managing image metadata effectively.

The `Params::SomeUtil` Perl module offers a straightforward and efficient way to validate parameters passed into your code, making it particularly useful for ensuring data integrity at the boundaries of your API. This module provides a collection of importable functions that check various types of parameters, such as scalars, hashes, arrays, and class instances, with a focus on strict correctness and clarity. It is a fork of `Params::Util`, incorporating bug fixes and enhancements while maintaining a commitment to thorough documentation and extensive testing. By allowing developers to explicitly import only the functions they need, or all at once, `Params::SomeUtil` promotes maintainability and reduces the risk of naming conflicts. This module is ideal for scenarios where the quality of incoming data cannot be guaranteed, helping to safeguard your code against unexpected or malformed inputs.

The "IO::Async::Loop::FutureIO" module is a subclass of IO::Async::Loop that integrates with Future::IO to facilitate asynchronous I/O operations in Perl. It allows developers to leverage the capabilities of Future::IO while working within the IO::Async framework, although it currently lacks support for certain features such as signal handling, PID watching, and operational metrics due to limitations in Future::IO itself. As of its initial release on February 7, 2026, this module aims to enhance asynchronous programming in Perl, with the potential for future updates to address its current shortcomings.

The `ccdiff` Perl module is a powerful tool designed for performing character-by-character comparisons between files or directories, providing a visually enhanced diff output that highlights subtle changes, such as character substitutions and whitespace variations. Unlike traditional diff tools, `ccdiff` employs a horizontal diff algorithm for each line, making it particularly effective for identifying hard-to-spot differences. It supports various command-line options for customization, including UTF-8 encoding, unified diff formats, and color-coded output for added and deleted text. Additionally, `ccdiff` can be integrated with Git for streamlined version control comparisons, although it may struggle with very large datasets due to its memory usage. Overall, `ccdiff` is an invaluable tool for developers and anyone needing precise text comparisons.

Dancer::Template::Mason is a Perl module that serves as a bridge between the Dancer web application framework and the HTML::Mason templating system, allowing developers to utilize Mason templates seamlessly within their Dancer applications. By configuring the template engine to 'mason' in the application's configuration file, users can create dynamic web pages using Mason's powerful templating features. The module supports passing parameters to Mason templates and allows for additional configuration of the HTML::Mason::Interp interpreter. The latest version, 0.004002, includes minor refactoring and a shift to using Test2 for testing, enhancing the module's maintainability and performance.

The `Hash::Util::Merge` Perl module provides utility functions for merging hashes with customizable behavior through a user-defined function. With the `mergemap` function, users can easily combine multiple hashes by applying a specified operation to their values for each key, allowing for flexible merging strategies. For instance, it can sum or subtract values from hashes, accommodating cases where keys may not align perfectly. The latest version, v0.3.0, enhances the module by allowing the merging of any number of hashes and ensuring that duplicate keys are not reprocessed, while also improving documentation and cleaning up the namespace. This module is particularly useful for developers needing efficient and customizable hash merging capabilities in their Perl applications.

Net::Proxmox::VE is a Perl module that provides a pure Perl API for interacting with the Proxmox Virtual Environment (PVE) REST API, facilitating both user/password and API token authentication methods. This module allows developers to easily perform various API operations such as logging in, retrieving API versions, and executing CRUD actions (create, read, update, delete) on Proxmox resources. With a focus on simplicity, it abstracts the complexities of the REST interface while offering a framework for future enhancements and additional API functionalities. Recent updates in version 0.44 include fixes to the Storage and Pools modules, as well as improvements to unit tests, reflecting ongoing efforts to enhance the module's reliability and performance.

JQ::Lite is a pure Perl module that serves as a lightweight, jq-compatible JSON query engine, ideal for environments where the jq binary cannot be installed, such as minimal Linux distributions, legacy systems, or air-gapped environments. With a familiar jq-like syntax, it allows users to extract, traverse, and filter JSON data without the need for external binaries or compilation steps. The module can be utilized both as a library and through its command-line interface, "jq-lite," which supports various features including optional key access, boolean filtering, and a wide array of built-in functions for data manipulation. Notably, version 2.32 introduces enhancements to variable handling, ensuring that query-local bindings do not leak across independent queries, thereby improving the reliability of variable usage in complex queries.

The Perl module Business::ISBN::Data serves as a data pack for the **Business::ISBN** module, providing essential data structures related to ISBNs, particularly for managing ISBN-13 prefixes. This module is typically loaded automatically by **Business::ISBN** and requires version 3.005 or later due to structural changes that address previous bugs. The data is sourced from the ISBN Agency's **RangeMessage.xml** file, which is included in the distribution and can be updated by setting the **ISBN_RANGE_MESSAGE** environment variable to point to a different file location. If the specified data file is unavailable, the module defaults to older data included in **Data.pm**. Recent updates include multiple data refreshes throughout early 2026, ensuring that users have access to the latest ISBN information.