CPANscan

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.

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.

UnQLite is a deprecated Perl module that provides bindings for the UnQLite database engine, which is a self-contained, serverless, and zero-configuration NoSQL database. It allows users to perform key/value storage operations, making it suitable for applications that require a lightweight database solution similar to MongoDB or Redis. The module supports various modes for opening databases, including read-only and read-write options, and offers a tie interface for seamless integration with Perl's hash data structure. However, it is important to note that the UnQLite project is no longer maintained, and users are advised against using this module in new code. The most recent change marked its deprecation, signaling that developers should seek alternative solutions for their database needs.

The `Matplotlib::Simple` Perl module is designed to facilitate the creation of visualizations by generating Python scripts that utilize the popular `matplotlib` library. This module allows users to easily create a variety of plots, including bar charts, pie charts, histograms, and scatter plots, by simply providing data in a structured format. The generated Python scripts are saved in a temporary directory for further customization, making it accessible for users who may not be familiar with `matplotlib`'s syntax. With options for single and multiple plots, as well as various customization features like color settings and axis labels, `Matplotlib::Simple` aims to streamline the plotting process, making it significantly easier than directly using `matplotlib` itself.

The `Alien::sqlite_vec` Perl module provides an interface for the sqlite-vec extension, enabling efficient vector search capabilities (KNN) directly within SQLite databases through the use of virtual tables. This module simplifies the process of downloading and compiling the sqlite-vec v0.1.6 amalgamation from source, making it readily available for use in your Perl applications. By utilizing this module, developers can leverage advanced vector search functionalities in their SQLite databases, enhancing data retrieval performance for applications that require such capabilities. The initial release of this module marks a significant step in integrating vector search into the Perl ecosystem.

Perl::Version is a Perl module designed for parsing, manipulating, and formatting Perl version strings with a focus on preserving the original format during modifications. Unlike version.pm, which primarily handles version comparison, Perl::Version allows users to easily increment version components—such as revision, version, and subversion—while maintaining the original string format. This module supports various version formats, including numeric, vstring, and alpha versions, and provides methods for stringification, normalization, and numeric representation. A noteworthy recent change in version 1.019 includes the requirement for IO::File before Perl v5.14, enhancing compatibility and functionality. Overall, Perl::Version is an essential tool for developers needing to manage version strings effectively in their Perl applications.

SQLite::VecDB is a Perl module that transforms SQLite into a vector database by leveraging the sqlite-vec extension, enabling efficient storage and retrieval of high-dimensional vectors. With this module, users can create collections to store vectors alongside metadata and perform k-nearest neighbor (KNN) searches to find similar vectors based on various distance metrics. It also supports automatic embedding generation through integration with the Langertha framework, allowing for seamless conversion of text into vector representations. The module is designed for flexibility, accommodating both in-memory and file-based databases, and is particularly useful for applications in machine learning and natural language processing. The initial release of version 0.001 introduced core functionalities such as adding, searching, and managing collections, along with optional embedding capabilities.

App::Git::Perl is a Perl module designed to enhance your Git experience by introducing a custom command, "git perl," which simplifies the process of monitoring the latest changes in Perl modules. This tool aims to facilitate collaboration among developers by streamlining the workflow associated with tracking updates and modifications in Perl projects. While this module serves as a stub, further details can be found in the associated git-perl application, making it a valuable addition for Perl developers looking to improve their version control practices.

The Math::Vector::Similarity Perl module provides a set of lightweight, pure-Perl functions for comparing numeric vectors, including cosine similarity, cosine distance, and Euclidean distance, making it ideal for analyzing embedding vectors from various sources such as LLM APIs. With zero dependencies, it operates on plain ArrayRefs of any dimensionality, allowing users to easily compute metrics like dot products and normalized vectors. This module is particularly useful for applications in machine learning and data analysis, where understanding the relationships between different vector representations is crucial. Users can import specific functions or all available functions as needed, facilitating flexible integration into their projects.

The Compress::Zstd module offers a Perl interface to the Zstandard (Zstd) compression and decompression library, enabling users to efficiently compress and decompress data within their Perl applications. With functions for both single-threaded and multi-threaded compression, this module allows for flexible handling of data buffers, whether they are provided as scalars or scalar references. Users can easily compress data with adjustable compression levels and decompress it while handling potential errors gracefully. This module is particularly useful for developers looking to integrate high-performance data compression into their Perl projects, leveraging the advanced capabilities of the Zstandard algorithm.