CPANscan

"Future::IO::Impl::Ppoll" is a Perl module that implements the "Future::IO" interface using the ppoll(2) system call, facilitated by IO::Ppoll. This module does not introduce any additional methods; instead, it enhances the functionality of "Future::IO" by simply being loaded into your program. Users can leverage its capabilities, such as the `->poll` method introduced in version 0.03, which aligns with updates in Future::IO v0.19. Notably, the module also manages the $SIG{CHLD} signal for the "waitpid" method, issuing a warning if another handler is already set, ensuring that future operations remain intact. With recent improvements in debugging and cross-platform compatibility, "Future::IO::Impl::Ppoll" is a robust choice for asynchronous I/O operations in Perl.

The "Future::IO" Perl module provides asynchronous input/output (IO) methods that return Future instances, allowing for non-blocking operations similar to core Perl functions. It enables developers to perform IO tasks such as reading from and writing to filehandles, sleeping, and managing socket connections in an asynchronous manner, which is particularly useful for applications that require efficient handling of multiple IO operations without blocking the main execution flow. The module includes a default implementation for simple cases but can be extended with more robust event loop integrations. Additionally, it supports cancellation of futures and is designed to facilitate unit testing by allowing the replacement of its internal implementation with mock objects. Overall, "Future::IO" is a versatile tool for building responsive Perl applications that handle IO operations efficiently.

The Time::Piece module in Perl provides an object-oriented interface for handling date and time, replacing the traditional localtime and gmtime functions with object instances that maintain backward compatibility. By using Time::Piece, developers can easily create time objects that allow for intuitive access to various time components, formatted output, and date calculations. The module supports a wide range of methods for retrieving time and date information, performing arithmetic operations, and parsing date strings with customizable formats. Additionally, it includes features for timezone handling, daylight saving time adjustments, and locale-aware parsing, making it a versatile tool for any Perl application that requires robust date and time manipulation.

Getopt::Guided is a Perl module that provides a POSIX-compliant implementation of the `getopts` utility for parsing command-line arguments. Unlike the core `Getopt::Std` module, which processes options in a single call, Getopt::Guided offers an iterator-based approach, allowing for more flexible and robust handling of command-line options, including support for common and list options, flags, and error handling. The module features a `processopts` function that enhances the parsing results by allowing developers to specify callback functions for options, thereby facilitating best practices in command-line interface design. Recent updates include improved documentation and enhancements to the Makefile setup, as well as a new `print_version_info` function that provides standardized version output, making it easier for developers to implement version reporting in their utilities.

Devel::Size is a Perl module designed to accurately determine the memory usage of Perl variables, providing developers with insights into how much memory their data structures consume. By using the functions `size` and `total_size`, users can measure the memory footprint of scalars, arrays, and hashes, with `total_size` offering a comprehensive view that includes the sizes of nested elements within complex data structures. This module is particularly useful for optimizing memory usage in Perl applications, as it helps identify potential inefficiencies in data handling. With its efficient pointer tracking mechanism, Devel::Size not only minimizes memory overhead but also enhances performance, making it an essential tool for Perl developers concerned with memory management.

The CmdLine module, now renamed to Term::CmdLine, provides a robust library for implementing a generic command line interface in Perl, leveraging the Term::ReadLine and Term::ReadLine::Gnu modules for enhanced functionality. It allows developers to define valid commands along with their help and description strings using a hash, enabling features like command name completion and built-in help. The module facilitates command execution, history management, and output handling, making it suitable for interactive command line applications. Recent updates in version 2.00 have modernized the module to require Perl 5.20 or higher, introduced implicit commands for exit and quit, and expanded the test suite, ensuring improved reliability and functionality.

IPCamera::Reolink is a Perl module designed to facilitate interaction with Reolink IP cameras and NVRs through their HTTP(S)/REST API. This module allows users to perform a variety of functions, including accessing system information, controlling pan-tilt-zoom (PTZ) operations, managing camera presets, capturing snapshots, and configuring audio alarms and lighting settings. With version 1.10, recent enhancements include the addition of methods for controlling infrared (IR) LEDs, expanding the module's capabilities for comprehensive camera management. The module is particularly useful for developers and system integrators looking to automate or customize their surveillance solutions using Reolink devices.

The Image::APNG Perl module is designed for generating Animated PNG (APNG) files from a series of individual PNG images, allowing users to specify frame delays and various options for customization. With a straightforward interface, users can define their frames along with parameters such as loop count, background color, and resolution adjustments. The module provides functionality to optimize the palette and manage frame disposal and blending methods, ensuring flexibility in creating high-quality animations. Upon execution, it returns a status indicating success or failure, along with any error messages and the resulting binary APNG data, making it an essential tool for developers looking to incorporate animated graphics into their applications.

The `App::Test::Generator` Perl module is designed to automate the generation 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 creates comprehensive black-box tests that include random fuzzing, deterministic edge cases, and static corpus tests, thereby enhancing the robustness of test suites. It supports various input types and configurations, allowing for detailed testing of edge cases and ensuring that functions handle both expected and unexpected inputs effectively. Notably, version 0.28 introduced improvements in getter/setter routines and added an 'isa' test to validate object types, further refining the module's testing capabilities.

Net::SAML2 is a Perl module that provides bindings and protocol implementation for SAML2 (Security Assertion Markup Language), specifically supporting the Web Browser Single Sign-On (SSO) profile. This module facilitates the integration of SAML2 authentication in web applications by enabling service providers (SPs) to communicate with various identity providers (IdPs) through SAML assertions. With features such as generating authentication requests, handling responses, and supporting encrypted assertions, Net::SAML2 is designed to work seamlessly with multiple IdPs, including popular services like Auth0, Azure, and Google. The latest version, 0.85, includes minor version adjustments and maintains compatibility with previous releases, ensuring stability for existing applications. Notably, it has been tested against a wide range of IdPs, making it a versatile choice for developers looking to implement SAML2 authentication in their applications.

The `Test::Mojo::Role::OpenAPI::Modern` Perl module is designed to enhance the testing capabilities of applications that utilize OpenAPI specifications by providing a role for `Test::Mojo` objects. It allows developers to validate API requests and responses against an OpenAPI document, ensuring compliance with defined schemas. With methods for checking the validity of requests and responses, as well as detailed error reporting, this module streamlines the testing process for APIs. Notably, the recent version 0.011 includes updates to tests for new `$ref` validation and parameter deserialization changes introduced in `OpenAPI::Modern`, reflecting ongoing improvements to maintain compatibility with evolving standards.

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.