CPANscan

Term::ANSIEncode is a Perl module designed to facilitate the generation of ANSI text with a markup language, enabling users to create colorful and formatted terminal output. It requires a UTF-8 compatible terminal to support special characters and offers a variety of tokens for text manipulation, including color changes, cursor movements, and screen clearing. Users can instantiate the module and utilize methods to define color formats, create frames, and apply various text attributes. Recent updates have significantly improved token handling and expanded the symbol set, enhancing the module's functionality and usability for developers looking to enrich their terminal applications with vibrant text displays.

The "IO::Async" Perl module provides a robust framework for asynchronous event-driven programming, enabling developers to manage non-blocking IO operations efficiently. It allows for the creation of applications that can handle multiple IO tasks simultaneously, such as network connections, file operations, and timers, without the need for multi-threading. The core of the module is the IO::Async::Loop class, which orchestrates various IO::Async::Notifier objects, including streams, timers, and signal handlers, to facilitate complex interactions. With built-in support for child process management and the ability to handle both stream and datagram sockets, "IO::Async" is ideal for building responsive applications that require high concurrency and low latency. Additionally, it offers features like futures for managing asynchronous actions and protocols for handling specific communication patterns, making it a versatile choice for modern Perl development.

RT::Extension::GroupSummary is a Perl module designed for the Request Tracker (RT) system, enabling the display of detailed semantic information about groups through a dedicated Group Summary page. This page showcases essential details such as the group's name, description, and any associated CustomFields, similar to user profiles. Users can access the Group Summary page from the "Admin/Groups" section and utilize a Group Summary Search feature that links directly to relevant summaries. Notably, as of version 0.03, this extension has been integrated into the core of RT 5, rendering it obsolete for versions 5.0.0 and above, while also updating compatibility for newer Perl releases.

"POE::Future" is a Perl module that integrates the capabilities of the Future module with the POE (Perl Object Environment) framework, enabling developers to write asynchronous code that returns Future instances. This allows for the use of the "await" method to block execution until a future is ready, facilitating a more streamlined asynchronous programming model. The module provides constructors for creating new futures, including options for delays and alarms, and supports failure handling through the "then_fail" method. A noteworthy recent change in version 0.06, released on January 19, 2026, is the implementation of most of the `Future::IO->poll` API, enhancing its functionality for I/O operations.

The RT-Extension-InlineAudioVideoAttachments module enhances the Request Tracker (RT) system by enabling the display of audio and video attachments directly within the interface using HTML audio and video players. This functionality allows users to interact with multimedia content seamlessly, improving the overall user experience. The module is compatible with various versions of RT, specifically requiring version v0.07 for RT 4.4, v0.08 for RT 5, and v0.09 or greater for RT 6. Notably, the recent update to version 0.09 includes enhancements for compatibility with newer Perl releases and an upgrade to support RT 6, ensuring that users can leverage the latest features and maintain compatibility with modern environments.

The "Future::IO::Resolver" Perl module provides asynchronous name resolution methods for network operations, enabling developers to convert human-readable hostnames and services into numerical address structures and vice versa. Utilizing the Future::IO framework, it offers methods such as `getaddrinfo` for resolving addresses, `getnameinfo` for retrieving human-readable names from address structures, and DNS query methods like `res_query` and `res_search`. This module relies on the Net::LibAsyncNS library for its asynchronous capabilities and is designed to facilitate network connectivity tasks while maintaining flexibility for future enhancements, including support for additional resolver backends.

The AsposeCellsCloud Perl module provides a convenient interface for interacting with the Aspose.Cells Cloud API, enabling developers to manipulate and manage spreadsheet files in a cloud environment. This module simplifies tasks such as creating, editing, and converting Excel documents, allowing users to leverage the powerful features of Aspose.Cells directly from their Perl applications. With its structured API and role-based access, it facilitates seamless integration of spreadsheet functionalities into various projects, making it an essential tool for developers working with cloud-based spreadsheet solutions.

The `Term::ANSIColor::Concise` Perl module provides a streamlined way to generate ANSI terminal color sequences using a concise notation, making it easier to apply complex color effects in command-line applications. It supports a variety of color specifications, including RGB, HSL, LCH, and Lab color spaces, as well as named colors and basic ANSI colors. Users can easily create colorized text by calling the `ansi_color` function with specific color codes and text, allowing for cumulative effects and adjustments such as luminance, lightness, saturation, and hue. Recent updates in version 3.02 include fixes for luminance settings and improved documentation for effect codes, enhancing the module's usability and accuracy in color representation.

The Perl module RT::Extension::ConditionalCustomFields enhances the functionality of custom fields in the Request Tracker (RT) system by allowing the visibility and editability of one custom field to be conditioned on the value of another custom field within the same object. This plugin enables administrators to set up complex dependencies between custom fields, using various operators such as "is," "isn't," "match," and others to define the conditions under which a custom field should be displayed or edited. With support for multivalued conditions and a flexible configuration process, this extension is particularly useful for tailoring ticket management workflows in RT, ensuring that users only interact with relevant fields based on prior selections. The module is compatible with RT version 6 and provides a robust solution for managing dynamic forms within the ticketing system.

The `greple` Perl module is an advanced and extensible tool designed for searching text with enhanced capabilities beyond traditional grep. It supports lexical expressions and region handling, allowing users to perform complex searches with greater precision and flexibility. With features such as block numbering, escape sequence handling, and support for variable-length lookbehind, `greple` is ideal for developers and system administrators who require powerful text processing capabilities. The latest version, 10.03, introduces a new `--version` option, enhancing usability by allowing users to easily check the module's version. This module is particularly useful for those working with large datasets or requiring intricate pattern matching in their text processing tasks.

The App::sdif module provides a suite of tools for comparing files and visualizing differences in a user-friendly manner. It includes the primary command `sdif`, which displays differences between two files side-by-side, and `cdif`, which enhances this output by highlighting changes at the word or character level. Additionally, `watchdiff` allows users to monitor changes in real-time by repeatedly executing a specified command and visually emphasizing modifications. This module is particularly useful for developers and anyone needing to track changes in text files, making it easier to identify and understand differences. Notably, the recent version 4.42 introduced a `--version` option for all commands, enhancing usability by allowing users to quickly check the installed version of the tools.

SPVM is a statically typed programming language that features a Perl-like syntax, designed for high performance and ease of use. Although it is still in development and has not yet reached a stable version 1.0, SPVM allows users to execute programs, generate executable files, and utilize both Ahead-of-Time (AOT) and Just-in-Time (JIT) compilation. It supports native threads, static types, and type inference, making it suitable for robust application development. Users can write SPVM classes and methods, which can be seamlessly called from Perl, enhancing interoperability between the two languages. With a focus on performance and a rich set of features, SPVM is an innovative tool for developers looking to leverage Perl-like syntax in a statically typed environment.

The Doubly module provides a high-performance implementation of a doubly linked list in Perl, utilizing a C-based backend for efficient memory management and operations. Unlike other linked list implementations that rely on Perl hashes, Doubly offers a true doubly linked list structure, allowing for bidirectional traversal through its nodes. Users can easily create a new list, add or remove items, and navigate through the list using methods such as `next`, `prev`, `start`, and `end`. The module supports bulk additions and various insertion methods, making it versatile for handling large datasets. With its focus on performance, as evidenced by benchmark comparisons, Doubly is an excellent choice for developers needing an efficient linked list solution in Perl.

Sim::OPT is a Perl module designed for optimization and parametric exploration, particularly in the context of simulation programs that utilize text files for input and output. It emphasizes problem decomposition and offers various optimization techniques, including block search methods that allow overlapping subspaces and a combination of sequential and parallel searches. The module includes specialized components such as Sim::OPT::Takechange for exploring less traversed search paths, and Sim::OPT::Morph for manipulating simulation model parameters. Additional modules facilitate tasks like converting 2D plots to 3D Autocad drawings and building metamodels from sparse data. Users can configure the optimization process through a detailed configuration file, specifying parameters, iterations, and search strategies. Notably, Sim::OPT is dual-licensed, offering both open-source and proprietary options, and is primarily intended for use on Linux systems. The latest version, 0.507, was released on December 26, 2025, marking the original version of the module.

Future::Uring is an experimental Perl module that provides a user-friendly interface for utilizing Linux's io_uring functionality, which facilitates efficient asynchronous I/O operations through the use of submission and completion queues. By allowing developers to perform file and socket operations, such as opening, writing, and renaming files, as well as managing directories and processes, Future::Uring enhances performance by enabling non-blocking I/O and the chaining of requests. The module supports various options for fine-tuning I/O behavior, including asynchronous execution, linking requests, and setting timeouts, making it a powerful tool for applications that require high-performance I/O operations in a Perl environment.

The `Music::Intervals` Perl module provides a comprehensive breakdown of musical intervals and notes, allowing users to analyze and compute various musical properties based on a specified set of notes. With its ability to calculate natural and equal-tempered frequencies, intervals, and cents, as well as to identify known intervals by name or ratio, this module serves as a powerful tool for musicians and music theorists alike. Users can create a `Music::Intervals` object with a list of notes and utilize methods to explore the relationships between those notes, including their prime factors and tension metrics. Notably, the recent version 0.1000 introduced the `cope()` and `tenney()` methods, enhancing the module's functionality by allowing users to compute tension measures for musical dyads.

The Perl module `DateTime::Format::Natural` is designed to parse informal natural language date and time strings, allowing users to convert human-readable date expressions into `DateTime` objects. With this module, developers can easily interpret various date formats such as "next Tuesday at 2am," "tomorrow morning," or "10 weeks ago," and extract date/time substrings from ordinary text. The module provides a flexible constructor that allows customization of date formats, language settings, and time zone preferences. Recent updates include improved support for parsing ISO 8601 strings with fractional seconds and optional time zone information, enhancing its functionality for modern applications. This makes `DateTime::Format::Natural` a powerful tool for applications that require natural language date processing.

"Net::LibAsyncNS" is a Perl module that serves as a wrapper around the libasyncns library, enabling asynchronous name resolution in non-blocking applications. It allows developers to perform DNS queries, such as `getaddrinfo` and `getnameinfo`, without blocking the execution of their programs. By creating an instance of `Net::LibAsyncNS`, users can initiate multiple queries and handle their results as they complete, making it ideal for applications that require efficient network communication. The module provides various methods for managing queries, including waiting for their completion and retrieving results, while also allowing the storage of user-defined data with each query. A notable recent change in version 0.05, released on January 18, 2026, involved a general refresh of the module to align with current coding styles, enhancing its maintainability and readability.

Linux::Landlock is a Perl module that provides a higher-level, object-oriented interface to the Linux Landlock API, enabling developers to implement sandboxing for processes on Linux systems. This module allows a process to restrict its own access to the file system and network, enhancing security by preventing unauthorized access and mitigating risks such as directory traversal attacks. With methods to create rulesets, apply restrictions dynamically, and manage file and network access, Linux::Landlock is particularly useful for applications that require fine-grained control over resource access without needing root privileges. Recent updates include support for Landlock ABI version 6 and enhancements to handle older ABI versions more effectively, ensuring broader compatibility and improved functionality.

The WWW::Crawl module is a straightforward web crawling utility designed for extracting links and resources from web pages within a specified domain. With version 0.5, it allows users to initiate a crawl from a given URL, recursively exploring the site to retrieve URLs found in various HTML elements, including href attributes and form actions, while ignoring certain file types like PDFs and images. Users can customize the crawling process by providing options such as a user agent string and the ability to skip following links for testing purposes. The module also supports a callback mechanism, enabling users to define custom processing logic for each visited page, making it a versatile tool for web scraping and link extraction tasks.

"Future::IO::Impl::UV" is a Perl module that serves as an implementation of the "Future::IO" interface utilizing the UV library. It allows developers to leverage asynchronous I/O operations seamlessly within their applications. By simply loading this module alongside "Future::IO," users can access its implementation methods without the need for additional configurations. This module is particularly useful for those looking to enhance their Perl applications with non-blocking I/O capabilities, enabling more efficient handling of concurrent tasks.

The "Future::IO::Impl::Tickit" module provides a specialized implementation of the Future::IO interface using the Tickit framework, enabling asynchronous I/O operations in Perl applications that utilize Tickit for terminal handling. To utilize this module, developers must first create a Tickit instance and set it using the `set_tickit` method, ensuring that the Future::IO functionalities are properly integrated with the Tickit event loop. A noteworthy recent update in version 0.02, released on January 18, 2026, introduced the new `->poll` method, enhancing compatibility with Future::IO v0.19 and expanding the module's capabilities.

"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 allows developers to leverage asynchronous I/O operations in their applications without needing to implement additional methods; simply loading the module provides access to the necessary "Future::IO" functionality. Notably, in version 0.03, released on January 18, 2026, the module introduced a new `->poll` method in line with updates to Future::IO v0.19, enhancing its capabilities for handling asynchronous events. Users should be aware that the "waitpid" method will manage the $SIG{CHLD} signal, and overriding this handler may disrupt the functionality of "waitpid" futures.

"Future::IO::Impl::Glib" is a Perl module that provides an implementation of the Future::IO API using Glib, making it an ideal choice for developers working with Glib or Gtk applications. By simply loading this module alongside Future::IO, users can seamlessly utilize asynchronous I/O operations, such as sleeping for a specified duration. The module has evolved over time, with the most recent update (version 0.03) introducing the new `->poll` method, enhancing its functionality in line with Future::IO v0.19. This makes it a valuable tool for those looking to integrate asynchronous programming into their Glib-based projects.

The "Test::Future::IO::Impl" module provides a suite of acceptance tests designed for validating implementations of the "Future::IO" framework in Perl. By utilizing this module, developers can easily run a series of predefined tests against their specific "Future::IO" implementation, ensuring that core functionalities such as connection handling, data transmission, and process management operate as expected. The module includes various test suites that cover essential methods like accept, connect, poll, send, and sleep, among others, allowing for comprehensive testing of the implementation's compliance with the "Future::IO" specifications. This makes "Test::Future::IO::Impl" an invaluable tool for developers looking to maintain high standards of reliability and performance in their asynchronous I/O operations.

"Future::IO" is a Perl module designed to facilitate asynchronous input/output operations by returning results as Future instances, which allows for non-blocking execution of IO tasks. It provides a set of methods that mirror core Perl IO functions, such as `read`, `write`, `sleep`, and `connect`, enabling developers to write modules that handle IO in an asynchronous manner. The module includes a default implementation suitable for simple cases involving a single filehandle, while also allowing for more complex setups by loading alternative implementations through the `load_best_impl` method. Recent updates include the addition of a `poll` method for standardized IO readiness checks and clarifications regarding the behavior of cancelled IO futures, enhancing the module's usability and reliability in various environments.

The Dpkg module in Perl serves as a foundational component for managing core variables related to the system installation of the Debian package management system. It provides essential information such as the current program name, version of the dpkg suite, and paths to critical directories like the configuration, database, and methods directories. This module acts as the entry point to a comprehensive hierarchy of related modules, each designed to handle various aspects of package management, including architecture handling, build options, changelog parsing, dependency management, and more. By utilizing the Dpkg module, developers can efficiently interact with and manipulate the underlying structures of Debian packages, streamlining the development and maintenance of software within the Debian ecosystem.

The Datafile::Hash module is a lightweight, pure-Perl utility designed for reading and writing key-value data files, including INI-style configuration files with multi-level sections. It allows users to easily load data into nested hashes or flat structures, supporting various delimiters and providing options for handling comments, empty lines, and file permissions. With features like safe atomic writes, detailed error handling, and the ability to generate backup files, Datafile::Hash is ideal for managing configuration settings in a structured manner. Notably, the recent version 1.05 introduced search filtering capabilities, enhanced verbose messaging for debugging, and improved atomic write functionality, making it even more robust for developers working with configuration data.

The Datafile::Array module is a lightweight, pure-Perl utility designed for reading and writing delimited data files with ease. It supports various features such as CSV-style quoted fields, automatic or explicit headers, and prefix lines following the H/R convention for headers and data. Users can load data into an array of hashes, apply search filtering, and trim whitespace from values, while also benefiting from safe atomic writes through temporary files. The module includes a standalone CSV line parser and offers extensive configuration options, including delimiter settings and comment handling. A noteworthy recent update in version 1.05 introduced enhanced CSV parsing capabilities, multi-line record support, and improved error handling, making it a robust choice for managing delimited data files in Perl.

Crypt::OpenSSL::PKCS10 is a Perl module that provides an interface to OpenSSL's PKCS10 API, enabling the creation of PKCS10 certificate requests using RSA and Elliptic Curve key pairs. It allows users to set the subject of the request, add various extensions (including custom ones), and sign the request with specified hash algorithms. The module supports generating new key pairs, importing existing ones from PEM or DER files, and writing the resulting requests and keys to files in PEM format. Notably, recent updates have improved compatibility with OpenSSL 3.0 and enhanced support for reading certificate requests from files, making it a robust choice for developers working with cryptographic requests in Perl.