CPANscan

AnyEvent::Impl::Prima is a tiny adapter that lets AnyEvent-based timers and callbacks run inside a Prima GUI application by using Prima's own event loop. With this module you can write asynchronous code with AnyEvent semantics and simply call Prima->run to drive both your GUI and AnyEvent timers or watchers, so you do not need a separate event loop or threads to mix GUI and async tasks. It is lightweight and easy to drop into existing Prima programs, making it useful for desktop apps that need network I/O, timers, or other asynchronous hooks managed by AnyEvent. The most recent 0.03 release fixes the test suite to accommodate the deprecation of the single-quote as a package separator.

IO::Stty is a Perl module and command-line utility that implements a POSIX-compatible stty for inspecting and changing terminal line settings from Perl or a shell, letting you query and restore modes on any filehandle such as STDIN. It covers the usual stty operations like toggling echo, switching between raw and cooked modes, adjusting parity, character size, flow control and baud rates, and setting special control characters, and it provides a stty() function for programmatic use plus helpers such as a parser for special-character notations. The bundled stty.pl supports common flags like -a and -g and the module is designed to work with IO::File even though it was not specifically tailored to it. The author notes it is not optimized for speed and advises caution because terminal parameters are low-level and easy to misconfigure, but for tasks like password input, tty testing, or saving and restoring terminal state IO::Stty gives a compact, familiar interface without calling the external stty program.

DB::Handy is a self-contained, pure-Perl embedded relational database that stores tables as fixed-length binary flat files and exposes a familiar DBI-like interface so you can use connect, prepare, execute and fetchrow_hashref without a separate server or XS modules. It implements a robust subset of SQL including joins, subqueries, aggregates, GROUP BY, ORDER BY, LIMIT and basic single-column indexes, and also offers a lower-level engine API for direct file-based operations. Because it has zero external dependencies and runs on very old Perls it is a good fit for small applications, scripts, testing, portable deployments and situations where you want simple relational storage without installing a full database. Note the important design choices and limits: there is no transaction support or AutoCommit control, VARCHAR values are stored as fixed 255-byte fields, there is no BLOB/CLOB support, column order in array fetches is alphabetical, and it is not usable as a DBI driver. This is the initial 1.00 release on CPAN.

Net::Whois::Raw is a Perl library for fetching WHOIS data about domain names and IP addresses, handling the quirks of many registries so you do not have to. It can follow recursive referral chains, perform some queries over HTTP for registries that require it, and supports IDN/punycode and IPv6 lookups. The module offers optional caching, configurable timeouts, source IP selection, result post‑processing hooks and flags to strip boilerplate or detect “not found” responses, and it exposes lower‑level get_whois modes to return the first, last or all recursive responses. It is actively maintained with frequent updates to WHOIS server mappings and not‑found patterns; the latest release corrected the whois server for the .in.net zone. Be aware that registrars forbid bulk automated querying and removal of copyright disclaimers, and the module can throw exceptions on connection or rate‑limit errors so caller code should handle those.

Dist::PolicyFiles is a lightweight Perl utility for quickly creating standard policy documents for a distribution, namely CONTRIBUTING.md and SECURITY.md, so you can ship clear contributor and security guidance without hand-writing files. You use it via a Dist::PolicyFiles object or the included dist-policyfiles command, supplying your GitHub login and module name and optionally email, full name and output directory, and it will fill templates for CONTRIBUTING.md and generate a SECURITY.md using sensible defaults and Software::Security::Policy::Individual integration. The module can auto-discover your name and email from SSH config, lets you supply a custom template for the contribution file, and builds sensible GitHub URLs by turning Perl module names into repository names with optional prefixing and lowercasing. If you want a small, configurable way to add polished contributor and security policy files to a repo or distribution, this module is a good fit. The latest release focused on improving tests and finishing the documentation.

Test::Mockingbird is a Perl testing utility that helps you isolate and inspect code by replacing or wrapping module methods and injecting fake dependencies. You can mock a method with a replacement subroutine or create lexically scoped mocks that automatically revert when a guard object is destroyed. Spies record calls and arguments while still running the original method so you can assert interaction patterns. The module also supports injecting mock objects into a module's dependencies and provides unmock and restore_all functions to revert changes globally or by package. Shorthand forms for specifying package::method are supported to make tests concise. It is designed to simplify unit testing and interaction verification, and it is provided as-is without warranty with bug reporting handled via RT.

Unicode::UTF8 is a compact Perl utility for reliably converting between UTF-8 octet sequences and Perl character strings, offering encode_utf8, decode_utf8 and a valid_utf8 checker with optional callback hooks for custom error handling. By default it replaces malformed sequences or unrepresentable code points with the Unicode replacement character U+FFFD and integrates with Perl warning categories so you can make encoding problems fatal during development. The module emphasizes correct Unicode behavior and clearer diagnostics than Perl's Encode module, preserves taintedness, detects inconsistencies in Perl's internal wide-character representation, and claims much faster performance in benchmarks. Use it when you need a standards-focused, high-performance UTF-8 encoder/decoder in Perl with flexible error handling.

Apache2::API is a compact framework that wraps and simplifies the mod_perl Apache2 API so you can write HTTP handlers more productively. It centralises common tasks such as building and sending replies with consistent JSON error formatting, managing request and response objects, logging, header and date handling, language/localisation support, on-the-fly compression based on configurable thresholds, JSON encode/decode, base64 and URL encoding, UUID generation and Apache-style password hashes, plus helper access to Apache constants and handler management. The module is aimed at developers working under mod_perl who want a higher-level, well-documented façade over the sprawling Apache2 interfaces to reduce boilerplate and error handling. Recent releases include better request parsing and wider localisation coverage, and the 0.5.1 update specifically improves acceptance of application/*+json content types to better support modern JSON-based APIs.

App::git_log_ch_usrdata is a compact command-line tool for fixing the name and email recorded in a Git repository's commit history; it rewrites author and committer identity across commits so you can correct typos, replace old addresses, or consolidate multiple identities into one. The tool is aimed at developers and repository maintainers who need to update historical metadata rather than just new commits, so it is most relevant when you are prepared to rewrite history on branches where that is acceptable. The most recent release cleaned up and completed the documentation and added and reorganized author and release tests, making the utility easier to use and more robust.

AnyEvent::I3X::Workspace::OnDemand is a helper for the i3 window manager that provides activity‑style workspace groups and on‑demand layout loading. It listens for i3 tick events named group:name and, when triggered, renames your current workspaces into a former_group namespace and creates the workspaces you have defined from JSON layout files in your i3 config. You can define per‑group and per‑workspace layouts, add "swallow" rules that launch or place applications when a layout is applied, and hook into workspace events so your environment is composed automatically when you switch activities. The module is built on AnyEvent::I3 so it works asynchronously and offers convenience methods to run i3 commands, subscribe to events, add swallow rules, and enable debugging, making it a good fit if you want to manage sets of windows and start apps automatically when switching between work modes.

Net::Jabber::Bot is a Moose-based Perl class that makes it easy to build XMPP/Jabber bots without deep protocol knowledge by letting you supply server credentials, a simple map of forum triggers, and two callbacks for handling incoming messages and periodic background work. The module handles connecting to chat rooms and users, sending group and personal messages, and provides built-in safety features such as configurable messages-per-second and messages-per-hour limits, maximum message size with automatic chunking, per-forum aliases and a join grace period to avoid reacting to history, and options to ignore server or self messages so you do not accidentally flood or loop. It also supports TLS/SSL configuration including custom CA bundle paths and certificate verification, and includes helpers for presence, roster and simple reconnection logic. Recent releases fixed newline handling in outgoing messages and improved TLS/CA handling and Moose integration. Be aware that some join-failure reporting is limited and disabling safety features can risk unwanted behavior, so keep safety mode enabled until you are confident.

Net::Ident is a compact Perl library for performing ident lookups defined by RFC1413 so you can ask the remote end of a TCP/IP connection which user or ID owns that connection. It offers a simple synchronous API that accepts a connected socket or packed sockaddr pair and returns the remote ID, plus a nonblocking asynchronous object interface you can integrate with select, and optional convenience methods that add ident_lookup to FileHandle or Apache connection objects. Because it uses the ident protocol it requires the remote host to run an ident daemon and that daemon may return opaque IDs for privacy, so results are useful for logging or supplemental access checks but are not guaranteed for every connection. The module is actively maintained and the recent 1.26 release fixes a number of bugs in the async path including a sysread EOF issue that could cause an infinite loop and improves RFC1413 parsing and async reliability.

Regexp::Parser parses Perl regular expressions into an object tree so you can inspect, walk, transform, or reserialize them programmatically. It yields node objects as it parses, provides a walker/iterator to traverse the tree, and can produce a visual string or a real qr// Regexp from the parsed structure while reporting detailed errors and warnings. The module includes support for named character escapes and a handler system for subclassing so you can add analyses or transformations such as min-length checks, character-class operations, or custom rendering. Be aware it parses regex syntax rather than full Perl so variable interpolation in literal strings can be misinterpreted, and early documentation was incomplete though the project has been actively maintained. Recent versions add modern Perl regex features including \K, \R, \h/\H, \v/\V, named captures and backreferences, possessive quantifiers, newer charset flags and caret-reset syntax, and raise the minimum Perl requirement to 5.16.

XML::Parser is a mature Perl interface that makes it easy to parse XML by wrapping the fast Expat library and exposing both high level styles and low level event handlers. You can feed it strings, files or streams and choose a style such as Tree to get a nested parse tree, Subs to dispatch element names to package subs, Stream for streaming canonical output, Debug for inspection, or Objects to build element objects, or you can register custom handlers for start and end tags, character data, declarations and external entities. It supports incremental non‑blocking parsing for streamed input, configurable encodings and namespace handling, and optional external entity fetching with LWP or a file fallback. Handler callbacks receive an Expat parser object and character data is returned as UTF‑8 which may arrive in multiple Char events so callers should accumulate chunks to form full text. Errors during parsing raise exceptions that you can catch with eval and there are options to include contextual lines in error messages. The recent 2.48 release tightened security and robustness by fixing several buffer overflows and large‑file position issues, improved encoding and error reporting, and added a few usability and maintenance enhancements.

YAML::Syck is a thin, fast Perl binding to the libsyck serializer that converts Perl data structures to and from YAML text using simple functions like Load, Dump, LoadFile and DumpFile and supports streaming multiple YAML documents and dumping into existing scalars with DumpInto. It gives you control over common emitter and parser behaviors via global flags such as $YAML::Syck::ImplicitTyping to recognize unquoted booleans and numbers, $YAML::Syck::ImplicitUnicode and $YAML::Syck::ImplicitBinary for Unicode and binary handling, and options to control quoting, sorting keys and whether loaded nodes are blessed into objects. The module implements YAML 1.0 and bundles its own copy of libsyck, so it can be useful when you need interoperability with other Syck wrappers or want a lightweight, speedy YAML layer, but it has some limitations such as incomplete support for dumping glob/IO values and tied variables and a history of known issues and only semi-active maintenance. Recent releases include important stability fixes, notably patches in 2025 that address memory corruption and improve handling of empty strings and keys, but if you need full YAML 1.1 compliance or a more actively maintained YAML stack you may prefer YAML::XS.

CPAN::MetaPackager is a small toolkit for creating and managing a local SQLite copy of the CPAN package index named cpan.metapackager.sqlite. It converts the standard CPAN index file 02packages.details.txt.gz into a searchable, machine-readable SQLite database using the included build scripts, and the distribution even ships a prebuilt database to save the build time. The database is useful when you want a local metadata store for tools such as CPAN::MetaCurator and it includes a converted changelog (Changelog.ini) for easier automation. The project is hosted on GitHub, has support and bug tracking via CPAN/RT, and is released under the Perl 5 license.

CPAN::MetaCurator is a toolset for curating and publishing CPAN and Perl.Wiki metadata as a browsable jsTree-style HTML site. It ingests a Perl.Wiki export (JSON tiddlers), optionally enriches that data from a CPAN::MetaPackager sqlite database, builds a local sqlite store and then exports an HTML tree you can patch into your website. The distribution provides scripts to automate the import, rebuild, export and upload steps so maintainers can refresh a public Perl.Wiki/CPAN listing, though the full import can be time consuming on modest hardware. The project is maintained by Ron Savage on GitHub, is licensed under Perl 5, and offers support via RT or direct email.

OpenGL is the Perl binding that lets you drive the full OpenGL suite from Perl programs, exposing gl*, glu*, glut* and many GLX calls so you can do hardware-accelerated 2D and 3D rendering, manage buffers and textures, use VBOs and FBOs, and compile and run shaders from Perl. It provides fine-grained import tags so you can pull in just the functions or constants you need and integrates with companion modules such as OpenGL::Array for efficient C-backed arrays, OpenGL::Matrix for uniform matrices, OpenGL::Image for ImageMagick image buffers, and OpenGL::Shader for shader management. The module is cross platform and designed to follow the C OpenGL API closely while offering Perl-friendly variants for pointer and array arguments. You must have the system OpenGL, GLU and a GLUT or FreeGLUT installation available, and GLX support is limited by platform and X bindings. A recent update improved Apple GLUT handling and added explicit GLX context-requesting support via glpRequestContext, and there is a compatibility note that MacOS does not support GLX_ARB_create_context_profile and that GLX support now requires GLX 1.3 or newer. If you want to render with OpenGL from Perl and need access to modern GL features and shader workflows, this module is the standard, actively maintained choice.

Mail::Milter::Authentication is a Perl-based milter daemon that brings a full suite of email authentication and policy checks into your MTA as a single, extensible service. It runs as a preforking Net::Server process and provides a handler framework so you can enable or extend checks like SPF, DKIM, DMARC, ARC, BIMI and RBL lookups, collect metrics, log decisions, and generate or defer DMARC reports. The module is aimed at mail server operators and developers who need a pluggable, production-ready way to apply authentication policies, reject or quarantine mail, and integrate reporting and metrics into their delivery pipeline. It includes daemon control, configurable timeouts and caching, hooks for custom handlers and callbacks, and background dequeue/report processing. Recent notable changes include a new option to perform a separate HELO SPF check and an earlier switch to a stricter Email::Address::XS parser that can change parsing behavior, so users with custom handlers are advised to test configurations after upgrades.

Text::Names::Canonicalize is a Perl module for normalizing personal names in a locale-aware way, useful for data cleaning, deduplication, indexing, and matching. It applies declarative YAML rules per locale to split names into parts and produce a consistent, lowercase canonical form, and it exposes simple functions for getting a canonical string or a structured breakdown showing the original, detected parts, and the canonical result. The rules system supports inheritance between locale files with detection of circular includes, handles multi-word surname particles like "von der" or "d'", and lets you override or extend built-in rules by dropping YAML files in your configuration directory. A command-line tool ships with the distribution and can show explanations of how a name was canonicalized or the resolved ruleset for a locale. Built-in locales include base, en_GB, en_US, fr_FR, and de_DE and you can add more by writing additional YAML rules. This initial release adds the YAML inheritance and circular-include checks, the CLI, user override support, and a multi-word particle tokenizer, and note that the code is provided as-is and the license limits free use to personal single-user scenarios while other uses require contacting the author.

Dist::Zilla::PluginBundle::YANICK is an opinionated collection of Dist::Zilla plugins that reproduces the build and release workflow used by Yanick Champoux, so you can automate packaging, metadata, documentation, testing, Git/GitHub integration, versioning, and CPAN uploads with a single configuration. It wires together contributors tracking, pod and readme handling, license and code-of-conduct files, release tagging and branch management, automatic prereqs, upload/push steps and optional dry-run mode via fake_release, while exposing a few knobs like builder type, authority, development and release branch names, and which extra files to import from the build. If you already use Dist::Zilla and want a ready-made, well-maintained setup that follows common best practices, this bundle saves you the work of assembling many individual plugins, and the 0.32.2 release recently ensured required dependencies are added to the generated dist.ini.

Git::CPAN::Patch is a small command-line toolkit that helps Perl developers grab a distribution from CPAN into a local git repository, make changes in branches, and send those changes back to the module author as patches. It installs a set of git-cpan commands to clone or import CPAN releases, keep a working branch rebased against upstream, format and squash commits into patch files, and submit patches via git-send-email or to RT, so you can use a familiar git workflow when contributing to or maintaining CPAN modules. The tool is designed for Unix-like systems and is not supported on Windows. If an official upstream git repository exists it will use that when available, and the recent 2.5.2 release includes a tweak to avoid signing git tags. This is a practical choice for anyone who wants to move CPAN patching into a git-centric workflow.

Crypt::HSM is a lightweight Perl wrapper for PKCS#11 libraries that lets your Perl code use hardware security modules and software token implementations to manage keys and perform cryptographic operations. It exposes the familiar PKCS#11 concepts of providers, slots, tokens and sessions so you can open a session, authenticate, find or create keys and then run high level operations such as encrypt, decrypt, sign, verify, digest and streaming encrypt/decrypt workflows. The module includes conveniences like loading a specific PKCS#11 library, generating random IVs, searching objects by attributes and handling common mechanisms such as AES-GCM, RSA-OAEP and RSA-PSS while mapping PKCS#11 attributes into Perl objects. Recent releases improved thread-clone safety, made Session and Mechanism objects hold a Slot for clearer ownership, added an id method on objects and relaxed identifier syntax to allow underscores, making it more robust in multithreaded Perl applications. If you need to integrate Perl code with an HSM or SoftHSM for key protection or to offload crypto operations to a PKCS#11 provider, Crypt::HSM is directly relevant and practical.

DBIx::SearchBuilder is an object oriented toolkit for Perl that makes it easy to build, run and paginate SQL queries and to represent returned rows as objects. You write small subclasses that declare the table and record type and the module handles common tasks like limiting and filtering results, ordering and grouping, joining other tables, counting total matches, selecting specific columns, and iterating through pages of results. It can emit the SQL it generates for debugging and supports using bind variables where available. You must provide a DBIx::SearchBuilder::Handle for your database connection and implement NewItem to produce row objects, and the module works with any DBI driver supported by your handle. Use DBIx::SearchBuilder when you want a higher level, reusable abstraction over raw SQL in Perl applications.

Aion::Format is a compact Perl utility collection for everyday text and number presentation tasks, aimed at making logging, console output and simple data formatting easier. It offers ANSI color markup and printing helpers, timestamped access and error logging, number formatting and radix conversion, human-readable byte sizes and intervals, rounding and Roman numeral conversion, lightweight HTML-aware template matching, Russian transliteration helpers, safe capture of STDOUT/STDERR, handy Data::Printer presets and a couple of string-quoting utilities. If you need quick, ready-made routines for coloring, logging, formatting numbers or handling Russian text in command line scripts or small utilities, this module is a good fit.

PlackX::Framework is a compact, Plack-based framework for building PSGI web applications that favors minimalism and extensibility. It wires together lightweight request and response objects with a small router DSL that provides route and filter handlers, and it automatically loads or generates per-application subclasses for handler, request, response, router and related pieces so you can get an app running from a single .psgi file or expand it into separate modules. Requests include a per-request stash and a one-cycle flash cookie, there is optional integration for Template Toolkit and an extended URI helper, and the router uses a Router::Boom based engine under the hood. The project emphasizes fast startup, low memory usage, and few dependencies while leaving heavy customization to subclassing, making it a good fit if you want a simple, performant PSGI foundation rather than a feature-heavy framework. The distribution requires Perl 5.36 or newer and Plack plus a few small modules, is described as experimental/alpha, and this release marks its first CPAN publication.

Hash::Wrap lets you turn plain Perl hashes into lightweight objects so you can access keys as methods instead of manually dereferencing hashes. It works at import time to install a constructor into your package or store it in a scalar, and it gives you options to use the original hash or take a shallow copy or a deep clone, to make accessors lvalue where supported, to recurse into nested hashes, and to make objects immutable or restricted to a fixed set of keys. By default calling an accessor for a missing key throws an exception but you can change that to return undef. The module is designed to be dependency-light and to let you customize class names and add extra methods while tracking additions and deletions to the underlying hash. Note the usual caveats: generated methods may mask keys like DESTROY or AUTOLOAD, lvalue accessors require newer Perls, locked hashes must be copied or cloned before wrapping, and recursive immutability is applied as nested hashes are visited. A recent enhancement in v1.08 adds a -lexical flag to create lexical constructor subs on Perl 5.38 and later.

Text::ASCII::Convert is a Perl module that normalizes text by turning non-ASCII characters into visually similar ASCII characters so you end up with a plain 7-bit ASCII string. It accepts Unicode strings or UTF-8 octets and returns only ASCII bytes, making it useful for spam filtering, search normalization, or any situation where obfuscated text must be reduced to a readable ASCII form. The module maps characters by appearance rather than linguistic meaning, so some mappings can be surprising, for example the German eszett may be mapped to a capital B and Greek Sigma to an E. Characters with no ASCII lookalike are replaced by a single space and runs of spaces are collapsed, zero-width characters are removed, and control characters like tabs and newlines are preserved.

App::GHGen is a command-line tool and GitHub Action that generates, analyzes, and optimizes GitHub Actions workflows for your repositories. It can auto-detect project type or produce language-specific templates for Perl, Node, Python, Rust, Go, Ruby, Docker, and static sites, and it builds workflows with sensible defaults for caching, concurrency, permissions, and testing matrices. The built-in analyzer finds performance, security, cost, and maintenance issues, provides CI-minute cost estimates, and can apply safe auto-fixes or open pull requests with suggested changes so teams can reduce CI time and keep workflows up to date. It integrates into CI to comment on pull requests, create scheduled fix PRs, or act as a workflow quality gate. Perl support includes multi-OS and multi-version testing, CPAN caching via local::lib, optional Perl::Critic and coverage steps, and respect for declared minimum Perl versions. The recent 0.04 release bumped the maximum Perl version, added support for C detection, improved failure behavior when project type cannot be determined, shows debug output on failure, and added analyzer and auto-fix rules for missing timeout-minutes in jobs.