CPANscan

Aion::Annotation is a Perl module designed to streamline the processing of annotations within Perl modules by scanning the specified codebase and extracting relevant comments and annotations. It organizes this information into structured files located in a designated directory, allowing developers to easily track module updates, remarks, and TODO items. With configurable paths for both the source code and output files, Aion::Annotation enhances code documentation and maintenance by automatically generating files that detail the last modification times, comments on routines and properties, and parameter annotations. This module is particularly useful for developers looking to maintain clear and organized documentation within their Perl projects.

The `Hash::Merge::Simple` Perl module provides a straightforward way to recursively merge two or more hashes, returning a new hash reference that combines their contents. When merging, the values from the rightmost hash take precedence, effectively overriding any conflicting keys from the left hashes. This module is particularly useful for scenarios where nested hashes need to be merged, as it will also handle subordinate hashes appropriately. Additionally, it offers methods like `clone_merge` and `dclone_merge` to create merged results without side effects, ensuring that modifications to the original hashes do not affect the merged output. This module is derived from code in `Catalyst::Utils`, making it a reliable choice for developers needing efficient hash merging capabilities in their Perl applications.

The `String::Print` Perl module offers a powerful alternative to the traditional `printf` and `sprintf` functions, enabling developers to easily insert values into format strings using both functional and object-oriented interfaces. It supports named parameters for interpolation, allowing for clearer and more maintainable code, especially in contexts involving translations. The module also features pluggable serializers and modifiers, which enhance its flexibility by allowing custom formatting and handling of various data types, including arrays and hashes. Additionally, `String::Print` ensures proper handling of Unicode and provides automatic output encoding for HTML, making it an ideal choice for modern Perl applications that require robust string formatting capabilities.

The Aion::Run module is a Perl role designed to facilitate the handling of command line arguments for console commands, enabling developers to easily define and manage script parameters. By utilizing this module, developers can create script objects that automatically parse command line options, allowing for both named and ordinal parameters. The module supports various argument types, including shortcuts for named parameters and the ability to handle unnamed parameters as arrays. This makes it particularly useful for building command line applications that require flexible input handling, such as mathematical operations or other calculations, as demonstrated in the provided example. With Aion::Run, developers can streamline the process of argument management, enhancing the usability and functionality of their scripts.

Mojolicious::Plugin::OpenAPI::Modern is a powerful plugin for the Mojolicious web framework that facilitates the integration of OpenAPI specifications into your application. It provides access to an OpenAPI document and a parser, allowing developers to validate incoming requests and outgoing responses against defined API schemas. With flexible configuration options, users can specify OpenAPI documents via file paths, URIs, or directly as Perl data structures. The plugin enhances API development by enabling automatic validation and logging of request and response data, ensuring compliance with the OpenAPI standard. This module is particularly useful for developers looking to streamline API design and improve the reliability of their web applications.

SPVM is a statically typed programming language that features a Perl-like syntax, designed to enhance performance and type safety in programming. Although it has not yet reached a stable release, SPVM allows developers to execute programs, generate executable files, and utilize both Ahead-of-Time (AOT) and Just-in-Time (JIT) compilation techniques. It supports native threads, static types, and type inference, making it suitable for high-performance applications. With the ability to call SPVM methods from Perl and integrate with C/C++ libraries, SPVM provides a versatile environment for developers looking to leverage the strengths of both Perl and compiled languages.

The IO::K8s Perl module provides a set of objects and methods for interacting with the Kubernetes API, facilitating the serialization and deserialization of Kubernetes structures. It allows users to convert JSON data into corresponding Perl objects and vice versa, ensuring that the data types conform to the strict requirements of the Kubernetes API. This module is particularly useful for developers working with Kubernetes, as it helps manage the complexities of data formatting and type validation. Recent updates include the addition of a convenient `to_json` method for all objects, enhancing usability for developers.

The `Data::Roundtrip` Perl module provides a versatile set of utilities for converting between Perl data structures, JSON, and YAML, while ensuring proper handling of Unicode content. With functions for transforming JSON to YAML and vice versa, as well as converting Perl variables to their string representations, this module facilitates seamless data interchange in various formats. It supports options for pretty-printing and Unicode escaping, making it suitable for both human-readable output and machine processing. Additionally, `Data::Roundtrip` includes file handling capabilities, allowing users to read from and write to files directly, enhancing its usability in data manipulation tasks. This module is particularly useful for developers needing to work with different data formats in a consistent and efficient manner.

The `Android::ElectricSheep::Automator` Perl module provides a powerful interface for controlling Android devices directly from a desktop environment, leveraging the capabilities of the Android Debug Bridge (ADB). Designed for developers and testers, this module allows users to perform a variety of actions on connected Android devices, including navigating the user interface, opening and closing applications, simulating touch events, and managing files. With features such as screen capture, geolocation manipulation, and process management, it serves as a comprehensive tool for automating interactions with both physical and emulated Android devices. Notably, it operates without installing any software on the device itself, ensuring a non-intrusive approach to device management. However, users should be aware that the module is currently in an alpha stage, and its API may undergo changes.

Test2::Harness is a robust Perl module designed to serve as a backend for running and processing tests, offering enhanced integration with the Test2 framework. While users typically interact with it indirectly through the App::Yath user interface, Test2::Harness provides essential functionalities for managing test execution and reporting. Recent updates include the removal of an unintended dependency on Test::Exception and improvements in preserving the exit status across various scenarios, ensuring more reliable test outcomes. This module is particularly valuable for developers looking to streamline their testing processes and enhance the reliability of their test suites.

Mooish::Base is a Perl module designed to simplify the creation of classes and roles within the Moose family of object-oriented programming frameworks. By using Mooish::Base, developers can easily import essential components such as Moo, Mooish::AttributeBuilder, and Types::Common, streamlining the setup process for their classes and roles. The module also supports a "-role" flag to import Moo::Role instead of Moo, catering to different development needs. Additionally, it allows customization through environmental variables to modify the underlying class and role systems, ensuring compatibility with various Moose flavors like Moose, Mouse, and Moo. This module is particularly beneficial for module authors, as it provides a solid foundation while maintaining flexibility and performance enhancements through optional modules.

Crypt::SecretBuffer is a Perl module designed to securely manage sensitive data, such as passwords, by preventing accidental exposure or copying in memory. It provides a specialized buffer that ensures secrets are wiped from memory when no longer needed, thereby reducing the risk of leaks in long-running applications. The module allows for secure input from the console without echoing characters, and it can interact with external commands without exposing the secret in Perl's memory. Recent updates in version 0.010 include bug fixes, new methods for manipulating the buffer, and enhancements to the C API, making it easier to integrate with C code while maintaining security practices. This module is particularly useful for developers looking to handle sensitive information safely within their Perl applications.

The Sys::Async::Virt Perl module provides an asynchronous interface for interacting with LibVirt services via its remote protocol, enabling clients to manage virtualization environments effectively. Built on the IO::Async framework, this module allows users to connect to a LibVirt server, execute various commands such as listing domains, and handle events asynchronously. It offers a user-friendly object-oriented API that maps closely to the underlying C API of LibVirt, while also accommodating differences in data types and argument handling. Notably, version 0.1.10 introduces updates to the LibVirt library, enhancing functionality with new constants related to storage and event management, ensuring that users can leverage the latest features available in the virtualization ecosystem.

The `Protocol::Sys::Virt` Perl module provides an abstract implementation of the LibVirt protocol, enabling the development of client and server components that interact with virtualization technologies. Designed to facilitate a truly asynchronous interface to LibVirt, this module addresses the limitations of the existing `Sys::Virt` module, which operates with blocking API calls. Unlike Python's threading model, which allows for shared variables across threads, Perl's threading is discouraged and creates isolated interpreters, making `Protocol::Sys::Virt` a valuable solution for developers seeking non-blocking interactions with LibVirt. This module is particularly useful for those looking to leverage the asynchronous capabilities of LibVirt in their Perl applications.

MooX::TypeTiny is a Perl module designed to enhance the performance of type checks in Moo classes when used in conjunction with Type::Tiny. By optimizing the way type checks and coercions are applied, this module allows for faster execution of attribute setters, achieving speeds comparable to those found in Moose. It achieves this by inlining type checks specifically for Type::Tiny, rather than relying on Moo's general mechanism. While it currently serves as a performance booster, there is an expectation that future developments may render this module unnecessary by automating the type inlining process.

SQL::Shell is a versatile command interpreter designed for creating database shells and executing batch scripts using the DBI framework in Perl. It provides a user-friendly command-line interface with features akin to popular database clients like mysql and sql*plus, but operates independently of any specific database, making it adaptable for various DBI-compatible databases. Key functionalities include executing SQL commands, managing command history, displaying database schemas, and importing/exporting data from delimited files. Users can customize commands and output formats, enhancing the shell's flexibility. The latest version, 1.18, introduces the use of File::Temp for improved handling of temporary files, further streamlining its operation.

The Win32::Console::DotNet module provides a .NET-compatible interface for managing Windows console applications in Perl, building upon the existing Win32::Console functionality. This module simplifies console input and output operations, allowing developers to easily read keyboard inputs, write text to the console, and manipulate console properties such as title, cursor position, and colors. It abstracts complex low-level Windows console functions and structures, making it easier to create robust console applications. Recent updates have included bug fixes for various methods and enhancements to support encoding and console key information, ensuring improved reliability and functionality for developers working with console applications in Perl.

The IO::Uring module provides a low-level interface to Linux's io_uring, enabling efficient asynchronous I/O operations in Perl. By drastically reducing the number of system calls required for I/O tasks, it allows developers to schedule actions and receive notifications via callbacks when those actions complete. The module's methods closely mirror system calls, with additional parameters for submission flags and callbacks, facilitating advanced features like chaining actions and handling timeouts. Designed for performance and flexibility, IO::Uring is ideal for applications that require high concurrency and low latency, although it is still considered experimental and may undergo changes in future releases.

Test::Unit is a Perl module that provides a unit testing framework inspired by the JUnit framework for Java, designed to facilitate unit testing in an object-oriented programming environment. It supports inheritance of tests and offers both object-oriented and procedural interfaces, making it versatile for various coding styles. The module includes essential components such as Test::Unit::TestCase and Test::Unit::TestSuite for structuring tests, while also allowing for procedural testing through Test::Unit::Procedural. Recent updates include version 0.28, which involved code formatting improvements without functional changes, and previous updates that enhanced hash comparison during tests to prevent randomization issues. This framework is particularly useful for developers looking to implement robust testing practices in their Perl applications.

WebDyne is a dynamic Perl web application framework designed for high performance and modularity, enabling seamless integration of Perl code within HTML files through template compilation and caching. It supports both CGI and persistent environments like mod_perl and PSGI, allowing developers to render .psp templates into HTML using the `html` and `html_sr` functions. With features such as block rendering, custom handlers, and caching, WebDyne is built for flexibility and efficiency, making it suitable for a variety of web applications. Recent updates include enhancements to the `html` function, allowing for alternative outputs, and improvements in error handling, ensuring a more robust development experience. Comprehensive documentation is available to guide users through its features and usage.

Print::Format is a Perl module designed to facilitate the creation of responsive text formats for output, particularly useful for generating structured reports such as bug reports. By defining a format template using a simple syntax, users can easily control the alignment and layout of various fields, ensuring that the output is both readable and well-organized. The module allows for dynamic data insertion, enabling developers to print formatted tables and detailed information with minimal effort. As of its initial release in version 0.01, Print::Format provides a straightforward approach to formatting output, making it a valuable tool for Perl developers looking to enhance the presentation of their data.

The `Telegram::Bot` module serves as a foundational class for developers looking to create their own Telegram bots using Perl. With a straightforward interface, it allows users to easily implement bot functionalities, such as responding to messages and sending media. The module leverages the Mojolicious framework, enabling developers to define custom behaviors through simple methods. Recent updates, including version 0.029, have improved the handling of UTF-8 encoded strings by switching to `to_json`, enhancing the module's reliability when processing messages. This module is ideal for those wanting to build interactive bots for Telegram, with a focus on ease of use and extensibility.

The AI::ActivationFunctions module provides a collection of activation functions essential for building and training neural networks in Perl. It includes widely used functions such as ReLU, sigmoid, and tanh, as well as advanced options like GELU and Swish, catering to various machine learning needs. The module supports both scalar and array inputs, allowing for flexible usage in different contexts. Additionally, it offers derivatives for key functions to facilitate backpropagation during the training process. With the ability to export specific functions or groups of functions, AI::ActivationFunctions is a versatile tool for developers working on artificial intelligence and machine learning projects in Perl.

The Sys::Virt Perl module provides a powerful interface for managing virtualization environments through the libvirt API, enabling users to connect to various hypervisors and perform operations on virtual machines, networks, and storage pools. With methods for creating, defining, and managing domains, networks, and storage resources, Sys::Virt allows for comprehensive control over virtualized environments. Recent updates include the addition of new constants for domain backup and event handling, enhancing the module's capabilities for managing virtual machine states and statistics. This makes Sys::Virt an essential tool for developers and system administrators working with virtualization technologies.

Config::Abstraction is a versatile Perl module designed to streamline the management of configuration data from various sources, including files, environment variables, and in-code defaults. It allows developers to load and merge configurations with a clear precedence order, ensuring that settings can be easily overridden as needed. Supporting multiple file formats such as YAML, JSON, XML, and INI, this module provides a consistent API for accessing configuration values, which can be done using a dotted notation for nested structures. Recent updates in version 0.37 include the addition of a command-line option for version display and improved handling of dependencies, enhancing its robustness and usability for dynamic configuration management in Perl applications.

LaTeX::Replicase is a Perl module designed to facilitate the dynamic generation of TeX-LaTeX documents by acting as a minimalistic template engine. It allows users to fill in templates with variable data through a straightforward syntax, utilizing control tags to define and substitute values from Perl data structures such as scalars, arrays, and hashes. The module supports various options for customizing the output file's location and name, as well as for handling special TeX characters. By separating the logic of data processing from the document structure, LaTeX::Replicase enables the creation of customizable and programmatically configurable documents, making it an efficient tool for generating consistent PDF or PostScript outputs.

The "meta" Perl module provides a powerful metaprogramming API that allows developers to inspect and manipulate the structure of their own Perl programs. By utilizing "meta"-objects, users can access various parts of the Perl interpreter, enabling them to create, modify, or remove symbols and other elements within packages dynamically. This module serves as a more user-friendly alternative to traditional metaprogramming techniques, such as using "no strict 'refs'", and aims to offer a consistent interface for enhancing Perl's capabilities. With methods for retrieving package information, adding new symbols, and managing subroutines, "meta" is designed for those looking to leverage advanced programming techniques, although it is currently considered experimental and subject to change.

Getopt::Guided is a Perl module that provides a robust implementation of the getopts() function, designed to adhere to POSIX utility guidelines for command-line option parsing. It allows developers to easily define and process command-line options, storing the results in a hash for convenient access. The module supports both flag options and options requiring arguments, with distinct handling for repeated options—overwriting for colon-prefixed options and array accumulation for comma-prefixed options. Notably, it includes error handling for illegal options and missing arguments, ensuring that @ARGV is restored in case of errors. Released in December 2025, Getopt::Guided is a valuable tool for Perl developers seeking a compliant and user-friendly way to manage command-line arguments.