CPANscan

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.

MCP::Server::Run is a Perl module designed to create an MCP server that facilitates command execution through a configurable tool. It serves as a base class for MCP servers, allowing developers to implement their own command execution mechanisms by subclassing it. The module supports a whitelist of allowed commands, a customizable working directory, and a timeout for command execution, enhancing security and control over the commands that can be run. The results of the executed commands, including exit codes, standard output, and standard error, are formatted and returned in a structured manner. The initial release of this module introduces these features, along with a concrete implementation using Bash for command execution, making it a versatile tool for developers looking to integrate command execution capabilities into their applications.

MooX::Const is a Perl module that provides syntactic sugar for defining constant and write-once attributes in Moo, enhancing the ease of creating read-only attributes for references. By allowing developers to specify attributes as "const" or "once," it ensures that the underlying data structures are immutable after their initial assignment, thereby promoting safer code practices. This module also integrates seamlessly with Types::Const, enabling type constraints for attributes. Notably, in version 0.7.2, the module's documentation was updated to fix broken links, ensuring users have access to accurate resources. With its focus on immutability and type safety, MooX::Const is an invaluable tool for Perl developers looking to implement robust object-oriented designs.

MIDI::Stream is a Perl module designed for encoding and decoding MIDI bytestreams in real-time. It provides stateful classes that handle a single MIDI port, device, or bytestream, ensuring that multiple streams are not processed simultaneously to avoid issues like message collisions or inaccurate tempo measurements. For converting MIDI bytestreams into usable events, users can utilize MIDI::Stream::Decoder, while MIDI::Stream::Encoder is available for transforming performance and system events into MIDI bytes suitable for hardware and software integration. The latest version, 0.005, introduces a significant change with a new 'concat' option in the encoder, allowing users to concatenate multiple messages or return them as an array, enhancing flexibility in MIDI message handling.

Langertha is a versatile Perl module designed to provide a unified interface for interacting with various Large Language Model (LLM) APIs, including OpenAI, Anthropic, Ollama, and more. By abstracting the differences between these providers, Langertha allows developers to seamlessly integrate AI capabilities into their applications with a consistent API. It supports both synchronous and asynchronous operations, including streaming responses, and offers features such as customizable parameters for temperature and response size. With its role-based architecture, Langertha is easily extensible, making it an ideal choice for developers looking to leverage AI in their projects without getting bogged down by provider-specific intricacies.

Net::IPData is a Perl module that serves as a client for the ipdata.co API, enabling users to access comprehensive IP geolocation and threat intelligence data for both IPv4 and IPv6 addresses. With this module, developers can easily look up specific IP addresses, retrieve information about their own IP, perform bulk lookups, and request specific fields to optimize response sizes. It features convenience methods for common data points such as ASN, threat intelligence, and currency, while ensuring compliance with GDPR through an EU endpoint option. Notably, the module has no non-core dependencies, relying solely on Perl's built-in modules like HTTP::Tiny and JSON::PP, making it lightweight and easy to integrate into existing Perl applications.

DBIx::Class::Async is an experimental Perl module that provides a non-blocking, multi-worker asynchronous wrapper for the popular DBIx::Class ORM, enabling developers to perform database operations without freezing the main application loop. By utilizing a worker-pool architecture, it allows multiple database queries to be executed in parallel, significantly improving responsiveness in applications that require high concurrency. The module integrates seamlessly with various event loops, including IO::Async and Mojolicious, and supports modern asynchronous programming patterns such as Futures and async/await. Notably, version 0.58 introduced a bug fix that ensures scalar-ref values targeting primary key columns are correctly handled, preventing silent errors during IPC serialization. This module is ideal for developers looking to enhance the performance of their database interactions in Perl applications.

The SIRTX::Font module provides a comprehensive interface for working with SIRTX font files, allowing users to read, write, and manipulate font data efficiently. With features such as importing and exporting glyphs, managing code points, and analyzing font attributes, this module is essential for developers dealing with custom font rendering and manipulation. Recent updates in version 0.06 have introduced support for importing PC Screen Font (PSF) files, enhanced HTML rendering capabilities, and experimental features for generating glyphs and analyzing font metadata, making it a powerful tool for font management in Perl applications.

The `Image::Epeg` module is a Perl wrapper for the high-performance JPEG manipulation library, Epeg, designed for quickly creating thumbnail images and modifying JPEG files. It provides methods for resizing images while maintaining aspect ratios, setting image quality, and adding comments. However, it is important to note that this module is deprecated due to known bugs in the upstream Epeg library, which is no longer maintained. Users are advised against using it in new projects. The most recent change in the module was its deprecation, marking a significant shift in its status and usability.

The `SPVM::Sys` module provides a comprehensive interface for system calls related to file I/O, sockets, time management, process control, signals, and user management in Perl. It allows developers to perform operations such as opening files, creating directories, manipulating processes, and handling sockets, all while ensuring compatibility across different operating systems, including automatic handling of UTF-16LE encoding on Windows. Recent updates include the addition of a keep-alive interval parameter for TCP connections, enhancing the module's functionality for network programming. This module is essential for developers looking to leverage low-level system capabilities within the SPVM (Simple Perl Virtual Machine) environment.

The `mdee` module is a terminal-based multi-column Markdown viewer designed to enhance the readability of Markdown documents, particularly those generated by large language models (LLMs). It preserves the original Markdown formatting while providing syntax highlighting, line folding for long list items, and table alignment. Users can customize the output style, color themes, and layout options, allowing for a tailored viewing experience. The module supports various output modes, including paged and filtered views, and integrates with other tools for enhanced functionality. Notably, the recent version 1.00 has integrated the `App::Greple::md` module, streamlining the syntax highlighting and table formatting processes, which enhances the overall performance and usability of the viewer.

Test2::Harness is a robust backend module designed for running and processing tests in Perl, offering enhanced integration with the Test2 framework. While it serves as the core functionality for test execution, users are encouraged to interact with it through the App::Yath interface, which provides a user-friendly UI layer. This module is maintained by Chad Granum and is part of a broader effort to improve testing capabilities in Perl, making it an essential tool for developers looking to streamline their testing processes. For more information, users can refer to the primary documentation available in App::Yath or access the source code repository on GitHub.

IPC::Manager is a versatile Perl module designed for decentralized inter-process communication (IPC) on a single machine, enabling message-based interactions between local processes through various protocols. It allows users to initialize a data store, which can be either temporary or persistent, and facilitates the sending and receiving of messages using a pluggable serialization mechanism. By utilizing the `ipcm_spawn` function, developers can create a new IPC instance, while `ipcm_connect` establishes connections for message exchange. The module supports multiple client protocols, including filesystem-based and database-driven methods, making it adaptable to different environments and requirements. With IPC::Manager, developers can efficiently manage communication between processes, ensuring seamless data transfer and message handling.

MCP::K8s is a Perl module that serves as an MCP (Model Context Protocol) server specifically designed for Kubernetes, enabling AI assistants like Claude to interact with Kubernetes clusters in a secure and RBAC-aware manner. This module dynamically discovers the permissions of the connected service account using Kubernetes' RBAC system, ensuring that only the relevant capabilities are exposed as tools. It supports various authentication methods, including direct token authentication and in-cluster service account detection, and provides a streamlined interface with ten generic tools for managing Kubernetes resources, such as listing, creating, and deleting resources. Notably, the initial release includes features like dynamic tool descriptions based on actual permissions and a robust permission-checking mechanism before executing any tool calls, making it a powerful asset for developers looking to integrate AI capabilities into their Kubernetes operations.