CPANscan

DBIx::Class::Async is a Perl module designed to facilitate asynchronous database operations using the DBIx::Class ORM framework. By leveraging a process-based worker pool built on IO::Async, it allows developers to perform non-blocking CRUD operations while maintaining persistent database connections in separate worker processes. This module returns results as Future objects, enabling efficient handling of database queries without stalling the main event loop. Key features include support for high-level atomic operations, transaction management, optional result caching, and health checks for worker processes. Ideal for applications requiring concurrent database access, DBIx::Class::Async enhances performance and responsiveness in environments where traditional synchronous database interactions may lead to bottlenecks.

Excel::ValueWriter::XLSX is a Perl module designed for the efficient creation of data-only Excel workbooks in XLSX format, focusing on speed and low resource consumption. Unlike more feature-rich alternatives like Excel::Writer::XLSX, this module prioritizes performance by generating workbooks that contain only plain values and formulas, making it ideal for scenarios where Excel is used as a simple database or for handling large datasets. Users can easily add sheets with various data sources, including arrays, database handles, or callback functions, and can define names and formulas for use within the workbook. Recent updates include the addition of a <dimension> node in the XML output to enhance compatibility with the Excel ecosystem, particularly for the companion module Excel::ValueReader.

Git::Server is a Perl module designed to serve as a secure Git server that enhances the default capabilities of Git by offering more granular hooks and access control lists (ACLs). It acts as a drop-in replacement for standard Git servers, allowing administrators to set up a Git repository with advanced server hooks and user permissions. The module simplifies the process of managing user access through SSH keys, enabling authorized users to perform Git operations seamlessly. With its focus on security and flexibility, Git::Server is ideal for developers looking to implement a robust Git hosting solution with tailored access controls.

SPVM::HTTP::Tiny is an experimental HTTP client module designed for use within the SPVM (Simple Perl Virtual Machine) framework, providing a straightforward interface for making HTTP requests. It serves as a wrapper around Mojo::User::Agent, allowing developers to perform various HTTP operations such as GET, POST, PUT, PATCH, HEAD, and DELETE requests while managing request headers and timeouts. The module emphasizes ease of use with a simple method for creating a new HTTP client instance and handling responses, including status codes and content. However, due to its experimental nature, users should be aware of potential incompatibilities and dependencies. This module is ideal for developers looking to integrate HTTP functionality into their SPVM applications with minimal overhead.

SPVM::Mojolicious is a real-time web framework that serves as a port of Perl's Mojolicious to the SPVM (Simple Perl Virtual Machine) environment. Currently in early development, this framework lacks comprehensive documentation, and its methods and functionalities are subject to frequent changes. It includes a variety of classes for handling HTTP requests, cookies, assets, and more, drawing on the capabilities of Mojolicious. Recent updates have introduced significant changes, such as the requirement for SPVM::Go 0.024 and the injection of Go::Context into several methods of Mojo::UserAgent, reflecting ongoing enhancements to its functionality. As it evolves, SPVM::Mojolicious aims to provide a robust foundation for building real-time web applications in the SPVM ecosystem.

The SPVM::Go module provides a Perl interface to the goroutines and channels of the Go programming language, enabling concurrent programming within Perl applications. It allows developers to create and manage goroutines using the `go` method, and to communicate between them via channels created with the `make` method. The module includes various methods for scheduling, sleeping, and handling I/O operations with timeouts, ensuring efficient management of concurrent tasks. Recent updates have improved the handling of goroutine cancellation and introduced support for default values in sleep and I/O methods, enhancing usability and flexibility for developers. With its robust features, SPVM::Go is an essential tool for Perl programmers looking to leverage Go's concurrency model.

The `ansicolumn` Perl module is designed to facilitate the formatting of text output in a columnar layout while being aware of ANSI escape sequences, making it particularly useful for terminal applications that utilize color and formatting. This module allows users to create visually appealing and organized text displays, accommodating various options for borders, alignment, and margins. Recent updates include the addition of the `ansicolumn()` function for compatibility with `App::Greple::tee`, enhancing its integration capabilities, and the requirement for `Text::ANSI::Fold` version 2.3303, which improves text handling. With its flexible options and robust functionality, `ansicolumn` is an essential tool for developers looking to enhance terminal output in Perl applications.

App::ansifold is a Perl module designed to handle ANSI terminal sequences effectively, allowing users to fold command output while preserving the formatting of colored or styled text. This utility is particularly useful for developers and system administrators who need to manage terminal output that includes ANSI escape codes, ensuring that text remains readable and well-structured. Recent updates include the addition of a new `--margin` option for specifying right margin width and enhancements for better integration with other tools, such as the `App::Greple::tee`. The module also now supports improved handling of Korean text and various options for text formatting, making it a versatile tool for terminal output management.

The SPVM::Getopt::Long module provides a robust mechanism for parsing command line options in SPVM (Simple Perl Virtual Machine). It allows developers to define options with various types, including strings, integers, and floating-point numbers, and to handle boolean flags seamlessly. By utilizing the `GetOptionsFromArray` method, users can easily specify option names and their expected types, while the module manages the parsing of command line arguments, ensuring that values are correctly assigned to a provided hash structure. Recent updates include a bug fix in version 0.004 that addresses issues with options containing hyphens, enhancing the module's reliability and usability. This module is essential for SPVM applications that require flexible command line interfaces.

The "Conduit" Perl module provides an asynchronous HTTP server built on Future::IO, allowing developers to handle HTTP requests efficiently. It supports both a simple HTTP::Message-based responder and PSGI applications, making it versatile for various web application architectures. The server can be configured to listen on a specified TCP port and is designed to report basic metrics about incoming requests and outgoing responses through Metrics::Any. Recent updates have introduced a simple HTTP::Message responder as an alternative to PSGI, along with reliability improvements that prevent server crashes due to client connection issues. This module is still in an experimental phase, with plans for future enhancements, including support for PAGI and HTTPS.

The Sys::Async::Virt::Connection::TLS module provides a means to establish a secure connection to a remote LibVirt server using TLS sockets, ensuring encrypted communication by default. Designed for asynchronous operations, it integrates with Future::IO::Resolver for non-blocking DNS resolution, although it can fall back to blocking calls if necessary. Users can create connections through the Sys::Async::Virt::Connection::Factory, and the module supports additional parameters as outlined in LibVirt's documentation, although some features, such as "tls_priority" and "no_verify," are currently unsupported. The recent update to version 0.0.2 improved the module's ability to detect class versions, enhancing its robustness.

Async::Redis is an asynchronous Redis client for Perl that leverages Future::IO to provide a modern, non-blocking interface for interacting with Redis databases. It supports full async/await syntax through Future::AsyncAwait, making it easy to perform Redis operations without blocking the event loop. Key features include automatic reconnection with exponential backoff, connection pooling, pipelining for efficient command execution, and robust PubSub capabilities. The module is event loop agnostic, compatible with various backends like IO::Async and UV, and includes support for TLS/SSL connections and OpenTelemetry observability. With its ability to handle multiple concurrent commands safely and its comprehensive support for Lua scripting, Async::Redis is ideal for high-performance applications that require efficient and scalable Redis interactions.

The Data::Alias Perl module provides a powerful set of aliasing operations that allow developers to create aliases for variables, arrays, and hashes instead of making copies, enhancing both performance and code readability. By using the `alias` keyword, users can define aliases within a block or for specific variables, enabling efficient manipulation of data without the overhead of copying. The module also includes the `copy` function to restore normal copying semantics when needed, and the `deref` function for dereferencing multiple references at once. Recent updates have improved compatibility with newer Perl versions, including fixes for state variables and handling negative array indices. While Data::Alias offers valuable functionality, users are encouraged to consider the core aliasing features introduced in Perl 5.22 for more robust support.

Moonshine::Magic is a Perl module designed to enhance the functionality of Moonshine components by providing features such as attribute handling, component extension, and lazy loading of HTML elements. With its simple syntax, developers can easily define attributes using the `has` method, extend existing components with `extends`, and utilize `lazy_components` to defer the creation of HTML elements until they are needed. This module streamlines the process of building dynamic web applications by allowing for cleaner and more maintainable code. Notably, recent updates have improved the lazy loading capabilities, making it even easier to manage component rendering efficiently.

Monitoring::Sneck is a Perl module designed to facilitate the execution of Nagios-style checks through a JSON interface for LibreNMS, leveraging SNMP extensions. It allows users to define checks and environment variables in a configuration file, which the module parses to execute commands and return results in a structured format. The latest version, 1.3.0, introduces options for quiet operation and locking, enhancing its usability in various monitoring scenarios. This module is particularly useful for system administrators looking to integrate custom checks into their monitoring solutions while maintaining a clear and manageable configuration.

The `LaTeX::Easy::Templates` Perl module simplifies the process of formatting content into high-quality PDF, Postscript, or DVI documents using LaTeX templates. By leveraging the powerful LaTeX typesetting system, this module allows users to transform structured Perl data (like arrays of hashes) into beautifully formatted documents with minimal effort. Users can define templates in LaTeX syntax, incorporating placeholders for dynamic content, and utilize the Text::Xslate templating engine for efficient rendering. Notably, version 1.04 introduced a new tag, `<<%% eatnewline+ %%>>`, which effectively removes all trailing newlines after its invocation, enhancing the control over document formatting. This module is ideal for generating reports, articles, or any document requiring professional typesetting, provided that LaTeX is installed on the user's system.

Data::TreeDumper is a Perl module designed to provide a more user-friendly alternative to Data::Dumper for visualizing complex data structures. It outputs data in a tree-like format that enhances readability by clearly labeling each node with its type and address, making it easier to understand relationships within the data. The module offers extensive customization options, including filtering capabilities, maximum depth control, and various display settings, allowing users to tailor the output to their specific needs. With features like color coding, indentation, and the ability to suppress or modify output, Data::TreeDumper is particularly useful for debugging and analyzing intricate data structures in Perl applications.

The `Net::Z3950::ZOOM` Perl module serves as a low-level interface to the ZOOM-C API, part of the YAZ toolkit, facilitating communication via the Z39.50 and SRW/U protocols. While it allows developers to create connections, set options, and handle errors, it is primarily intended for advanced users who require direct access to the underlying API, as its use is discouraged in favor of the higher-level `ZOOM` module, which offers a more user-friendly interface. Recent updates in version 1.32 include significant improvements to the module's configuration process, allowing it to utilize Debian's yaz-config when pkg-config is unavailable, and adjustments to the test suite to eliminate dependencies on defunct servers, enhancing overall reliability and usability.

The Term::Choose Perl module provides an interactive way for users to select items from a list, either through a functional or object-oriented interface. With its versatile `choose` function, users can make single or multiple selections from an array, customize prompts, and utilize various options for display and behavior, such as alignment, pagination, and mouse support. This module is particularly useful for command-line applications that require user input in a user-friendly manner, allowing for easy navigation through potentially large lists of choices. It also includes features for handling undefined or empty elements, making it robust for various use cases.

The `Config::Model::TkUI` module provides a graphical user interface (GUI) for editing configuration data using the Config::Model framework. It allows users to interactively modify configuration files, such as `/etc/X11/xorg.conf`, through a Tk-based interface. The module features a tree structure for navigating configuration elements, various editing options, and the ability to copy and paste configuration data. Users can also utilize a wizard for guided editing of important or erroneous items. Recent updates include bug fixes that enhance the functionality of hash editors and checklist viewers, as well as improvements to the main UI, such as the addition of an "auto save" option and better handling of filtered elements. This makes `Config::Model::TkUI` a robust tool for managing complex configuration settings in a user-friendly manner.

Config::Model is a powerful Perl framework designed to facilitate the validation, migration, and editing of configuration files. It allows developers to create interactive configuration editors that can be graphical, terminal-based, or curses-based, providing users with a seamless experience when managing configuration settings. By defining a configuration model that outlines the structure and constraints of the configuration data, Config::Model generates user interfaces that include integrated help and data validation. This module supports various backends for reading and writing configuration data, making it versatile for different file formats. Additionally, it simplifies the process of configuration upgrades and audits, ensuring that changes are validated and easily manageable. With its ability to separate configuration models from processing logic, Config::Model enhances maintainability and usability across applications.

PAGI (Perl Asynchronous Gateway Interface) is a specification designed for asynchronous Perl web applications, serving as a modern successor to PSGI. It establishes a standard interface for async-capable Perl web servers, frameworks, and applications, supporting protocols such as HTTP/1.1, WebSocket, and Server-Sent Events (SSE). With its focus on asynchronous programming, PAGI allows developers to create responsive web applications using an async/await syntax. The module includes various components like PAGI::Server, which provides a reference server implementation, and PAGI::Request, which simplifies HTTP request handling. Recent updates have introduced query parameter parsing for PAGI::SSE and PAGI::WebSocket, enhancing the module's functionality and usability. As a beta software, PAGI is actively developed, inviting contributions and feedback from the community to shape its future.

The `Config::Model::Tester` module provides a robust testing framework specifically designed for configuration models in Perl. It allows developers to create and run tests for various configuration models by specifying test cases in a structured format. The module supports complex configurations, enabling tests to be organized into subtests with specific data files and parameters tailored to different applications. Recent updates include the addition of a `data_from_group` parameter to streamline the reuse of test data across different test groups, enhancing efficiency and reducing redundancy. With its comprehensive capabilities, `Config::Model::Tester` is an essential tool for ensuring the reliability and correctness of configuration models in Perl applications.

App::rdapper is a command-line client for the Registration Data Access Protocol (RDAP), designed to retrieve and display information about internet resources such as domain names, IP addresses, and autonomous systems in a user-friendly format. Users can query various types of objects, including forward and reverse domain names, IP addresses, and registrar details, using a range of options to customize their queries. Notably, version 1.23 introduced a fix for a broken method call, ensuring smoother operation. With features like internationalization support, search capabilities, and the ability to bypass local caches, App::rdapper is a versatile tool for network administrators and developers needing quick access to RDAP data.

Log::Log4perl::Config::YamlConfigurator is a Perl module designed to facilitate the reading and processing of Log4perl configurations written in YAML format. By leveraging the YAML::PP module, it allows developers to easily define logging settings, including loggers, appenders, and layouts, in a structured and human-readable manner. The configurator can be instantiated with either a parsed YAML data structure or a raw YAML string, and it provides methods to parse the configuration and create appender instances for logging. Recent updates include the migration of the project to Codeberg and improvements in the project's setup and dependencies, enhancing its usability and maintainability.

Sisimai is a powerful Perl library designed for decoding and analyzing bounce emails, providing structured data about delivery failures, including reasons for bounces and recipient addresses. It allows users to extract detailed information from complex email formats, outputting results in both Perl hash references and JSON format. With methods like `rise()` and `dump()`, Sisimai can process emails from various sources, including file paths and standard input, while also supporting options to include delivered messages and vacation responses. Additionally, it features a callback mechanism for custom processing of email headers and bodies, making it a versatile tool for developers needing to handle email delivery status notifications effectively.

App::PDFUtils is a versatile Perl module that provides a suite of command-line utilities for managing PDF files, including functionalities for password protection, compression, text extraction, and password verification. With commands like `add-pdf-password`, `compress-pdf`, `pdfgrep`, and `remove-pdf-password`, users can easily manipulate PDF documents directly from the command line. The module enhances usability by offering features such as configuration file support for passwords and options for handling multiple files. A noteworthy recent update in version 0.017, released on February 2, 2026, improved compatibility with AppArmor by ensuring temporary files end with a .pdf extension instead of .tmp. This module is ideal for users looking to streamline their PDF workflows with powerful command-line tools.

The `chot` module, short for Command Heuristic Omni-Tracer, is designed to facilitate the tracing and debugging of command execution within Perl scripts. By integrating this module into your executable scripts, you can enhance your ability to monitor and analyze command behavior, making it easier to identify issues and optimize performance. For detailed usage instructions, users can refer to the documentation included with the module by using the `perldoc chot` command. Authored by Kazumasa Utashiro, `chot` is released under the same terms as Perl itself, ensuring its availability for modification and redistribution.

Net::Daemon is a Perl module designed to simplify the creation of portable server applications by providing an abstract base class for implementing daemons. It facilitates common daemon tasks such as startup, logging, client acceptance, and security management, allowing developers to focus on the specific functionality of their applications. With support for both threading and forking, Net::Daemon enables the handling of multiple client connections efficiently. The module includes features for command line parsing, configuration file support, and access control based on client IP or hostname. By overriding specific methods, developers can customize the behavior of their daemons while benefiting from the built-in functionality of Net::Daemon.

Claude::Agent is a Perl SDK designed to facilitate the development of AI agents using the Claude Agent SDK, enabling seamless interaction with Claude's capabilities. This module allows developers to create agents that can perform tasks such as reading files, executing commands, and editing code, while providing features like streaming message iteration (both blocking and asynchronous), tool permission management, and session management for maintaining state across multiple interactions. With support for custom tool definitions and integration with the Model Context Protocol (MCP), Claude::Agent empowers users to build sophisticated applications that leverage AI functionalities efficiently and effectively.