CPANscan

as is a small Perl utility that lets you load a module under a shorter or alternate name so you can refer to it more conveniently in your code. It hooks into Perl's require/use process and aliases the original module's symbol table into the name you choose, so you can write Foo->new while the object is actually provided by Very::Long::Module::Name. Be aware that objects blessed under the alias will report the original module name as their class, and that an aliased module's import method is only called when you pass additional parameters besides the as => 'Name' option. This makes as a simple way to tidy up long module names, especially in object oriented code, without changing the underlying module behavior.

MooX::Private::Attribute is a tiny extension for Moo that makes it easy to mark object attributes as private so their accessors are not exposed to outside callers. You simply add private => 1 to a has declaration and the attribute remains usable inside your class but attempts to call its accessor from outside will fail, which helps enforce encapsulation without extra boilerplate. It is lightweight, plugs into existing Moo classes, and is useful when you want a simple, declarative way to keep certain fields internal.

Date::Cmp is a small Perl utility that compares two date strings or date-bearing objects and returns -1, 0, or 1 like Perl's spaceship operator, letting you sort or order imperfect genealogy-style dates. It understands plain years, exact ISO or slash dates, approximate forms like "Abt. 1850" or "1802 ?", year ranges such as "1802-1803" and "BET 1830 AND 1832", month ranges like "Oct/Nov/Dec 1950", and the common qualifiers "BEF" and "AFT". You can pass plain strings, blessed objects with a date() method, or hashrefs with a date key. It uses fast-path heuristics for simple year comparisons and falls back to DateTime::Format::Genealogy for more complex parsing, and you may supply an optional callback to receive diagnostics about ambiguous range edge cases. On undefined inputs it prints diagnostics and returns 0 and it croaks on fatal parse failures with messages that start "Date parse failure: ". The author notes a few limitations to be aware of, notably no support for month-only dates, incomplete handling of some BEF/AFT combinations, and a package-level parser variable that is not safe to swap concurrently in threaded programs.

WebService::Chroma is a Perl client for Chroma, the open source vector database that helps you plug knowledge into LLMs for retrieval and semantic search. The module provides a simple object interface to a Chroma server so you can manage tenants, databases and collections, add documents with IDs, and run vector queries. It supports configurable embedding backends including OpenAI, Ollama, and Jina and lets you set model names, API keys, and base URLs, with sensible defaults for a local server. The API also exposes utility calls such as version, reset, heartbeat, pre-flight checks, and identity, making it easy to embed Chroma into Perl applications that need fast similarity search and LLM augmentation.

WebService::Jina is a Perl client for Jina AI that makes it easy to call Jina cloud services from Perl programs, offering high-level methods for DeepSearch for iterative web research, Reader for extracting clean, LLM-friendly text from web pages, embedding generation for multilingual and multimodal vectors, reranking search results to better match user intent, zero-shot and few-shot classification of text and images, and text segmentation into tokens or chunks. The API mirrors Jina endpoints and supports streaming responses and custom request options so you can integrate search, RAG, and agent-style workflows into existing applications with minimal glue code. You will need a Jina API key to use the service, and the module is aimed at developers who want a concise Perl interface to Jina’s search and multimodal AI capabilities.

ANSI::Palette is a lightweight Perl utility that makes it easy to display ANSI color charts and to print colored, bolded, underlined or italicized text using 8, 16 or 256 terminal colors. It provides simple, procedural functions like palette_8, palette_16 and palette_256 to show available colors and helpers such as text_8/text_16/text_256, bold_*, underline_* and background_* variants to wrap strings in the appropriate ANSI escape sequences. The module is handy for command line scripts and quick tooling where you want readable APIs for previewing palettes and adding colored output without handcrafting escapes. It uses standard ANSI codes so it behaves as expected on terminals that support the chosen color depth and styles.

Glitch is a lightweight Perl exception helper that exports a single glitch function for raising named, reusable errors with predefined messages and optional fields. You define glitches when you use the module or load them from a config file, then trigger them in code with glitch('name', key => value) and handle them via eval and inspecting $@ to branch on the error name. The module also supports a pluggable logger callback and configurable stringify format so you can centralize error text, logging, and presentation, and it works well when you want simple, structured, maintainable error handling across modules without a heavy framework.

Cache::CodeBlock provides a tiny, convenient way to cache the result of a code block by exporting a single function named cache that you wrap around the code whose return value you want stored and reused. You can pass optional arguments such as a time-to-live and an explicit key and you supply CHI-style configuration at import to choose the caching backend. It is useful for quick memoization of expensive calculations or I/O without writing boilerplate cache plumbing. The module is maintained by LNATION and recent releases require Perl 5.10 or newer.

Quaint is a compact Perl DSL that offers an unconventional but readable way to define classes, attributes and methods without the overhead of heavyweight OO frameworks. It lets you declare typed attributes like str, num, bool, array, hash and obj along with modifiers for read only, required, defaults and triggers, and it maps small anonymous subroutines to named methods with a concise function block syntax. You also get simple inheritance via extends and standard method modifiers before, around and after, making it easy to add behavior around existing methods. If you want a lightweight, expressive approach to Perl object orientation for small to medium projects, Quaint provides a minimal, declarative toolset that keeps class definitions short and clear; the distribution originated with an initial release on CPAN.

Dancer2::Plugin::JobScheduler is a Dancer2 plugin that makes it easy for web apps to hand off time-consuming or CPU-heavy tasks to external job schedulers and to query queued jobs, without tying your routes to a specific scheduler implementation. It exposes simple submit_job and list_jobs commands that hide scheduler details and let you target a configured scheduler by name or use a default, returning a structured result with success, status, and error fields and scheduler-specific data when available. The module supports TheSchwartz out of the box and can be configured through Dancer2's config system, including integration with Dancer2::Plugin::Database so scheduled work can share your app's database handles and participate in transactions. The project is under development so the API may change, but it is useful today for offloading background work like sending emails or delayed processing without rewriting your web routes.

mb.pm is a single-file Perl tool that makes it easy to write and run Perl scripts containing multibyte literal text in many legacy encodings as well as UTF-8 and WTF-8, by transpiling MBCS source into safe octet-oriented Perl or by providing a runtime mb:: API for selective codepoint-aware operations. It supports Big5, Big5-HKSCS, EUC-JP, EUC-TW, GB18030, GBK, Shift_JIS / CP932, UHC, Johab, HP-15 and others, automatically escapes problematic multibyte sequences that collide with ASCII metacharacters, and rewrites regular expressions and character classes so they behave sensibly for multibyte codepoints while leaving traditional byte-oriented builtins unchanged. You can use it as a source filter on modern Perls, as a modulino wrapper (perl mb.pm script.pl) for older Perls, or call mb:: routines at runtime to get codepoint semantics where needed, and it also includes helpers for Windows globbing and filename handling. The author notes some tradeoffs and limits, for example the modulino wrapper path writes a transpiled .oo file and there are intentional omissions such as full Unicode property support and non ASCII casing, plus a few platform-specific quirks, but for anyone maintaining or writing Perl that must work with MBCS source text or porting JPerl-era scripts this module is highly practical.

LLM::API is a Perl client for Anthropic's Claude REST API that makes it simple to send text and document prompts, list models and API keys, and fetch organizational usage and cost reports. It supports convenient helpers for creating prompt content, submitting messages, counting input tokens and estimating costs, and it handles authentication via an api_key or the LLM_API_KEY environment variable which is immediately removed for safety. The module also includes helpers for building request headers and query strings and for converting local dates to RFC 3339 timestamps for report queries. Note that the date formatter accepts exactly two input formats and that the built-in pricing table is hardcoded so you should verify current rates before relying on it for billing. In the 1.0.1 release the pricing data and supported models were updated and the content subsystem was refactored to add new content types including text, thinking and tool_uses.

Salus is a lightweight Perl toolkit for reading, writing and manipulating CSV files while optionally protecting them with an HMAC secret so you can detect tampering. You declare the column headers up front and then use a simple API to read protected or unprotected CSVs, add, update or delete rows, combine multiple CSVs by a key column, search and sort data, and run basic numeric aggregations like sum, mean, median and mode. It also offers helpers to stringify headers, diff files and work with rows either as arrays or hashes, making it handy when you need spreadsheet-style operations without a full database. The 0.10 release focuses on code hygiene by removing PAX headers and enabling strict and warnings.

Sys::RunAlways is a tiny, no-frills Perl helper that prevents multiple copies of the same script from running by locking the script's DATA filehandle when the module is loaded, letting your program continue only if it can acquire that lock. If the script has no DATA handle the module aborts with an error, if the lock is already held it exits silently with status zero, and if the lock is acquired it prints a startup message unless you pass the silent => 1 option to suppress that output. It is useful for simple cron jobs or lightweight daemons where you want an easy at-most-one-instance guard and depends only on core Fcntl, but you must include a DATA handle (for example via __DATA__ or __END__) for it to work. Be aware that symlinked copies of the same file will be treated as the same script and that editing a running script can release the lock and allow another instance to start. The module was updated over the years for adoption and the silent option, and the most recent 0.08 release is a small housekeeping update.

Sys::RunUntil is a tiny, zero-dependency Perl module that ensures a script runs no longer than a specified time. You activate it by loading the module with a runtime string such as "30mW" for 30 minutes of wallclock time or "30sC" for 30 seconds of CPU time, and you can combine units like "1H30M". If the script exceeds the limit the module will terminate it, which makes it handy for long-running batch jobs, cron tasks, test suites, and other resource-constrained runs. The module supports both wallclock and CPU limits and requires no extra libraries. Recent maintenance has kept the module lightweight and portable.

PerlIO::via::MD5 is a small PerlIO layer that makes it trivial to compute an MD5 checksum of a file by opening it with the :via(MD5) layer and reading from the handle, returning the digest instead of the file contents. It supports three output formats controlled by a class method: a 32‑character hexadecimal string, the raw 16‑byte binary digest, or a 22‑byte base64 MIME string. The layer is read‑only and stores the chosen format with each opened handle, and you change the default for subsequently opened files via the provided method because PerlIO does not allow passing parameters at open time. The module depends on Digest::MD5 and is useful when you want a simple, filehandle-style way to obtain MD5 checksums without writing explicit digesting loops.

PerlIO::Via::Base64 provides a PerlIO layer that transparently decodes Base64 when you read from a handle and encodes to Base64 when you write to one, so you can open files with via(PerlIO::Via::Base64) and treat MIME Base64 data like ordinary file I/O. It supports the usual MIME behavior of wrapping encoded output into 76-byte lines by default and exposes a class method eol to change the line-ending behavior or disable line breaks entirely. The layer is convenient for scripts that need to read or produce Base64-encoded files without calling encode/decode explicitly, but be aware that the current implementation reads or writes the entire file into memory before encoding or decoding, so it is not suitable for very large streams.

PerlIO::via::Rotate is a PerlIO layer you can attach to filehandles to transparently apply the classic rotational letter substitution (rotN) encoding and decoding, defaulting to rot13 but supporting any rotation from 0 to 26; you enable it by naming the rotation when loading the module or in your layer spec, for example <:via(rot13) for reading or >:via(rot14) for writing, and it will shift only ASCII letters while leaving other bytes alone. It is useful when you need to read or write files already encoded with rot-style ciphers without manually transforming data, and you can allow a single rotation, a list of rotations, or use the special ":all" keyword to permit all rotations. Internally the module acts as a front end that loads one of the PerlIO::via::rot0…rot26 helpers because PerlIO layers cannot take runtime parameters, but that detail does not change the simple usage model. The latest 0.11 release contains minor packaging maintenance including removal of PAX headers.

PerlIO::via::LineNumber is a lightweight PerlIO layer that transparently prefixes line numbers onto lines read from or written to a file handle, making it handy for quick debugging, printed listings, or simple text transforms; you enable it by opening a handle with :via(LineNumber) or by applying binmode and you configure the starting number, numeric format, and step size via class methods or as options to the module because PerlIO::via does not support passing parameters at open time. Defaults are line 1, format '%4d %s', and increment 1, and you can change the increment to produce BASIC-style numbering like 10, 20, 30. The module has no extra runtime dependencies and is intended as a small development tool rather than a production formatter. The recent maintenance release cleaned up packaging by removing PAX archive headers while keeping the interface stable.

Smaz is a tiny compression library optimized for very short strings, offering two easy functions, smaz_compress and smaz_decompress, so you can quickly shrink and restore short textual values. It is not a drop-in replacement for general-purpose compressors but it excels on small English phrases and common tokens, often cutting size by 40–50% on average and even compressing words like "the" down to a single byte, while still providing some benefit for HTML and URLs. This Perl module is a thin wrapper around Salvatore Sanfilippo’s Smaz algorithm, is lightweight and fast, and is useful when you need to reduce storage for keys, tags, short messages or other tiny text fields; recent updates focused on better test coverage and minor build/test housekeeping.

Game::Snake is a small Perl module that provides a playable clone of the classic Snake game using the raylib graphics library. It exposes a simple object-oriented interface so you can create a Game::Snake object and call run to start the game, and the distribution includes a ready-to-run snake.pl example. The module is useful as a fun demo, a learning resource for building simple games and handling input and rendering in Perl, or a starting point for extending a basic arcade-style game. Documentation is available via perldoc and the CPAN pages, and the 0.11 release is a minor maintenance update that removes PAX headers from the package.

Game::Floppy is a small Perl module that implements a Flappy Bird style game using the raylib graphics library, letting you create and run the game from Perl with a minimal API. You typically instantiate the game with Game::Floppy->new() and start it with ->run(), or run the included floppy.pl script to play the demo. It is useful if you want a lightweight, playable example of game programming in Perl, a quick demo for raylib Perl bindings, or a starting point for building simple 2D games. The module is released under the Artistic License 2.0 and requires raylib and its Perl bindings to be installed.

Mojo::DOM::Role::Restrict is a plugin for Mojo::DOM that lets you declaratively limit and transform HTML by supplying a specification of allowed tags and attributes. You describe rules per tag, use "*" as a wildcard, and control attributes with simple flags, regular expressions, or custom callbacks to accept, modify, or remove values. The role can remove or replace tags, mutate or prefix attributes, validate whether the current DOM matches the spec with valid, apply irreversible changes with restrict, and show what changed with diff using a configurable diff backend. It is useful when you need to sanitize or normalize HTML output in a controlled, programmable way without diving into the parser internals.

Ascii::Text::Image is a small Perl module that renders ASCII or banner-style text into bitmap image files. It builds on Ascii::Text and uses an Imager TrueType font to draw text with configurable font, color and padding, and you create images simply by instantiating the object with options like imager_font and padding then calling it with the text and an output filename. This makes it handy for generating programmatic headers, banners, or label graphics from scripts and web apps without manually composing images. The module is available on CPAN, documented via perldoc, and released as version 0.06 under the Artistic License 2.0.

Ascii::Text is a lightweight Perl module for turning plain strings into styled ASCII-art banners that you can print to the terminal or write to a file. You create an object, pick a font and styling such as color, alignment, padding and maximum line width, then call render to print or stringify to get the output as text. The module adapts to your terminal width by default, supports custom ANSI color maps, lets you override inter-word spacing, and can return the generated lines to your program for further processing. It is useful for adding readable, attention-grabbing headings to command line tools, scripts, logs, or text files without needing to handcraft large ASCII layouts.

Module::Generate::YAML provides a single exported function, generate, that reads a human‑readable YAML specification and produces a Perl module or distribution skeleton for you, so you can describe classes, methods, accessors, POD, metadata and small code blocks in YAML and have the module files generated automatically. It is handy when you want to script or template module creation rather than handcraft files, and it can be invoked from the command line for quick scaffolding. The recent 1.01 update removed PAX headers from generated archives to produce cleaner package metadata.

Module::Generate::Hash is a small utility that builds Perl distributions and classes from a simple hash-based specification, exporting a single function named generate that accepts a hash describing the distribution name, author, version and the classes to create. You provide a declarative structure for each class including abstract text, package variables, begin blocks, accessors and subroutines with code references, POD and examples, and the module generates the corresponding module scaffolding for you. It is useful for authors, tooling and tests that need to produce multiple modules or boilerplate programmatically and saves time compared with hand-writing repetitive code.

Module::Generate is a Perl scaffolding tool that programmatically builds distributions, packages and their test files so you do not have to hand-write repetitive boilerplate. Via a fluent API you declare the distribution name, author and version, add classes and then define constructors, accessors, methods, POD with examples, tests and compile-phase blocks, and even create reusable macros and custom keywords to inject shared code across classes. It writes out ready-to-run module files and test skeletons to speed up module development and release preparation, so it is best suited to Perl authors and maintainers rather than end users of a library. The recent 1.03 update removes generated links to AnnoCPAN and CPAN Rating and fixes POD versioning so generated documentation reflects the module version.

Cpanel::JSON::XS is a fast, C-implemented JSON encoder/decoder for Perl that prioritizes correctness and full Unicode handling while offering a rich set of configuration options for common needs like pretty printing, ASCII/latin1/binary output, canonical key sorting, bignum support, and controlled handling of blessed objects. It preserves round-trip fidelity for JSON-representable data, supports incremental parsing and BOM detection, is thread-safe, and is the actively maintained cPanel fork with a public issue tracker so bugs get fixed promptly. It integrates cleanly with JSON::MaybeXS so you can get its speed transparently and offers defensive defaults and limits to avoid resource or security issues, though note the allow_nonref behavior was changed to permissive by default in a recent release and can be disabled if you require strict top-level array/object enforcement. The very latest updates include a canonical sort fix that now compares keys by UTF-16 code units to match RFC 8785 and a quadmath-related float formatting fix to avoid dropping “.0” on high-precision platforms, plus many practical bug and security fixes across platforms and Perl versions.

Net::DNS is a mature collection of Perl modules that give you full DNS resolver functionality beyond the simple gethostbyname/gethostbyaddr calls, letting Perl programs perform lookups, zone transfers, asynchronous queries, and dynamic DNS updates. It models DNS concepts with Resolver objects for query state, Packet/Header/Question objects for responses, and RR objects for resource records, and it provides convenient helpers such as rr() and mx() for common lookups, rrsort() for ordering records, and builders for update prerequisites and add/delete operations. The module also includes utilities for managing zone serial numbers and supports AXFR and background queries, so it is a good fit if you need to script DNS administration or implement protocol-aware DNS clients in Perl. Expect to be comfortable with basic DNS concepts and zone file formats to use it effectively. The project is actively maintained at NLnet Labs and is widely used, but the authors note that Net::DNS can be relatively slow compared with some lightweight alternatives.