CPANscan

Speak is a simple Perl module that turns text into spoken audio using Google’s TTS engine and plays it on your speakers, with support for multiple languages, optional persona voices served by an MCP TTS server, and flexible input sources such as a string, a file handle, or the clipboard. It is configured via environment variables or a small config file and can be muted by a flag or by placing a “shh” file in a standard location. The module exposes easy-to-call routines like speak() and say_persona() and can log activity to a file. Recent updates added the ability to save generated audio to a file via an output parameter or command line option and unified the say and speak commands. Basic dependencies include Clipboard, LWP::UserAgent, and URI::Escape and there are no known bugs reported by the author.

Perl::Critic::Policy::ErrorHandling::RequireCheckedIndirectResults is a Perl::Critic policy that catches cases where a subroutine forwards the result of a system call or an eval and a caller then drops that result, for example when a sub returns the value of close and the call site ignores it. Unlike checks that only look at the builtin call itself, this policy follows return values through named subs across files in a distribution and reports calls that are standalone statements whose results go nowhere. It covers the same builtins configured for InputOutput::RequireCheckedSyscalls plus eval blocks, honors files that use autodie or Fatal so builtins that already die are not reported, and supports the same functions and exclude_functions configuration. The policy ignores results that are assigned, tested, returned, passed on, originate from wantarray, come from methods or lexical subs, or involve string eval, and it registers package subs across the distribution to enable cross-file analysis. Initial release 0.001.

Perl::Critic::Policy::ControlStructures::ProhibitMutatingListFunctionsStricter is a Perl::Critic policy that helps prevent accidental modification of list elements when you use list-processing constructs like map and grep by flagging cases where $_ is changed either directly in the block or indirectly by a sub the block calls. It builds on the core ProhibitMutatingListFunctions check and extends it to recognize common mutating operations including substitutions and chomp or chop written as standalone statements, and it can track named subs in the same file or distribution that mutate $_ so you get warnings for those indirect mutations too. The policy respects the same configuration options for which list functions to check and avoids reporting changes that happen in contexts where $_ is not the caller’s or where a sub localizes $_. Enable this policy instead of the core policy to avoid duplicate reports. This is the initial release.

Game::RoyalUr is a Perl engine for playing and simulating the ancient Royal Game of Ur, providing a complete, rule-driven implementation suitable for building UIs, bots, or online play. It implements two modern reconstructions of the rules, "finkel" and "masters", lets you seed the dice so every game is reproducible, and records or replays entire games in a standard notation. The API gives you the side to move, the current roll, the set of legal moves, and commands to play, undo, resign, inspect the board and export a text record. The module enforces rule differences between variants and can be driven by real dice or by a deterministic seed, so it is useful both for deterministic testing and for live play. If you need a reliable programmatic representation of the Royal Game of Ur or want to integrate its rules and logging into a Perl application, this module provides the engine and supporting tools.

Game::Mahjong is a Perl engine that implements four-player Mahjong under the World Mahjong Organization competition rules (2006), providing a complete rule set including 144 tiles with flowers, chow/pung/kong claims, robbing the kong, the eighty-one scoring elements grouped into twelve grades, and the eight-point minimum to win. It ships with utility components for tile handling and notation parsing so you can list tile sets, convert tile ids to codes, check terminals, and parse human-readable hand strings, and it is the engine used by the online game at peer2peergames.com. The recent 0.02 update fixes several practical bugs and UI issues, including a decoding problem seen on an older Perl smoker, a tile-numbering and ordering bug in the rack, display and claim-marker problems when color is off, and more robust handling of command-line options.

IO::Compress::Lzop is a Perl module for producing lzop (.lzo) compressed data from your scripts, letting you write compressed output to files, filehandles, or in-memory buffers. It offers a simple one-shot function, lzop, for quick conversions and a full object interface that behaves like a regular writable filehandle so you can print, write, syswrite, seek forward, flush, and close compressed streams. Inputs and outputs may be filenames, filehandles, scalar refs, or lists and you can stream data, append to existing outputs, control header name and timestamp, create minimal files, and start new compressed streams on the fly. Errors are reported via $LzopError and the companion IO::Uncompress::UnLzop module handles reading. This module is a good fit when you need straightforward programmatic creation of lzop archives from Perl.

IO::Compress::Zstd is a Perl module for writing Zstandard (zstd) compressed data to files, filehandles or in-memory buffers, offering both a simple one-shot function zstd and a full object-oriented interface that behaves like a filehandle. It accepts filenames, filehandles, scalar refs, arrays or fileglob patterns as input and output, supports streaming, appending, and multiple-file compression, and exposes familiar methods such as print, write, syswrite, flush, tell, seek, newStream and close; errors are reported via $ZstdError. Compression level is configurable and defaults to 3 to match the zstd command line, and the module pairs with IO::Uncompress::UnZstd for reading. The project is actively maintained, recently bumped to version 2.225, and now requires Perl 5.8 or newer.

IO::Compress::Lzma is a Perl module for writing LZMA compressed data to files or in-memory buffers, offering both a simple one-shot function and a full object interface that behaves like a writable filehandle. It accepts filenames, filehandles, scalar or array references and supports streaming, appending, multiple input files, and starting new compressed streams, while exposing familiar operations such as print, write, syswrite, flush, tell, seek (forward only) and close. Common options include AutoClose, Append and a configurable LZMA filter object, and it pairs with IO::Uncompress::UnLzma for decompression. Use this module when you need to create .lzma output from scripts or pipelines and want easy, filehandle-like control over compression.

IO::Compress::Lzf is a small, easy-to-use Perl module for producing LZF-compressed output to files or in-memory buffers. It offers a handy one-shot function lzf for simple conversions and a filehandle-like OO interface so you can print, write, syswrite, flush, seek forward and close compressed streams just like an IO::File object. The module uses Compress::LZF internally but writes compressed data in the same file format as the lzf command-line utility so output is compatible with that tool, and a companion module IO::Uncompress::UnLzf provides the reader side. IO::Compress::Lzf accepts filenames, filehandles, scalar refs, arrays and fileglob mappings, supports streaming and appending and lets you start new compressed streams on the fly. The distribution is actively maintained with ongoing fixes and compatibility updates and as of the latest releases requires Perl 5.8 or newer and is at version 2.225 (October 2026).

Compress::Stream::Zstd is a lightweight Perl wrapper for the Zstandard compression library that makes it easy to compress and decompress in-memory byte buffers. It provides simple functions like compress($source [, $level]) and decompress or uncompress($source) that accept scalars or scalar references and return the processed bytes or undef on error. This module is a fork of Compress-Zstd with enhancements to make streaming compression and decompression more robust and to support use with IO::Compress::Zstd, and it exposes version and level constants such as ZSTD_VERSION_STRING and ZSTD_MAX_CLEVEL so you can query library capabilities. Use it when you need fast, modern compression in Perl with a straightforward API for buffer-oriented tasks.

IO::Compress is the umbrella Perl distribution for reading and writing compressed data in many common formats. The top-level IO::Compress module in this release is a stub that contains no code, but the package supplies the real functionality in submodules such as IO::Compress::Gzip, IO::Compress::Zip and their IO::Uncompress counterparts, plus helper modules like AnyUncompress and AnyInflate for automatic format detection. It offers both streaming and one‑shot interfaces, broad archive support including Zip/Zip64 features and extra fields, and compatibility with multiple compression algorithms including zlib/deflate, gzip, bzip2, lzma/xz and zstd, making it suitable for scripts and applications that need to compress, decompress or manipulate archives programmatically. The project is mature and actively maintained with extensive tests and interoperability fixes; recent updates include a fix to prevent inefficient or unbounded reading of gzip Name and Comment fields and the addition of a newStreamHook for stream handling.

Compress::Raw::Lzma is a low‑level Perl wrapper around the liblzma library that gives you direct, in‑memory access to LZMA/XZ compression and decompression routines. It exposes multiple encoder and decoder classes for different formats and use cases, including Easy, Alone, Stream and Raw interfaces, supports streaming via simple code and flush calls, and lets you compose filter chains (LZMA1/LZMA2, BCJ, Delta) and tune presets, dictionary size, checksums and memory limits for fine control. The module also exports liblzma constants and helper functions to query the library version, so it is ideal for developers who need to embed or script LZMA compression without the overhead of higher‑level IO layers and for building custom compression tools. It is actively maintained and recent releases keep compatibility with newer xz/liblzma releases; as of mid‑2026 the project set Perl 5.8 as the minimum supported version and continues to receive small bug fixes and documentation/security additions. If you only need simple file compression you may prefer the higher level IO::Compress wrappers, but if you want direct control over filters, streaming and memory behavior this module is a solid choice.

Compress::Raw::Bzip2 is a thin, low-level Perl binding to the bzip2 C library that lets you compress and decompress data in memory. It supplies compression and decompression objects with methods such as bzdeflate, bzflush, bzclose and bzinflate, constructor options to control output appending, block size and work factor, and it returns native bzip2 status codes so you can handle streaming and errors explicitly. The module is the backend used by IO::Compress::Bzip2 and IO::Compress::Bunzip2 but can be used directly for simple or performance-sensitive tasks that need direct access to bzip2 features, and it also exposes the library version and the standard bzip2 constants.

Compress::Raw::Zlib provides Perl programs with a thin, low-level interface to the zlib or zlib-ng compression libraries so you can compress and decompress data in memory with fine-grained control. It exposes Deflate and Inflate objects with options for compression level, window bits, strategies, dictionaries and buffer sizing, plus methods to flush, reset and tune streams and to recover from partial corruption. The module also offers checksum helpers like adler32 and crc32 and combine functions, and a LimitOutput mode to avoid unbounded memory growth when inflating pathological streams. This is a good choice when you need performance or detailed control over zlib behavior; for higher-level file and archive handling you may prefer the IO::Compress/IO::Uncompress or Archive::* modules. The distribution normally ships with a private zlib copy but can be built against system zlib or zlib-ng and includes helpers to detect which library was used.

Net::CalDAV::FindEntry is a small Perl module for querying CalDAV calendars to find events that overlap a given time span. It connects to a CalDAV server using your credentials and calendar URL and returns matching events via methods such as get_events or GetEventLinksEx, with precise time-range filtering that does not truncate timestamps to whole days. It also provides GetEventsEx to request the server expand recurring events into concrete occurrences when the CalDAV server supports RFC 4791. The module is useful for scripts and integrations that need accurate event lookups for scheduling, notifications, or display, and the source is available on GitHub; note that recurrence expansion requires CalDAV server support for RFC 4791.

Pheno::Ranker is a Perl toolkit for computing semantic similarity between phenotypic profiles stored in PXF/BFF formats and in plain JSON or YAML, producing pairwise similarity matrices as text files. It is designed for researchers and bioinformaticians who need to compare individuals or cohorts using GA4GH-compatible phenotype data, and it includes a command-line interface for straightforward use. You instantiate the object with your reference files and call run to generate the outputs, and full documentation and a citation are provided for users who incorporate it into published work.

MooseX::NonMoose makes it straightforward to subclass traditional non‑Moose Perl classes with Moose by handling the tricky plumbing required to merge Moose's object system with legacy constructors and inheritance. It installs a compatible constructor that ensures BUILD methods run and can inline an optimized constructor at make_immutable time, lets you adapt the argument list passed to the superclass via a FOREIGNBUILDARGS hook, and even accepts a nonstandard parent constructor name through the extends call. You can apply it directly or as metaclass traits so classes that inherit from Moose and non‑Moose parents behave consistently. Note the usual caveats from the author: your instance representation must match Moose's (normally a hashref), changing @ISA after extends can interfere with constructor wrapping, and completely overriding new in the subclass is not supported. If you want to wrap legacy object classes with Moose attributes and modifiers without handcrafting constructors this module removes most of the hassle.

HTML::FormHandler is a Moose-based Perl framework for declaring, validating and rendering forms in a clean, reusable way. It separates form structure from presentation so you can define fields, validators and dependencies as Perl classes or via dynamic field lists and then render them with built-in or custom renderers. The module handles both database-backed workflows, with DBIx::Class integration that can inflate, validate and update rows, and non-database or structured data input. You drive processing with a simple process/run API that accepts params, performs validation, produces fill-in-form and value hashes, and reports errors, and you get features such as compound and repeatable fields, defaults and activation control, cross-field validation hooks and i18n support. HTML::FormHandler is commonly used in Catalyst and template-driven web apps but works in any Perl program. For new projects the authors recommend evaluating Data::MuForm, which is the successor and may offer improved speed or ergonomics.

XML::LibXML is the primary Perl binding to the libxml2 library that gives you fast, full-featured XML and HTML parsing with DOM, SAX and pull-reader APIs plus XPath, DTD, RelaxNG and W3C Schema validation. It lets Perl programs build, query and modify XML trees, evaluate XPath expressions, stream large documents with a reader, and integrate with libxml2 features such as canonicalization and custom input callbacks. The module handles character encodings for in-memory nodes while I/O operations follow the document encoding, so you should feed parsers and serializers raw byte streams and use binmode on filehandles to avoid double conversion. It supports Perl threads with a conservative per-thread default and an optional shared-object mode, and exposes a global external entity loader mechanism whose semantics and lifecycle have been tightened in recent releases. The latest updates fixed a crash when managing global entity loaders, restored the intended no-network/entity-loader contract across schema and RelaxNG parsing, and cleaned up various memory and safety issues, making this a robust choice if you need production-grade XML processing from Perl.

XML::SAX::Writer is a SAX2-aware XML serializer for Perl that turns SAX events into well-formed XML and gives you flexible control over where and how that XML is emitted. It can write to a filename, a filehandle, a scalar or array reference, or to a custom Consumer object so you can plug in any output sink you like. The writer supports configurable character escaping and separate comment escaping, lets you choose the quote character used for attributes, and uses a pluggable Encoder interface for character set conversion with sensible defaults of UTF-8 for input and output. The module is designed to be subclassed for custom output formats and to accept custom Consumers and Encoders, and recent maintenance switched encoding support to the modern Encode module while cleaning up regex issues. Do note that full UTF-16 handling and some formatting options are still listed as TODO items.

MCE is a Perl framework for parallel processing that spawns a pool of workers and feeds them chunks of input so you can harness multiple CPU cores without managing individual forks or threads. It provides a core API plus higher-level models for common patterns like parallel loops, maps, greps and multi-stage flows and streams, and includes utilities for mutexes, signals and worker coordination. Add-on modules supply channels, queues, relays and other communication patterns so workers can exchange data or preserve output order, making MCE a strong fit for tasks such as large log file parsing, numeric computations and other data-parallel workloads. The documentation notes a Windows-specific performance caveat for certain in-memory file parsing approaches beyond four workers and suggests alternative techniques. MCE requires Perl 5.8 or later and ships with examples and source on GitHub.

Task::Kensho::CLI is a meta-distribution that bundles and recommends a small, curated set of Perl modules useful for building and working with command-line tools rather than providing library code itself. It groups well-known utilities such as App::Ack for fast text searching, App::Nopaste for easy pastebin access, Module::CoreList for checking what shipped with a given Perl, and Reply for an interactive REPL, and it is part of the larger Task::Kensho collection promoting "Enlightened Perl" practices. Installation is interactive so you can pick which subtasks to install and modern CPAN clients like cpanminus support this via cpanm --interactive, and recent releases across the Task::Kensho family have refreshed recommendations to reflect newer tooling such as improved REPLs and async libraries. This bundle is intended as a sensible starting point and not a comprehensive prescription, so you may prefer different modules depending on your project.

App::Ack is an internal helper module for the ack command line search tool that groups small, ack-specific utilities used by the main program. It provides routines for emitting warnings and dying with ack-style messages, printing the main help and subpages for file types, colors, and RGB, returning version information, detecting whether input is coming from a pipe, deciding the correct exit code based on match counts, and showing filetype associations for a given filename. This module is intended as an implementation detail of ack itself, so it is primarily useful if you are developing, extending, or embedding ack rather than if you are looking for a standalone, general-purpose library.

Module::CoreList is a lookup service for which Perl modules and module versions shipped with each Perl release, available as a programmer API and a command line tool called corelist. It answers questions like when a module first appeared in core, whether a given module and version are bundled with a particular Perl, which modules match a pattern, and when modules were deprecated, removed, or changed between releases. The module exposes ready-made data structures such as %Module::CoreList::version and %Module::CoreList::delta that map Perl releases to module versions, release dates, deprecations, upstream and bug tracker information. It is handy for maintainers and developers who need to determine compatibility or the historical status of a module across Perl versions. Coverage includes all stable Perl releases since 5.6 and development releases since 5.9, with earlier 5.000-era coverage limited, and it is maintained by the Perl 5 Porters under the same license as Perl.

Task::Kensho::Config is a small CPAN "task" that bundles a curated set of configuration-handling modules recommended by the Enlightened Perl community. It does not add runtime code but makes it easy to install sensible defaults for reading and handling configuration files, including Config::Any for transparently loading many file formats, Config::General for classic config file needs, and JSON::MaybeXS which selects a modern, fast JSON backend. You can install the subtask by itself or let the Task::Kensho installer prompt you for subtasks and their modules, and cpanm users should run with --interactive to choose options. This bundle is meant as a practical starting point for good Perl practice rather than a mandatory standard and it evolves over time, for example JSON::MaybeXS was added to the recommendations to prefer current JSON implementations.

Config::Any is a plugin-based loader that lets Perl programs read configuration from many common formats through a single, simple interface. It can load XML, YAML, JSON, INI, Apache-style and even Perl config files and returns the parsed data so your application can treat all formats the same. You call load_files or load_stems and optionally restrict parsers by file extension, force a particular parser, apply an in-place filter, or return a flattened filename-to-data hash, while format support is provided by separate parser modules discovered automatically via Module::Pluggable::Object. This makes it handy when deploying on varied systems or handing configs to sysadmins who prefer different file formats, and the module documents which extra parser libraries are needed for each format. Recent maintenance refreshed the docs about required parser modules and improved version checks and error handling for various loaders.

Config::General is a flexible Perl module for reading, writing and manipulating configuration files in an Apache-style or simple key/value format. It parses nested and named blocks, repeated options as arrays, here-documents, C-style comments, multiline values and include directives, and returns the result as a native Perl hash so your program can work with configuration data directly. The parser is highly configurable with options for case normalization, variable interpolation, include search paths and globbing, merging or forcing array behavior, flag-bit expansion, default values and custom normalization, and it can save the parsed structure back to disk or produce a config string. You can use it procedurally via ParseConfig or in an object oriented way, extend parsing with hook plugins, and even tie the resulting hash to specialized storage. Be aware that comments are discarded when saving, including the same file multiple times can lead to recursion, and a few compatibility options such as SlashIsDirectory or UTF8 handling should be used with care.

DBI is the standard database access layer for Perl that gives you a single, portable API for connecting to and working with many different databases via driver modules. It handles connecting, preparing and executing SQL, placeholders and bound parameters, fetching rows as arrays or hashes, transactions, quoting and identifier quoting, and offers utilities for metadata, tracing, caching and callbacks to customize behavior. DBI itself is an interface or "glue" layer and the actual database work is performed by DBD drivers, so exact features and behavior depend on the driver you use and you should consult driver documentation and keep versions aligned. Mature and widely used, DBI makes it easy to write portable Perl code that talks to diverse database engines while still allowing driver-specific extensions when needed.

DBIx::Class::Schema::Loader automates creating a DBIx::Class schema from an existing relational database by inspecting tables and inferring columns, primary keys, unique constraints and relationships. You can use it to generate Perl result classes on disk with the bundled dbicdump tool or produce schema classes in memory at runtime via make_schema_at, and it supports the DBI storage model with many common DBD drivers such as DBD::Pg, DBD::mysql, DBD::SQLite and DBD::Oracle while allowing custom loader options and vendor-specific subclasses. The module provides conveniences like dump_to_dir to write files, loader_options to tune behavior, and rescan to add newly created tables to a loaded schema, and it replaces the older DBIx::Class::Loader. It requires DBIx::Class 0.08127 or later and is primarily intended for generating or dumping schema classes rather than heavy dynamic generation in production.

SQL::Translator is a Perl toolkit for reading vendor-specific SQL table definitions and converting them into other SQL dialects and formats such as ER diagrams, HTML or POD documentation, XML, and Class::DBI classes. It separates parsing and producing through an intermediate schema object so you can mix and match built-in or custom parsers, producers, and filters to manipulate the schema before output. The module accepts non-SQL inputs like spreadsheets and delimited text, and offers options for identifier quoting, name formatting, adding DROP TABLE statements, and validating the schema. You drive it with a single translate call that runs the parser, any filters, and the chosen producer, and you can configure behavior via constructor arguments or accessor methods. It focuses on definition statements such as CREATE and ALTER and does not handle data manipulation statements like INSERT, UPDATE, or DELETE, making it a good fit for migration, documentation, and code generation workflows.