CPANscan

The Perl module `Business::Tax::US::Form_1040::Worksheets` provides essential functions for calculating and managing the worksheets associated with U.S. IRS Form 1040, specifically targeting the Social Security Benefits Worksheet and the Qualified Dividends and Capital Gain Tax Worksheet. It allows users to compute taxable social security benefits and the necessary data for completing these worksheets, facilitating accurate tax reporting for filing years 2022, 2023, and 2024. The module includes functions for pretty-printing results for easier transcription and ensures monetary values are formatted to two decimal places. A noteworthy recent change in version 0.07 updates the module to accommodate tax year 2024, reflecting the latest IRS guidelines. Users are advised to verify the accuracy of calculations independently, as they have not been reviewed by tax authorities.

Geo::Address::Parser is a Perl module designed for lightweight parsing of country-aware addresses from flat text input. It supports address formats for the US, UK, Canada, Australia, New Zealand, and recently added France, allowing users to extract components such as name, road, city, region, and country using country-specific regular expressions. The module can be easily configured at runtime through environment variables and configuration files, enhancing its flexibility. With version 0.08, the latest update introduced support for parsing French addresses, further expanding its utility for international applications. This module is ideal for developers needing to process and validate address data efficiently across multiple countries.

App::PerlPackage2PlantUMLClassDiagram is a Perl module designed to generate class diagrams in PlantUML format from Perl packages, facilitating the visualization of object-oriented structures in Perl applications. This module serves as the backend for the package2plantumlclassdiagram tool, making it easier for developers to create and maintain UML diagrams directly from their codebase. Notably, in the recent update (version 0.03), the module addressed compatibility issues with Perl 5.40+ by fixing a "Downgrading a use VERSION declaration" error and transitioned its continuous integration from Travis CI to GitHub Actions, enhancing its development workflow.

Data::Path::XS is a high-performance Perl module designed for efficient access to deeply nested data structures using path-based syntax. It offers multiple APIs tailored for different use cases, including a Keywords API for near-native performance, a String API for general-purpose access, an Array API for pre-parsed paths, and a Compiled API for maximum speed with repeated access patterns. The module supports features like autovivification, negative array indices, and protection against leading-zero and integer overflow issues. With benchmarks showing it to be 10-25 times faster than pure Perl for deep paths, Data::Path::XS is an excellent choice for developers needing rapid and flexible data manipulation. The initial release laid the groundwork for these capabilities, establishing a robust foundation for future enhancements.

EV::Future is a high-performance Perl module designed for managing asynchronous control flow with minimal overhead, leveraging the EV event loop. It allows developers to execute tasks in parallel, with a limit on concurrent tasks, or in a sequential series, all while ensuring efficient memory management and error handling. Each task is defined as a code reference that must call a provided "done" callback upon completion, with built-in protections against double-calling this callback in safe mode. For performance-critical applications, an unsafe mode is available that bypasses certain safety checks, significantly boosting execution speed. The module is particularly useful for applications requiring efficient task management without the complexity of traditional threading models. The initial release in March 2026 introduced core functionalities, including support for parallel execution and cancellation capabilities.

Getopt::Guided is a Perl module designed to provide a robust implementation of the POSIX `getopts` utility for parsing command-line options, adhering closely to POSIX guidelines. Unlike the core Perl `Getopt::Std` module, which processes options in a single call, Getopt::Guided offers an iterator-based approach, allowing for more flexible and user-friendly option handling. It supports various option types, including flags and option-arguments, and provides features such as error handling that restores the original argument list and warns users about issues. Recent updates in version 3.1.0 introduced new functions like `readopts()` for reading default options from a configuration file and `program_name()` for better program identification, along with exporting common exit status constants, enhancing the module's usability and functionality.

Langertha::Knarr is a Perl module designed to serve as a multi-format proxy for large language models (LLMs), including OpenAI, Anthropic, and Ollama, while integrating Langfuse tracing for enhanced observability. Released in its initial version 0.001, this module supports a passthrough mode that allows for seamless tracing of requests, and it can operate within a Docker container, automatically detecting environment settings. Additionally, it features a command-line interface (CLI) that facilitates various operations such as starting the service, managing containers, checking models, and initializing configurations. This module is particularly useful for developers looking to implement LLMs with robust tracing capabilities in their applications.

Daje::Database::Model is a Perl module designed to facilitate the creation and management of database classes within the Daje framework. It provides a structured approach to database interactions, allowing developers to define models that represent their data and handle database operations efficiently. The module requires Perl version 5.40 or higher and is built with experimental features. Notably, in version 0.25, released on March 3, 2026, a base class for defaults was added, enhancing the module's functionality and usability. This library is open-source and can be freely modified under the same terms as Perl itself.

The Google::RestApi module provides a comprehensive framework for interacting with various Google APIs, including Drive, Sheets, Calendar, Gmail, Tasks, and Docs. It simplifies the process of making API calls by managing authentication, request formation, and response handling, allowing developers to focus on their application logic rather than the intricacies of the Google API. Users can create a new RestApi object with configuration options such as authentication details and timeouts, and then utilize specific API modules to perform operations like file management in Google Drive, spreadsheet manipulation in Google Sheets, event scheduling in Google Calendar, email handling in Gmail, task management in Google Tasks, and document editing in Google Docs. The module also supports advanced features like chained API calls and pagination handling, making it a powerful tool for developers looking to integrate Google services into their Perl applications.

Affix is a powerful Foreign Function Interface (FFI) extension for Perl that enables seamless integration with native libraries written in languages such as C, Rust, and Fortran, without the need for XS code or complex compiler management. It provides a high-performance bridge to native software, allowing developers to bind and call functions, work with C structs, manage raw memory, and perform pointer arithmetic with ease. Affix features an extensive type system that supports various data types, including primitives, nested structs, and SIMD vectors, while leveraging a Just-In-Time (JIT) compilation engine for optimized performance. With built-in memory management, error handling, and library discovery capabilities, Affix simplifies the process of interfacing Perl with external libraries, making it an ideal choice for developers looking to enhance their Perl applications with native functionality.

The Clone module in Perl provides a powerful and efficient way to create deep copies of complex data structures, including nested hashes, arrays, scalars, and objects. By using the `clone()` function, developers can duplicate data while ensuring that changes to the cloned structure do not affect the original, making it particularly useful for managing state in applications. The module handles circular references and tied variables gracefully, preserving their behavior in the cloned copies. Recent updates in version 0.48 have optimized performance for critical paths and improved compatibility with various data types, including fixes for cloning issues related to Math::BigInt::GMP objects and threads::shared data structures. With its C-based implementation, Clone is designed for speed, making it an excellent choice for applications that require rapid data manipulation.

Text::SlackEmoji is a Perl module designed to facilitate the mapping of Slack emoji strings, such as ":disappointed_relieved:", to their corresponding Unicode representations. By utilizing this module, developers can easily integrate Slack emoji into their applications, ensuring that messages retain their intended visual expressions across different platforms. The module provides a straightforward interface with methods like `emoji_map`, which returns a hash reference of emoji mappings, and `load_emoji`, allowing for dynamic updates to the emoji data without reloading the module. The latest version, 0.011, includes updates for Unicode 16 and compatibility with Perl v5.42, ensuring that users have access to the most current emoji standards.

The `Alien::libpq` Perl module is designed to facilitate the integration of the PostgreSQL client library, libpq, into Perl applications. It automatically detects and utilizes the system-installed version of libpq if available; otherwise, it can download and build the library from source, ensuring that developers have access to the necessary components for PostgreSQL connectivity. By leveraging this module, users can easily configure their build processes with the appropriate compiler flags and library paths, streamlining the development of database-driven applications. A noteworthy recent update in version 0.02, released on March 3, 2026, introduced dynamic detection of the latest stable PostgreSQL version, enhancing the module's usability and ensuring compatibility with current PostgreSQL releases.

Mail::BIMI is a Perl module designed for the retrieval, validation, and processing of Brand Indicators for Message Identification (BIMI) records. It facilitates the integration of BIMI into email systems by allowing developers to verify the presence and correctness of BIMI records associated with email messages, ensuring that messages are authenticated and comply with BIMI standards. The module requires objects from Mail::DMARC and Mail::SPF for validation and can handle various attributes related to BIMI processing, such as domain and selector information. A noteworthy recent change in version 3.20260302 includes an update to the Certificate Authority (CA) list to incorporate ssl.com, enhancing the module's capabilities in handling certificate validations.

EV::Etcd is a high-performance asynchronous client for etcd v3, leveraging native gRPC and the EV/libev event loop for efficient communication. It allows developers to interact with etcd's key-value store using non-blocking operations, enabling features such as asynchronous key-value storage (put/get), watching for changes, and managing leases and distributed locks. The module supports comprehensive authentication and authorization mechanisms, making it suitable for secure applications. Additionally, it provides cluster management capabilities, leader election support, and maintenance operations, all designed to facilitate robust and scalable distributed systems. With its straightforward API, EV::Etcd simplifies the integration of etcd into Perl applications, enhancing their performance and responsiveness.

The Time::OlsonTZ::Data Perl module provides a comprehensive interface to the Olson timezone database, encapsulating essential timezone data and binary tzfiles for various regions. It allows users to access key functionalities such as retrieving the current version of the database, obtaining canonical and link timezone names, and understanding the relationships between timezones and countries. With functions like olson_tzfile, users can easily obtain the pathname of the binary tzfile for a specified timezone, ensuring accurate and up-to-date timezone information. This module is designed to be regularly updated to reflect changes in timezone rules and data, making it a vital tool for applications that require precise timezone management.

The Sys::Async::Virt module provides an asynchronous interface for interacting with LibVirt services through its remote protocol, enabling Perl clients to manage virtualized environments effectively. Built on the LibVirt API, this module allows users to connect to hypervisors, list and manage domains, and handle various virtualization tasks using an object-oriented approach. It supports asynchronous operations through the Future::AsyncAwait framework, allowing for non-blocking calls and efficient handling of remote procedure calls (RPCs). With features like event subscriptions for domain and network changes, as well as comprehensive methods for querying and manipulating virtual resources, Sys::Async::Virt is an essential tool for developers working with virtualization in Perl.

The `Protocol::Sys::Virt` Perl module provides an abstract implementation of the LibVirt protocol, enabling the development of client and server components for managing virtualization technologies. Unlike its predecessor, `Sys::Virt`, this module offers a truly asynchronous interface, addressing the limitations of blocking API calls inherent in the original design. This is particularly beneficial for developers looking to implement non-blocking operations in their applications. The latest version, v12.1.0, continues to enhance compatibility with the LibVirt project, ensuring that users can leverage the latest features and improvements from the underlying protocol.

Date::Manip is a comprehensive Perl module designed for effortless date and time manipulation, catering to a wide range of operations such as comparing dates, calculating time intervals, and parsing international date formats. It supports the Gregorian calendar and accounts for daylight saving time, making it versatile for various applications. Users can input dates in numerous formats, extract specific information, convert between time zones, and manage recurring events with ease. With both functional and object-oriented interfaces available, Date::Manip is particularly recommended for its object-oriented approach, which unlocks the full potential of its extensive capabilities. Whether you need to perform simple calculations or complex date manipulations, Date::Manip provides a robust solution for all your date-related programming needs.

The `String::Redactable` Perl module provides a mechanism for handling sensitive strings, such as passwords, by automatically redacting them to prevent accidental exposure in logs or outputs. When a `String::Redactable` object is created with sensitive text, it displays as a placeholder string (e.g., "<redacted string>") when used normally, while the actual content can only be accessed through the `to_str_unsafe` method. This design helps mitigate the risk of unintentionally revealing sensitive information, as the original string is XOR-encrypted with a transient key that is not stored with the object. Additionally, the module includes features to resist serialization, ensuring that sensitive data remains protected even when serialized. Overall, `String::Redactable` is a useful tool for developers looking to enhance the security of sensitive string handling in their applications.

MooX::Cmd is a Perl module designed to simplify the creation of command-line interface (CLI) applications using the Moo object system. It allows developers to organize commands and subcommands in a hierarchical structure, mirroring the package structure of the application. Each command is defined as a class with an `execute` method that receives parameters for the command instance, the arguments passed to it, and the chain of commands leading to it. This structure enables the easy handling of complex command trees, where only the most specific command's `execute` method is invoked, while also providing access to attributes and options defined at higher levels in the command hierarchy. With MooX::Cmd, developers can efficiently build modular and organized CLI applications that are easy to maintain and extend.

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.

Aion::Emitter is a Perl module that implements the Event Dispatcher pattern, allowing for efficient event handling and listener management within applications. By defining events through event object classes, it enables the registration of listeners that respond to specific events using the "#@listen" annotation. The module provides an `emit` method to trigger events, invoking all associated listeners, and allows for targeted event emissions through an optional key parameter, facilitating more granular control over event handling. This makes Aion::Emitter particularly useful for applications that require dynamic interaction between components, such as in GUI applications or complex systems where events need to be dispatched to specific listeners based on context.

DBIx::Class::Async is an experimental Perl module designed to provide a non-blocking, multi-worker asynchronous interface 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 heavy database interactions. The module integrates seamlessly with various event loops, such as IO::Async, and supports modern asynchronous programming patterns, including Futures and async/await syntax. With features like automatic serialization of results, error handling, and optional caching, DBIx::Class::Async is ideal for building responsive applications that demand efficient database access without compromising performance.

The `Data::Dumper::Interp` Perl module enhances the output of `Data::Dumper` for better readability and human consumption by interpolating variable values directly into strings. It provides a variety of functions to format scalars, arrays, and hashes, allowing for clear visualization of complex data structures. Key features include the ability to display references with abbreviated addresses, stringify objects, and handle Unicode characters gracefully. The module also supports debugging options, such as labeling interpolated values and showing spaces visibly. Recent updates include a reversion of changes to the `:all` import tag, ensuring it no longer sets `$Carp::RefArgFormatter`, along with minor documentation tweaks and bug fixes. This makes `Data::Dumper::Interp` a powerful tool for developers needing to debug and present data structures in a more accessible format.

SPVM is a statically typed programming language that features a Perl-like syntax, designed to enhance performance and type safety while maintaining familiarity for Perl developers. Although it is still in development and has not yet reached a stable release, SPVM allows users to execute programs, generate executable files, and call SPVM methods from Perl, making it versatile for various programming tasks. With support for native threads, ahead-of-time and just-in-time compilation, and a rich set of features including static types and C/C++ bindings, SPVM aims to provide high performance and robust functionality for developers looking to leverage Perl's syntax in a more structured environment.

The `Unicode::UTF8` Perl module provides essential functions for encoding and decoding UTF-8, adhering to Unicode standards. It allows developers to easily convert between octet strings and character strings using the `decode_utf8` and `encode_utf8` functions, while also offering customizable error handling through optional fallback mechanisms. Additionally, the module includes a `valid_utf8` function to check the integrity of UTF-8 sequences. Recent updates have significantly improved performance, with a notable rewrite of the UTF-8 validator that enhances decoding speed by up to 10 times compared to previous implementations. This makes `Unicode::UTF8` a powerful tool for handling UTF-8 data efficiently in Perl applications.

HTTP::Handy is a lightweight, single-file HTTP/1.0 server designed for Perl 5.5.3 and later, ideal for personal use, local tools, and rapid development. It implements a subset of the PSGI specification, allowing developers to create simple web applications with minimal setup—just copy the file into your project directory. The server supports basic GET and POST methods, serves static files with MIME type detection, and includes utility functions for URL decoding and query parsing. Notably, it features an access log in LTSV format and allows configuration of the maximum POST body size. With no external dependencies, HTTP::Handy is perfect for quick prototyping and local development environments. The first release on CPAN marks its availability for broader use, emphasizing its simplicity and portability.