CPANscan

Tree::STR is a Perl module designed for creating a Sort-Tile-Recursive (STR) tree, which serves as a read-only R-Tree optimized for efficient construction. It allows users to index spatial data by providing bounding box coordinates in an array format, making it suitable for applications that require spatial queries. With methods like `query_point` and `query_partly_within_rect`, users can easily retrieve items based on spatial intersections. Notably, in version 0.06, the module's query methods were enhanced for compatibility with Tree::R, allowing for more flexible data handling by accepting an array reference for results. This makes Tree::STR a powerful tool for developers working with spatial data in Perl.

Mail::DMARC is a comprehensive Perl module designed to implement Domain-based Message Authentication, Reporting, and Conformance (DMARC) protocols, adhering to the latest specifications. It provides tools for validating incoming email messages against DMARC policies, allowing mail transfer agents (MTAs) and filtering applications to ensure that messages align with the sender's authentication policies. The module facilitates the generation and reception of DMARC reports, enabling email senders and MTA operators to manage and analyze email authentication results effectively. With features for storing reports in various SQL databases and methods for viewing and sending reports, Mail::DMARC is an essential tool for enhancing email security and compliance with DMARC standards.

Getopt::EX::Hashed is a Perl module designed to streamline the management of command line options using Getopt::Long by automating the creation of a hash object that stores option values. It allows developers to define command line parameters in a concise manner, integrating both initialization and specification into a single declaration. The module automatically generates accessor methods for these parameters, supports validation through various built-in checks, and offers configuration options to customize behavior, such as locking hash keys and managing accessors. This makes it an efficient tool for building command line applications in Perl, simplifying the process of handling user input and ensuring data integrity.

Dist::Zilla::Plugin::Git::Contributors is a Perl module designed to enhance your distribution's metadata by automatically extracting contributor names and email addresses from git commits in your repository. By adding the plugin to your dist.ini file, it populates the "x_contributors" key with this information, allowing for a streamlined and minimalist approach to contributor management without cluttering other data locations. The module offers configuration options to include authors, control the inclusion of the current user, sort contributors by name or commit count, and filter out specific contributors. It also supports unicode characters and can integrate with Pod::Weaver to include contributor details in your module documentation, making it an essential tool for maintaining accurate credit for contributions in Perl projects.

PDL::Fit::Levmar is a Perl module that provides an interface to the Levenberg-Marquardt optimization routines for performing non-linear least-squares fitting of data to model functions. It leverages the levmar library, allowing users to fit complex models with support for both analytic and finite difference derivatives, as well as various constraints on parameters. The module is designed for efficiency, enabling users to define fit functions in Perl, C, or a specialized function description language (lpp) that is compiled into C for optimal performance. With features such as multi-threading support and customizable output, PDL::Fit::Levmar is suitable for a wide range of data fitting and optimization tasks, making it a powerful tool for researchers and developers working with numerical data in Perl.

Amon2 is a lightweight and extensible web application framework for Perl, designed to be simple, readable, and fast, built on top of Plack. It provides a structured way to create web applications by allowing developers to define their application context, load configurations, and manage plugins easily. Amon2 supports various features such as project-local context management, plugin loading, and configuration handling, making it suitable for both small and large applications. Recent updates in version 6.17 include the removal of unused dependencies, the introduction of Crypt::SysRandom for secure random string generation, and enhancements to the framework's overall stability and performance, reflecting its commitment to maintaining a modern and efficient development environment.

Pod::Weaver::Section::SourceGitHub is a Perl module designed to enhance your Pod documentation by automatically adding a "SOURCE" section that includes the GitHub URL for your module and instructions for cloning the repository. By configuring this module in your "weaver.ini" file, you can streamline the process of providing essential source information to users and contributors, making it easier for them to access and collaborate on your project. This module is particularly useful for developers looking to maintain clear and accessible documentation for their GitHub-hosted Perl modules.

The "Future::IO" Perl module provides asynchronous input/output methods that return results as Future instances, allowing for non-blocking IO operations. It serves as a decoupling mechanism for modules that require asynchronous IO, enabling them to function independently of the underlying event system. The module includes methods for common IO tasks such as reading, writing, sleeping, and handling socket connections, all of which yield Futures that can be awaited. By default, it offers a minimal implementation suitable for simple cases, but it can be extended or replaced with more robust event loop implementations as needed. This flexibility makes "Future::IO" particularly useful for writing unit tests and integrating with various event systems, while also supporting cancellation of operations without disrupting the overall program flow.

The RRD::Fetch Perl module is designed to facilitate the retrieval of information from Round Robin Database (RRD) files, allowing users to easily access and manipulate time-series data. With a straightforward interface, users can create an instance of the module by specifying the RRD file and optional parameters such as consolidation function (CF), resolution, and retry settings. The module provides methods for fetching raw data, joined data by time or column, and daily maximum statistics, all while handling retries in case of transient errors. A notable recent addition in version 0.1.0 is the inclusion of RRD::Fetch::Helper, which enhances the module's functionality and provides an example for users. This makes RRD::Fetch a valuable tool for developers working with time-series data in Perl.

The `Storage::Abstract` Perl module provides a unified interface for storing and retrieving files across various storage backends, allowing developers to focus on high-level operations without delving into implementation specifics. By utilizing different drivers, such as in-memory storage, local directories, or composite storage solutions, users can easily manage files with methods for storing, retrieving, listing, and disposing of files, while also handling exceptions for errors like missing files or invalid paths. This abstraction simplifies file management tasks and supports Unix-like file path conventions, making it a versatile choice for applications requiring flexible file storage solutions.

The `IO::Uring` Perl module provides a low-level interface to Linux's `io_uring`, an advanced asynchronous I/O framework designed to minimize system calls and enhance performance. By utilizing a proactor model, this module allows developers to schedule asynchronous operations and receive notifications via callbacks upon their completion. With methods that closely mirror system calls, such as `recv` and `send`, `IO::Uring` supports features like submission flags for chaining actions and the ability to handle multiple events simultaneously through multishot operations. Recent updates include the addition of `statx` and `fstatx` functions in version 0.012, further expanding its capabilities for file handling. As an experimental module, it is still evolving, with ongoing improvements to ensure robustness and functionality.

Future::Uring is an experimental Perl module that provides a user-friendly interface for utilizing Linux's io_uring mechanism, which facilitates efficient asynchronous I/O operations through submission and completion queues. This module allows developers to perform various I/O tasks, such as reading and writing files, creating directories, and managing sockets, using familiar function names that mirror their synchronous counterparts. Notably, version 0.003 introduces the `statx` function for enhanced file status retrieval and removes the *at functions, reflecting ongoing improvements in the module's API and functionality. With options for asynchronous execution, linking submissions, and timeout management, Future::Uring aims to streamline I/O operations while offering flexibility for performance optimization.

File::StatX is a Perl module that provides an interface to the Linux `statx` system call, allowing users to retrieve detailed file status information with enhanced capabilities compared to the traditional `stat` function. With functions like `statx`, `statxat`, and `fstatx`, users can obtain various attributes of files, including size, timestamps, and device information, while also utilizing bitmask flags and masks to specify the desired data. This module is particularly useful for applications that require precise file metadata, especially in environments with advanced filesystem features. The latest version, 0.003, includes various documentation fixes, enhancing the clarity and usability of the module for developers.

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 applications. It allows developers to leverage the capabilities of Future::IO while working within the IO::Async framework. However, it currently lacks support for certain features such as signal handling, monitoring of PID 0, reliable status checks with "is_running", and operational metrics, due to limitations in Future::IO itself. A recent update (version 0.02) has improved the module by adding a working Future::IO implementation to the test requirements, ensuring that tests can be executed effectively. This module aims to enhance the asynchronous programming experience in Perl, with the potential for future enhancements as Future::IO evolves.

The Google::GeoCoder::Smart module is a straightforward Perl client for the Google Geocoding API, designed to facilitate the conversion of addresses into geographic coordinates. By utilizing this module, developers can easily send geocoding requests to the Google API, supporting both structured addresses and place IDs, while also allowing for optional parameters such as language and region. The module returns decoded API responses, including the raw JSON for debugging purposes. Recent updates in version 2.1.0 have improved request handling to align with current API usage, removed deprecated parameters, and enhanced testing capabilities with offline-safe tests, ensuring a more robust and modern implementation.

The CtrlO::PDF module is a high-level PDF creator designed to simplify the process of generating PDF documents in Perl. It provides an intuitive interface for adding various elements such as headings, paragraph text, images, and tables, while managing pagination and layout automatically. Users can customize aspects like page size, orientation, margins, and include optional headers and footers. Built on the PDF::Builder library, CtrlO::PDF allows for direct access to its powerful features, making it versatile for creating complex documents. Notably, version 0.34 introduced support for PDF::Builder 3.028, enhancing formatting capabilities and enabling internal linking within PDFs, which significantly improves document navigation.

The Bored Perl module, currently at version 0.04, provides a whimsical approach to expressing feelings of ennui and discontent through a series of methods such as `pointless`, `waiting`, and `tortured`. Designed for developers looking to inject a bit of humor into their code, Bored allows users to invoke a sense of boredom programmatically. With a simple interface, you can easily utilize its features by importing specific functions or creating an instance of the Bored class. The module is actively maintained, and users are encouraged to report bugs or feature requests via CPAN's request tracker.

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 test cases that include random fuzzing, deterministic edge cases, and static corpus tests, thereby enhancing the robustness of your test suite. It allows developers to easily probe both expected and unexpected inputs, helping to identify boundary errors and invalid data handling without the need for extensive manual test case creation. The module supports various input types and configurations, making it a versatile tool for improving the reliability of Perl applications through automated testing.

PDL::Transform::Proj4 is a Perl module that provides an interface to the Proj4 projection library, enabling users to perform various geographic transformations and projections using the PDL (Perl Data Language) framework. This module allows for the creation of maps and the manipulation of geographic data by utilizing a generalized projection interface, where users can specify projection parameters in a string format similar to command-line usage of the Proj tool. It supports a wide range of projection types, including orthographic, Mercator, and many others, making it a versatile tool for cartography and geospatial analysis. Recent updates include a fix for numerical changes affecting tests with PROJ version 9.8.0, ensuring compatibility and reliability in projections.

Container::Builder is a Perl module designed for creating TAR archives that can be imported into containerization tools like Podman or Docker, specifically tailored for building lightweight containers based on Debian packages. It provides a range of methods that mimic Dockerfile functionalities, allowing users to create directories, add files, and manage users and groups within the container environment. With the ability to specify a Debian mirror, add Debian packages, and set environment variables, Container::Builder streamlines the process of crafting custom container images. Although still in early development stages and not yet production-ready, it offers a flexible framework for developers looking to experiment with containerization using Perl.

The `IBGE::Municipios` Perl module provides a straightforward interface for retrieving the IBGE city codes of Brazilian municipalities, which are essential for generating official consumer invoices and other tax-related documents in Brazil. By using the `codigo` function, developers can easily obtain the IBGE code for a specified city and state, facilitating compliance with Brazilian regulations. The module is particularly aimed at Brazilian developers, and while the documentation is primarily in Portuguese, contributions for translations are welcomed. Data is sourced directly from the official IBGE website, ensuring accuracy and reliability.

MIDI::RtController is a Perl module designed for real-time control of MIDI controllers through customizable plug-in filters. It allows users to create MIDI applications that can respond to various MIDI events, such as note on/off messages, by defining specific filtering functions. The module supports multiple input sources and provides an asynchronous loop for handling MIDI events efficiently. Recent updates, including version 0.0803, have improved compatibility with the RtMidi FFI, enhancing the module's functionality and performance. With its straightforward interface, MIDI::RtController is ideal for musicians and developers looking to manipulate MIDI data dynamically.

Aion::Format is a Perl module designed to provide a variety of utilities for formatting numbers, coloring output, and manipulating text. It includes functions for colorizing text using ANSI escape sequences, formatting numbers with separators, converting between different numeral systems, and generating human-readable representations of time intervals. Additionally, it offers capabilities for logging with color-coded messages and transforming text based on specified rules. Notably, version 0.1.1 introduced a recommendation for the Devel::Size module, enhancing its functionality for users on Perl 3.8. This module is particularly useful for developers looking to improve the readability and presentation of output in terminal applications.

MIDI::RtMidi::FFI is a Perl module that provides bindings to the RtMidi library, enabling real-time MIDI input and output across various platforms such as ALSA, JACK, CoreMIDI, and Windows Multimedia. With version 0.10, the module introduces several significant changes, including a new minimum Perl version requirement of 5.26, the separation of input and output devices into distinct classes, and the removal of support for specifying data in rtmidi callbacks. Additionally, it now features a method for nonblocking IO integration into event loops, enhancing its usability in asynchronous applications. This module is particularly useful for developers looking to implement MIDI functionality in their Perl applications, leveraging the robust capabilities of the underlying RtMidi library.

Apache::Session::Generate::Random is a Perl module designed to enhance session management by generating secure random session IDs using the system's randomness sources. It integrates seamlessly with Apache::Session, allowing developers to tie session data to various storage backends, such as Postgres, while ensuring that session identifiers are both unique and secure. This module is particularly useful for applications requiring robust session handling, as it mitigates risks associated with predictable session IDs. The latest version, 0.002001, includes important bug fixes, such as specifying minimum versions of prerequisites, ensuring better compatibility and stability for users.

Bot::IRC is a versatile Perl module designed to create and manage IRC bots with a focus on simplicity and extensibility. It allows developers to quickly set up a bot that can connect to an IRC server, join channels, and respond to messages using a straightforward configuration. The module supports a pre-forking architecture, enabling it to handle multiple concurrent requests efficiently, and features a robust plugin system that allows for easy customization and enhancement of bot functionality. Recent updates, including version 1.47, have introduced the ability to override database handle attributes and pragmas, further enhancing the module's flexibility. With its minimal core and extensive plugin options, Bot::IRC is an ideal choice for developers looking to implement custom IRC bots with ease.

HTTP::Session2 is a Perl module designed for HTTP session management, providing a lightweight solution for handling session data in web applications. It features automatic generation of XSRF protection tokens, making it suitable for modern web applications that require security against cross-site request forgery. The module supports both server-side and client-side session storage, with the latter being advantageous for reducing server disk usage and simplifying setup. However, it is important to note that HTTP::Session2 is deprecated and no longer maintained, which means it should not be used for new projects. The most recent change in the module was its deprecation, marking a significant shift in its status and advising users to seek alternatives for session management.

Beam::Wire is a lightweight dependency injection container for Perl that simplifies the management of object creation and dependencies within applications. By utilizing a YAML configuration file, developers can define services and their relationships, allowing the container to automatically instantiate and manage these objects as needed. This approach promotes an inversion of control, enhancing flexibility and maintainability in code. Recent updates include the deprecation of the `$path` keyword in favor of standard `$ref` lookups, and the introduction of bare hashrefs as implicit child containers, which streamline the configuration process. With its robust feature set, Beam::Wire is an excellent choice for developers looking to implement dependency injection in their Perl applications.

The Mail::Box::Parser::C module is designed to enhance the Mail::Box framework by providing efficient parsing of email messages using C routines through Perl's XS extension. This optional module automatically integrates with Mail::Box to handle message content when accessed via file handles, falling back to the Perl-based parser in other scenarios. Notably, version 4.01, released on February 25, 2026, addressed critical issues with reading functionality, ensuring improved reliability for users. This module is particularly useful for developers looking to optimize email processing tasks within Perl applications, while also being mindful of compatibility with earlier versions of Mail::Box.

MCP::Run is a Perl module designed to create an MCP server that facilitates command execution through a defined protocol. It serves as a base class for MCP servers, allowing developers to implement specific command execution mechanisms by subclassing it. The module enables the registration of a "run" tool that accepts a command string, an optional working directory, and a timeout, returning the command's exit code, standard output, and standard error. With features like configurable allowed commands and default settings for working directory and timeout, MCP::Run provides a flexible framework for executing commands securely and efficiently. For practical implementation, users can refer to the MCP::Run::Bash subclass, which utilizes the Bash shell for command execution.