CPANscan

Restish::Client is a lightweight Perl client for talking to REST-style HTTP APIs, giving you a simple object that wraps a base URI and common request patterns so you can send GET, POST, PUT, DELETE, PATCH and LIST calls with minimal boilerplate. It supports default headers for things like authentication, URI templating with named interpolation, query parameters, JSON-encoded body parameters, raw body uploads with content type, and a thin_request mode for calling LWP directly when you need low-level control. The client can be configured with SSL/TLS options, an optional persistent cookie jar, request-level headers, and a debug mode that can trim tokens, and it returns parsed JSON for 2xx responses while exposing the response code, headers and body for error handling. This module is suitable for scripts and services that need a straightforward REST wrapper without heavy framework dependencies. The initial CPAN release adds a Moo-based interface, comprehensive tests, and the core features above.

Chess4p is a lightweight Perl library that provides core chess functionality for building engines, analysis tools, or board utilities. It offers Board and Move objects that can load and emit FEN, push and pop moves, print an ASCII board, generate legal moves and run perft tests, and handle UCI move input/output for engine integration. The module is practical for developers who need reliable move generation and testing hooks without a heavy dependency stack. Planned additions include SAN input/output and PGN parsing, and at present the author notes the library supports only 64-bit systems. This is the initial 0.01 release by Ejner Borgbjerg.

IO::K8s is a Perl toolkit for representing, validating and serializing Kubernetes API objects so you can build, inspect and emit kube-friendly JSON and YAML from Perl code. It provides typed object classes for core resources, a small DSL for writing ".pk8s" manifests, helpers to load and validate YAML (with optional error collection), and methods to inflate JSON or hashrefs into typed objects and serialize them back to JSON, YAML or plain Perl structures. The module also supports Custom Resource Definitions either by writing simple IO::K8s::APIObject classes or by auto-generating classes from a cluster OpenAPI spec, and it can merge external resource maps such as Cilium so multiple providers can coexist while using apiVersion or domain-qualified names to disambiguate colliding kinds. IO::K8s is designed to ensure Kubernetes gets correctly typed values and to integrate with Kubernetes::REST for API calls. Note that the library was rewritten in version 1.00 with a switch from Moose to Moo, unified list handling and an update to the Kubernetes v1.31 API, so you may need to adjust code when upgrading.

Graphics::Toolkit::Color is a high-level Perl toolkit for creating, converting and manipulating colors as immutable objects, with easy serialisation to and from many common formats such as hex, CSS strings, numeric tuples and named palettes. You can construct colors from names or from values in many color spaces, query or export their values, measure distances between colors, and generate related palettes with operations like mix, invert, complement, gradient and cluster for producing coordinated sets. The API favors a functional style so methods return new color objects rather than mutating the original, and it supports perceptual spaces like OKLAB and CIELUV for smoother gradients and more meaningful distance measures. It also integrates with external color-name schemes via Graphics::ColorNames and provides a handy color() importable constructor. Note that several legacy getter and modifier methods are deprecated and slated for removal in the upcoming 2.0 release. In the most recent updates mixing more than two colors without explicit amounts is handled by equal weighting and a few parsing and documentation improvements were made.

App::Cme provides the cme command line utility for working with configuration data through Config::Model, letting you validate, inspect, edit, dump and script changes to system or application configuration in a consistent, model-driven way. It is useful when you want automated checks or controlled edits of config files, interactive editing via available UIs, or to run small configuration scripts that can read and write config trees and optionally commit changes to version control; run scripts can be written in YAML or Perl and support variables, foreach loops, stashing changes before execution and fine grained commit control including the new modify --commit <msg> option. The tool can export configs as YAML, JSON or Perl, supports multiple backends such as ShellVar and YAML, works with configuration directories and application-specific models, and integrates with Config::Model features for deep checks and sane defaults. App::Cme is open source under the LGPL, maintained on GitHub, and is a good fit if you manage many or complex config files or need repeatable scripted edits, but it is only relevant if you use Config::Model and a Perl-based workflow.

Syntax::Construct is a small utility that lets you explicitly declare which Perl syntactic constructs your code uses when those constructs are not managed by the feature pragma. By naming constructs such as the defined-or operator or non-destructive substitution in a use Syntax::Construct line you get clear, user-friendly error messages on older Perls that tell people which language release introduced the syntax instead of cryptic parse errors, and you avoid needlessly raising your script's required Perl version just to cover a few non-feature items. The module also exposes introduced and removed query functions so tools or install-time checks can determine when particular constructs were added or taken away, which helps when auditing code for backward compatibility or preparing patches for ancient Perls. It does not export symbols and is intended as both documentation and runtime guidance, though behavior can be unsettled on development Perl releases where construct removal is still being tested.

DBIx::Fast is a lightweight DBI wrapper for Perl that simplifies everyday database work by providing easy connection setup and a small set of convenience methods for common tasks. You can connect with a DSN or by specifying driver, database, user and password and then run queries that return results as arrayrefs, hashes, single values or flat lists. It includes helpers for inserts, updates, deletes and a shorthand up method, exposes the last SQL, last insert id and errors, and can write a simple profile log. The module also provides utilities to build WHERE clauses and handle MySQL-style timestamps so you can focus on CRUD logic instead of boilerplate DBI code. It aims to be simple and pragmatic for scripts and small applications, and is distributed under the Artistic License 2.0; note that the author has left a FIXME around one preparation path which suggests a small area may need refinement.

Dist::Zilla::PluginBundle::Author::ETHER is an opinionated, ready-made bundle of Dist::Zilla plugins by Karen Etheridge that sets up a full build, test and release workflow for Perl distributions. Add [@Author::ETHER] to your dist.ini and you get sensible defaults for gathering files from git, generating README and metadata, running a broad suite of author- and release-time tests, managing version numbers and git tags, preparing and committing release artifacts, and updating GitHub and CPAN metadata. The bundle is tailored for GitHub-hosted projects by default but supports other servers and lets you tweak installer backends, inject plugin prereqs into your metadata, enable airplane mode to avoid networked checks, create a cpanfile, perform fake releases, and control licence and authority metadata. It is designed to be customizable and mint-friendly so new projects start with a robust setup. The latest updates include tweaks to the generated CONTRIBUTING document to address AI contribution guidelines.

Acme::AsciiEmoji is a lighthearted Perl module that exports a large set of ready-made ASCII and kaomoji emoticons as simple functions you can call from your code. With names like innocent, shrug, table_flip and hugger each export returns a printable emoticon string so you can easily add expressive faces to command line tools, logs, bots, tests or any script output. It is meant to be a fun, presentation-focused utility rather than a library for data processing, and is useful whenever you want to inject personality or humor into text output.

CallBackery is a Mojolicious-based framework that provides the server-side plumbing for building appliance-style, configurable web frontends. It wires a Mojolicious app to load configuration (from etc/callbackery.cfg or a CALL BACKERY_CONF override), supply a pluggable database interface, expose RPC service endpoints for a rich client, and set security headers on responses. The distribution is aimed at powering a Qooxdoo-style rich client and includes support for forms, tables, uploads and downloads, translations, plugin-based GUI components, YAML configs, session-cookie login flows and async/promise-aware backends so you can focus on application logic rather than HTTP wiring. Recent work continues to polish robustness and compatibility, for example a recent fix prevents attempts to call controller event hooks when no controller is present.

Dump::Krumo is a small Perl utility that produces colorful, human-friendly dumps of variables to make debugging easier. It provides two simple entry points, kx to print a variable and kxd to print and die with file and line details, and it can be configured to return the dump as a string, toggle color output, adjust indentation, suppress all output at runtime so debug calls can remain in production code, and even promote JSON::PP booleans to literal true/false or emit a full stack trace when desired. You can also customize the color scheme via the COLORS hash. If you want prettier, more readable and easily parseable alternatives to Data::Dumper for everyday debugging, Dump::Krumo is a lightweight, configurable option.

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.

String::Ident converts arbitrary text into safe identifiers and URL-friendly slugs. It transliterates Unicode to ASCII, replaces non-alphanumeric characters with dashes, collapses and trims repeated dashes, enforces a configurable maximum length and pads too-short results with random lowercase letters. You can call cleanup as a class method for quick conversions or create an object with new to set min_len and max_len, which default to 4 and 30. The cleanup method accepts an optional second argument to change the truncation limit or -1 to disable truncation. This module is useful when you need predictable, URL-safe identifiers from titles, filenames, or user input.

App::wsgetmail is a small Perl command and library for fetching email from Microsoft 365 mailboxes via the Microsoft Graph API and feeding each message to a local delivery command or mail processing program. You configure it with a JSON file that specifies authentication (client credentials are preferred but username/password is also supported), the mailbox and folder to read, size and body limits, line ending conversion, the command and arguments to run for each message, and whether to mark messages read or delete them after successful delivery. It can be used as a standalone CLI for cron or systemd jobs or embedded in Perl code to iterate and process messages programmatically. The module currently speaks only to Microsoft Graph and reads one folder per run, and it includes options for dry runs and debug output to help with testing. Be aware of Microsoft Graph throttling limits and occasional transient 5xx errors which wsgetmail handles conservatively by treating them as empty successes.

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.

DBD::Pg is the PostgreSQL driver for Perl's DBI that lets Perl programs connect to and work with Postgres databases in a native, full featured way. It supports connection options including service files and SSL modes, explicit transaction control and savepoints, server side prepared statements and flexible placeholder styles, array and bytea handling, large object APIs, high performance COPY operations, and asynchronous queries and connects for nonblocking workflows. The driver exposes many Postgres specific attributes and helpers such as UTF8 handling, type constants, last insert id lookup, error diagnostics and server debugging hooks so you can tune behavior to your application. You should explicitly set AutoCommit when connecting and the module documents sensible defaults and caveats around prepared statements and forking. Version 3.20.0 is the release documented here and bugs or contributions are handled via the project's GitHub.

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.