CPANscan

JSON::Conditional is a small templating tool that lets you embed conditional logic and simple loops inside a JSON structure and then "compile" that template into a concrete JSON document or Perl data structure based on a parameters hash. You write JSON that contains blocks like if/elsif/else, given, and/or, plus for-each and for-keys loops, and use expressions such as regex matches, equality or numeric comparisons to drive which parts of the template are emitted, while placeholders like "{key}" are filled from your params. The module provides a compile method to produce a JSON string, a Perl structure, or write to a file, plus handy encode/decode helpers and file variants. If you need rule-driven or param-driven generation of JSON from declarative templates this makes the job simple and readable. Recent fixes addressed file handling in the decode method so decoding from files works correctly.

Struct::Conditional embeds a small conditional language inside Perl hashes so you can declaratively transform input parameters into an output data structure. You write a template struct that uses familiar keywords such as if, elsif, else, given, and, or, for and each to express branching, pattern or equality checks, placeholders like {param}, and loops over arrays or hashes. The module provides a simple API with new, compile and itterate to evaluate that template against a params hash and produce a populated Perl structure. This makes it easy to map, filter and reshape incoming data or build rule-driven templates without imperative code, and it is useful when you want readable, data-driven generation of nested structures in Perl.

PerlIO::via::UnComment is a tiny PerlIO layer that automatically strips lines that start with '#' from a file or stream on input or output, letting you open files with :via(UnComment) or apply it to STDIN/STDOUT so only uncommented source flows through; it is intended mainly as a development tool for tasks like testing or producing comment-free output and can be stacked with other PerlIO filters such as PerlIO::via::UnPod. The module has no extra dependencies, is simple and stable, and was adopted by a new maintainer in 2019.

Module::ScanDeps::Static is a small, pragmatic tool for discovering direct Perl dependencies by statically scanning a script or module for common declarations like use, require, parent and base. It can read files or STDIN and produce text, JSON, raw, or RPM-style requirement output, with options to include or exclude core modules, append installed versions when none are specified, and set a minimum Perl version to be considered core. The module itself returns only direct dependencies, and the distribution supplies a find-requires helper for recursive directory scans and cpanfile-style outputs. The scanner relies on regular expressions so it handles many common coding patterns, including base/parent with qw or curly braces, and the recent 1.8.1 release added recognition for Moo and Role::Tiny::With's with syntax and fixed RPM output. It is very useful for quick dependency audits but may miss complex or multi-line constructs because it is a static parser rather than a runtime resolver.

PersonName::Format is a pure-Perl library that renders personal names using CLDR person-name patterns so names appear correctly across languages and writing systems. It inspects the name parts to detect script and likely subtags, chooses an effective formatting locale when scripts differ, and applies configurable options such as length, formality, display order, usage, and optional surname-all-caps. You can format individual name hashes or objects, compile a frozen formatter for repeated use, or get structured parts for custom rendering or markup. The module is useful for web and application interfaces that must present, address, or monogram names in a standards-driven, locale-aware way.

Mojolicious::Plugin::BarefootJS integrates the BarefootJS server-side JavaScript runtime into Mojolicious by registering a per-request "bf" helper that lazily creates a BarefootJS instance backed by BarefootJS::Backend::Mojo and lets you render compiled BarefootJS templates as ordinary Mojolicious templates. It is a straightforward way to add server-side rendering of BarefootJS components to a Mojolicious app and to access the runtime from controllers and templates. If you run outside Mojolicious or under PSGI look at BarefootJS::Backend::Xslate which drives the same runtime without a web framework. A recent improvement makes the plugin load the build manifest lazily and cache it by mtime and size so booting before the first build no longer breaks SSR defaults and manifest changes are picked up without restarting the server.

BarefootJS::Backend::Xslate is a rendering backend that lets the BarefootJS runtime render Kolon ".tx" templates with Text::Xslate. It binds the runtime into templates as the bf object so templates emitted by the @barefootjs/xslate adapter can call runtime helpers and Kolon builtins, and it handles HTML auto-escaping and JSON encoding for you. You can give it a prebuilt Text::Xslate instance or just a list of template paths plus options, and it exposes simple methods like render_named, encode_json, mark_raw and materialize to integrate rendering into your app. The backend is framework-agnostic so it runs under PSGI/Plack or standalone, making it an easy drop-in for projects using BarefootJS and Kolon templates.

BarefootJS is a lightweight server-side runtime that lets templates compiled from JSX/TSX call into Perl during rendering, providing a consistent runtime API while delegating framework- and engine-specific tasks to a pluggable backend. It handles things like JSON marshalling, marking raw strings, materializing JSX children, and named-template rendering without tying you to a particular template engine or web framework, so you can plug in backends such as Xslate for PSGI/Plack or a Mojolicious plugin as needed. The core keeps dependencies minimal by loading only core Perl modules unless a backend requires more, the project is actively maintained with frequent releases, and it is available under the MIT license.

Cucumber::Messages is a Perl library that implements the Cucumber messages protocol and provides Perl classes for every message type used across the Cucumber ecosystem, together with NDJSON serialization and deserialization. It lets you build, inspect and emit Envelope-wrapped messages that Cucumber tools expect, for example converting Location, Attachment or TestCase objects to and from JSON with methods like to_json and Envelope->from_json. Use it when you need to integrate Perl test runners, formatters or reporters with other Cucumber components, handle attachments or externalized attachments, or consume/produce NDJSON message streams generated by the broader Cucumber toolchain. The module follows the shared cross-language message schema maintained by the Cucumber project and is kept in step with upstream protocol improvements.

Geo::Address::Formatter converts a structured postal address (a Perl hash of components like house number, street, postcode and city) into a human readable, country‑specific formatted address using templates for each country. You must supply a configuration path of templates, and the module supports per-call options such as forcing the country, producing abbreviated forms, or limiting output to just address components rather than place names. It returns a multiline string ready for display or printing and exposes the final resolved components of the last formatted address for further use. The distribution includes a minimal configuration for testing but is designed to be used with the comprehensive OpenCage address-formatting templates on GitHub, making it useful for any application that needs consistent, global address formatting.

Text::Hogan is a Perl port of Twitter’s hogan.js that implements the Mustache templating language statement-for-statement. It lets Perl applications precompile Mustache templates into plain Perl code so rendering is very fast and it passes the full Mustache specification, including lambda sections, making it suitable for web pages, emails, APIs or static site generation where simple logic-less templates are preferred. If you are familiar with hogan.js or need a compatible, high-performance Mustache engine in Perl this module will behave as expected and supports dumping compiled templates for reuse. The 2.05 release modernized dependencies and includes various speedups to make compilation and rendering even faster.

CPAN::Test::Dummy::Perl5::SKAJI is a tiny placeholder CPAN distribution intended for testing packaging, upload and release workflows rather than providing useful runtime functionality. It is useful when you need a predictable, no-op distribution for exercising CPAN toolchains, continuous integration pipelines, or publication steps that involve signing and provenance. Recent work has focused on supply-chain hygiene: release tarballs are signed and accompanied by GitHub Artifact Attestations and the project now makes GitHub releases immutable, so it is a convenient testbed for trying out Sigstore signing, PAUSE uploads and attestation-based provenance. The module is maintained by Shoichi Kaji and is licensed under the same terms as Perl.

GraphQL::Houtou is a high-performance, XS-backed GraphQL parser and execution toolkit for Perl that makes it easy to run GraphQL queries with production features and low overhead. It exposes a canonical Perl AST for parsing, an XS native runtime for execution, and multiple APIs so you can pick a simple one-off entry point or build a long-lived runtime for repeated queries. The library includes efficient batching via a bundled DataLoader and an on_stall hook to collapse N+1 database lookups, a direct JSON rendering path that emits UTF-8 bytes without building Perl data structures, a one-line PSGI adapter for HTTP endpoints, and support for persisted queries as compiled bundles or programs for maximum throughput. It also offers async schemas that recognize Promise::XS promises, program caching and cost limits for production safety, and utilities to import or emit SDL. Limitations noted by the author include no subscription execution or streaming transports in the 0.01 profile, no generic promise adapters, fixed native bundles cannot accept GraphQL variables, and the runtime is not compatible with Perl ithreads so use process-based concurrency.

ExtUtils::MakeMaker::CPANfile lets authors drive ExtUtils::MakeMaker's WriteMakefile from a cpanfile so you can declare distribution prerequisites in a modern cpanfile and have them translated into Makefile.PL parameters automatically. It loads a cpanfile found next to Makefile.PL, converts its requires/recommends/suggests/conflicts into WriteMakefile arguments, and strips unknown parameters that older EUMM versions would warn about. It does not fully handle complex version ranges and it sets dynamic_config to false by default though you can enable dynamic configuration via META_ADD or META_MERGE when needed. Recent releases improve dependency handling by merging prerequisites with CPAN::Meta::Requirements so combined constraints are resolved more sensibly.

Complete::KDEActivity is a small helper module that plugs into the Complete family to provide tab-completion data for KDE activities. It exposes two optional functions, complete_kde_activity_guid and complete_kde_activity_name, which return lists of existing KDE activity GUIDs or activity names for use in completion routines. The functions are not exported by default so you can import them only when you need KDE activity completions. This is a focused, first-release utility best suited to developers writing shell completion scripts or command-line tools that need to look up KDE activities, and the source and docs are available from its CPAN and GitHub pages.

String::Mask is a small Perl utility for hiding sensitive parts of strings while leaving a usable, realistic fragment visible for testing or display. It provides a single mask function that takes the text, a visibility position (start, middle, end, or email), an optional count of characters to keep (defaulting to half the string), and an optional mask character (default '*'), so you can easily obfuscate emails, phone numbers, IDs, or other personally or commercially sensitive data while preserving structure and readability. The email mode preserves the @ and domain layout and there is an XS variant available for much higher performance when processing large volumes.

Google::Ai::Generativelanguage::V1 is a Perl client for Google Cloud's Generative Language API that makes it easy to call generation and embedding services from Perl programs. It is an auto-generated gRPC/Protocol Buffers client that integrates with Google::Auth for Application Default Credentials and lets you choose between gRPC and REST transports. The library exposes high-level methods such as generate_content, embed_content, batch_embed_contents, and count_tokens so you can create text, produce embeddings, run bulk embedding requests, and estimate token usage without dealing with low-level RPC plumbing. It is intended for Perl developers who want to add AI-powered text generation or embedding functionality to their applications and is released under the Apache 2.0 license. The bundled documentation notes a couple of POD formatting errors, but the client functionality itself targets standard Google Cloud authentication and transport workflows.

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.