CPANscan

YAML::LibYAML is the Perl binding (distributed as YAML-LibYAML and better known as YAML::XS) that gives you fast, robust YAML parsing and generation by wrapping the libyaml C library with XS. It provides familiar Load and Dump routines and file helpers so Perl programs can read and write YAML efficiently while handling anchors, aliases, tags, regexps, tied variables, Unicode, and various Perl types including blessed references when explicitly allowed. The module is actively maintained with security-conscious defaults such as disabling automatic loading of blessed objects and recent fixes for YAML 1.2 compatibility, boolean handling, and several memory and parsing bugs. Use it when you need a high-performance, well-tested way to serialize or parse YAML from Perl and when you want explicit control over object loading and the latest libyaml behavior.

Weasel::Driver::Selenium4 is a lightweight adapter that lets the Weasel browser-automation framework drive real browsers via Selenium WebDriver 4 by wrapping Selenium::Client, providing the standard Weasel driver operations like navigating pages, finding elements, clicking, double-clicking, typing, executing scripts, taking screenshots and waiting for conditions. It exposes simple configuration for Selenium capabilities, window_size and a millisecond wait_timeout and includes helpers to update the timeout and window size on a running session, while capability changes take effect after restarting the session. Use this module when you are working with the Weasel test framework and need a ready-made Selenium 4 backend for browser-based tests.

Syntax::Infix::ConditionalSplice provides a lexically scoped infix operator ?| that makes it trivial to conditionally splice elements into a list, so you can write things like $verbose ?| '--verbose' inside an argument list instead of the noisier COND ? LIST : (). The operator short-circuits so the right-hand expression is only evaluated when the condition is true, and it is context-aware so in list context it flattens the supplied list into the surrounding list while in scalar context it returns the list's last value or undef when false. The operator has sensible precedence relative to commas and logical operators and you can parenthesize the right side to include multiple elements. Note that it relies on Perl 5.38 or newer and will not install on older Perl releases.

Syntax::Infix::OptionalChain provides a lexically scoped infix operator "?->" that implements safe navigation in Perl so you can walk into objects, hashes and arrays and get undef instead of a fatal error when a link in the chain is missing. The right-hand bareword is resolved at runtime so if the left value is a blessed object with that method it calls the method, if it is a HASH reference it performs a key lookup, and if it is an ARRAY reference it treats the bareword as a numeric index; an undef left-hand operand causes an immediate undef result and no autovivification happens. Blessed hashrefs or arrayrefs fall through to structural access when the method does not exist, defined but non-navigable values croak, and the operator pairs naturally with // for defaults. Note that the right-hand side must be a compile-time bareword so you cannot pass arguments, compute keys, or use negative indices. The module is implemented on top of Infix::Custom with an XS navigator, requires Perl 5.38 or newer, and this release is the initial 0.01.

Infix::Custom lets you declare your own binary infix operators in Perl so expressions like "a OP b" can be made to call a Perl sub, act as a native binary operator, or be handled by a C-level builder, and those operators are recognized and lowered at compile time so there is no added runtime parsing cost beyond the work of the operation itself. You register a glyph and choose a lowering mode: call mode maps the infix to a Perl sub, method mode treats the right hand side as a bareword to enable natural looking safe-navigation like "?->", and binop mode maps directly to a built-in operator for zero call overhead. Declarations are lexical so operators only apply where imported and can be rebound or removed in nested scopes. There is also an escape hatch for XS authors to build custom optrees at C level. This requires Perl 5.38 or newer because it relies on the core infix plugin hook, so use it when you want readable, compile-time custom operators with predictable performance.

Perl::Critic::Policy::ControlStructures::LoopsRequireLabels is a Perl::Critic policy that enforces explicit labels on loops and on loop-control keywords like next, last, and redo so the target of a break is always obvious and less likely to break during refactoring. It offers three modes: always, which requires labeled loops and labeled break keywords everywhere; nested, the default, which requires labels for loops that are nested or whose body exceeds a configurable max_lines threshold; and max_lines, which only enforces labels when a loop body is longer than the configured line count. The policy also treats continue blocks as part of their loop and flags bare breaks when any ancestor loop carries a label to avoid ambiguous targets. Configure it in your perlcriticrc to tighten control-flow clarity in codebases where nested loops or long loop bodies make break targets hard to track.

Gherkin is the Perl implementation of the Gherkin language parser and compiler used by the Cucumber project. It reads feature files (including support for Markdown-based Gherkin in recent releases), parses them according to the official grammar, and emits a stream of Cucumber::Messages protobuf objects encoded as NDJSON so other tooling in the Cucumber pipeline can consume them. The module exposes streaming APIs such as from_paths and from_source that accept a user-supplied id generator and a sink callback to receive Envelope messages, and you can choose whether to include the original source, the parsed AST, or the compiled "pickles" in the output. It handles source encodings, is intended for building higher-level Cucumber tools in Perl, and since version 22 it emits Cucumber::Messages objects instead of plain hashes. The project is actively maintained, ships under the MIT license, and is a good fit if you need robust, language-compliant Gherkin parsing in Perl.

Cucumber::Messages is a Perl library that implements the Cucumber messaging protocol and makes it easy for Perl programs to produce and consume the NDJSON event stream used across the Cucumber ecosystem. It provides in-memory classes for every message type—envelope, source, gherkin AST, pickles, test cases, step results, attachments and more—plus simple serialization and parsing helpers so you can call methods like to_json on objects or Envelope->from_json on NDJSON lines. Use it when you need to integrate Perl tools with Cucumber formatters, test runners or CI pipelines, or when you want structured access to attachments, timestamps and other test metadata; the library also supports externalized attachments to avoid embedding large binaries and is released under the MIT license.

Algorithm::QuadTree::XS is a high-performance XS (C) backend for the Algorithm::QuadTree family that gives you a drop-in, compatible replacement for the pure-Perl implementation and is used automatically when available. It provides the same quadtree API so you can index and query 2D shapes like rectangles and circles without changing your code, while delivering much faster insert and search operations and dramatically reduced tree-clearing time in recent releases. If your application needs spatial indexing or collision-style queries and the pure-Perl version feels slow, this module provides a straightforward way to get a significant speedup with minimal fuss.

Algorithm::QuadTree is a pure-Perl spatial index that stores rectangular and circular objects in a hierarchical quadtree so you can rapidly find everything that intersects a given rectangular or circular region. You create the tree by giving map bounds and depth, add objects (as rectangles or circles) with add, and then use getEnclosedObjects to retrieve items that overlap a query area; objects can be removed or the whole tree cleared and you can set a window and scale to support zoomed views. The module uses a pure-Perl backend by default but will use an optional XS backend if installed for better performance. It is handy for fast region queries and simple collision detection in canvases or map-like data, and note that you are responsible for providing unique object identifiers if you need them to be distinct.

App::CommonPrefixUtils provides small command line tools and supporting functions for finding and manipulating common prefixes in lists of strings, including the utilities common-prefix, majority-prefix, remove-common-prefix and strip-common-prefix. It is useful when you need to detect the longest shared starting substring across many labels or filenames or to derive a prefix that is shared by the majority of items and then optionally remove or strip that prefix. The included library functions common_prefix and majority_prefix return an enveloped result designed for programmatic use, using an HTTP-like status code, a human-readable reason, an optional payload with the computed prefix, and optional metadata. The 0.002 release added the common-prefix and majority-prefix CLI wrappers to make these operations directly available from the command line.

Switch::Declare provides a compile-time, lexically-scoped switch/case keyword for Perl that lowers the whole construct to ordinary Perl ops so there is no runtime parser overhead. You write switch (EXPR) { case ... { ... } default { ... } } and the scrutinee is evaluated exactly once, the first matching case wins, and there is no fallthrough. Cases support a compact, predictable pattern grammar including numeric and string literals, regexes, ranges and lists, predicate subs, ref/reftype and isa checks, named constants, runtime comparisons and runtime regexes, and you can destructure the matched value into fresh lexicals with -> PATTERN for convenient per-arm bindings. The implementation is undef and type safe so non-matching or undef inputs do not warn or miscompare, and common string-only switches are automatically lowered to a static hash lookup for fast dispatch. Performance is close to hand-written if/elsif chains for most patterns, with numeric comparisons paying a small extra cost for safety, and the compile-time lowering keeps the generated code tight and efficient. If you want a readable, safe, and performant switch construct that integrates with Perl scoping and offers destructuring it is likely a good fit.

Graphics::Toolkit::Color is a high‑level Perl API for creating, converting and manipulating colors and color sets aimed at colors for screen output. You build lightweight, read‑only color objects from names, hex, CSS strings, numeric tuples or many named formats, then convert them between dozens of color spaces, format their values for output, check gamut validity and look up or approximate human‑readable color names. It also provides practical color operations such as mix, invert, add_value/set_value and a suite of convenience modifiers to lighten, darken, saturate, desaturate, tint, shade and tone, plus generators for gradients, complements, analogous palettes and clusters of similar colors. The module emphasizes perceptual correctness by using RGB as the I/O format while performing many calculations in perceptually uniform spaces like OKLAB or OKHSL, supports many RGB profiles and modern spaces, offers multiple output formats and an is_in_gamut helper, and ships with no runtime dependencies. The recent 2.20 release is a notable feature bump that added the HSL‑family OKHSL/OKHSV/OKHWB spaces, the new lighten/darken/saturate/desaturate/tint/shade/tone methods, improved docs and more flexible error handling, making it easier to produce visually consistent color manipulations.

Destructure::Declare installs a compile-time, lexically scoped let keyword that makes it easy to unpack arrays, hashes and lists into real my variables using simple pattern syntax. Array patterns [ ... ] treat the right-hand side as an arrayref, hash patterns { ... } treat it as a hashref and ( ... ) destructures a list in list context. The module supports nested patterns, per-slot defaults that use // and are evaluated lazily, holes to skip slots, and trailing slurpy captures like @rest and %rest for remaining elements or keys. The right-hand side is evaluated exactly once and the entire pattern is parsed at compile time and lowered to ordinary lexical declarations so runtime overhead is minimal, and flat patterns can lower to a single native list assignment for hand-written assignment speed. The distribution also publishes its compile-time engine for reuse by other modules. This is the initial 0.01 release implementing these features.

JSON::Schema::Modern is a Perl evaluator and validator for JSON Schema that implements the official specification up to Draft 2020-12, letting you validate either Perl data structures or JSON strings and get back a rich Result object describing success, errors, annotations and defaults. It supports multiple schema versions, configurable behavior such as short-circuiting, default population, optional string-to-number and scalarref-boolean handling, format and content-schema validation, and extensibility via custom format validators, media types, encodings, vocabularies and callbacks, plus utilities to add and cache schemas or traverse and validate schemas themselves. The module is suitable for integrating strict JSON Schema validation into Perl applications and works well with tools like OpenAPI::Modern, but it does not automatically fetch schemas from disk or the network, some format checks require optional CPAN modules, and you should avoid running untrusted schemas because pattern evaluation and certain numeric operations can pose security risks.

JSON::Schema::Tiny is a compact Perl validator that checks Perl data structures against JSON Schema rules, offering both a simple functional interface and an object-oriented API. It covers the most commonly used keywords and returns either a boolean pass/fail or a detailed result with standard JSON Schema error locations, making it handy for quick validation right after decoding JSON. You can tweak behavior with globals or constructor options such as short-circuiting, allowing numeric strings, and limiting traversal depth to avoid accidental recursion. It intentionally omits some advanced JSON Schema features and external $ref resolution to stay small and fast, so very complex schemas or cross-document references are not supported. Be aware that schema regular expressions are used as-is, so do not run schemas from untrusted sources. If you need full specification compliance, consider a heavier implementation such as JSON::Schema::Modern.

Hypersonic is a Perl micro HTTP server that JIT‑compiles C code so the hot path runs in native code for extreme throughput. You define routes in Perl, call compile() to generate and compile the C event loop and baked responses, then run() the server; static handlers execute once at compile time and are embedded as C constants while dynamic routes still run Perl per request and can be augmented with custom JITed C handlers. It provides optional TLS, gzip compression, streaming and SSE, full WebSocket support including broadcast rooms, sessions, middleware, and a JIT async thread pool, making it a good fit for high‑performance APIs, static asset delivery, and low‑latency real‑time services. Because it relies on XS::JIT and native libraries such as zlib and OpenSSL and requires a compile step, it is most useful when your routes and behavior are known ahead of time and you are willing to accept native code generation rather than a purely interpreted runtime.

DBIx::Class::Relationship::ManyToMany::Async provides asynchronous many-to-many accessors for DBIx::Class by generating Future-returning methods that work with DBIx::Class::Async worker pools. You declare the usual has_many pivot and belongs_to target relationships and then call many_to_many_async to create an accessor like groups plus helper methods add_to_groups, remove_from_groups and set_groups. The read accessor returns a Future that resolves to an arrayref of target objects and the mutators return Futures that resolve when the pivot rows have been created, removed or replaced. The module assumes the target table has a primary key named id and may need proper SQL quoting if your relationship name is an SQL reserved word. This is an experimental initial release extracted from a Mojolicious plugin so the API may change, but it is useful if you need nonblocking many-to-many helpers for DBIx::Class::Async.

Plerd is a minimalist static-blog generator that turns Markdown files stored in a Dropbox-synced directory into a ready-to-serve website. It uses Template Toolkit templates to render posts, generates syndication feeds, and maintains a small index so post ordering, recent-post lists, tag pages, and prev/next links are correct. The tool can republish the entire site or run incrementally so changes to a single file are handled efficiently, and recent updates write files atomically to avoid serving half-written pages. Plerd also includes features for tags, social-media metadata, JSON Feed and RSS, optional webmention support, and MultiMarkdown compatibility. If you want a simple, file-based blogging workflow without a database or heavy CMS, Plerd makes it easy to author posts in Markdown and publish them via a Dropbox-backed directory.

Mojolicious::Plugin::BarefootJS integrates the BarefootJS server runtime into a Mojolicious application by registering a "bf" controller helper that provides a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo. It lets you render compiled BarefootJS marked templates as normal Mojolicious templates and installs the supporting hooks so rendering happens smoothly within each request. If you prefer a framework-free setup, the same runtime can be driven with BarefootJS::Backend::Xslate and Text::Xslate. The plugin is lightweight, focused on wiring the runtime into Mojolicious, and is available under the MIT license.

BarefootJS::Backend::Xslate provides a simple bridge that lets the BarefootJS runtime render Kolon-style Text::Xslate templates. It can take an existing Text::Xslate object or build one from a list of template paths, binds the runtime into templates as the bf variable so helpers are invoked naturally, and configures Xslate for HTML auto-escaping while offering a mark_raw mechanism for helper-produced markup. You can override the JSON encoder if needed and call render_named to render a named .tx template with variables. Because it has no web-framework dependency it runs under PSGI/Plack or in standalone scripts and pairs cleanly with the @barefootjs/xslate compile-time adapter that emits templates expecting the bf runtime.

BarefootJS is a lightweight server runtime for rendering BarefootJS templates that were compiled from JSX/TSX into marked templates and accompanying client JavaScript. It intentionally stays framework and engine agnostic and delegates framework-specific tasks like JSON marshalling, raw-string marking, children handling, and named-template rendering to pluggable backends so the same runtime can drive different Perl rendering stacks. Out of the box it has backends for Text::Xslate and Mojolicious and it only pulls in noncore template or web framework code when a backend requires it, keeping the core minimal and easy to embed in PSGI/Plack or Mojolicious applications. If you need to render BarefootJS templates from Perl across multiple frameworks or want a backend-driven, low-dependency approach, this module provides that and is actively maintained with releases through 2026.

WWW::Gitea is a lightweight Perl client for the Gitea REST API that makes it easy to script and automate common operations on a self hosted Gitea instance. Built with Moo, it exposes resource controllers for repositories, issues, pull requests, labels, milestones, releases, organizations and users so you can do things like create a repo, open or comment on an issue, create and merge a pull request, or publish a release with simple method calls. Authentication works with a personal access token or basic auth and the client will derive the API base URL from the instance root you provide or from environment variables like GITEA_URL and GITEA_TOKEN. Calls return small entity objects wrapping the decoded JSON while keeping the raw data available, and internal operation tables are precomputed so there is no OpenAPI parsing at runtime. If you need a straightforward programmatic interface to manage Gitea resources from Perl, WWW::Gitea provides an intuitive, minimal layer over the API.

Dist::Zilla::PluginBundle::Author::GETTY is a ready-made Dist::Zilla configuration that encodes the packaging, metadata, versioning and release practices used by the CPAN author GETTY, so you can build and release Perl distributions with a consistent, automated workflow. It wires together common plugins to generate META and POD, manage versions and changelogs, run pre and post build or release commands, and integrate with GitHub or self-hosted Gitea for repository metadata and release creation. The bundle also supports XS and Alien-based C libraries, optional Docker image builds, control over what files are shipped, and flags to skip CPAN uploads or other steps, while exposing many attributes for fine-grained customization. A companion GitHub Action and CI guidance make it easy to reproduce the same authoring and test environment across projects, which makes this bundle a good fit for Perl authors who want a well-tested, configurable release pipeline without hand-crafting every Dist::Zilla plugin.

Crypt::OpenSSL::PKCS12 is a Perl wrapper around OpenSSL's PKCS12 API that makes it straightforward to read, create and manipulate PKCS#12 files used to bundle private keys, X.509 certificates and CA chains. You can load a .p12/.pfx from a file or string, extract certificate, CA chain and private key as base64 or raw output, verify the MAC, change passwords, and create PKCS12 output either to disk or as a string. It can also reproduce OpenSSL's pkcs12 -info output and deliver a parsed representation as a Perl hash for scripts that need to inspect a file's internal structure. The module supports OpenSSL 1.x and 3.x and requires a standard OpenSSL installation and Perl 5.8 or newer, so it is a handy choice when you need to automate certificate packaging or integrate PKCS#12 handling into Perl tools.

MCP is a Perl SDK that implements the Model Context Protocol so you can expose Perl tools, prompts and resources to AI systems with minimal fuss. It lets you register named tools with descriptions, JSON Schema-validated inputs and handler code, then serve them over HTTP in a Mojolicious app or run a local stdio transport for testing and command-line use. The module supports structured, image, audio and resource results, sessions, notifications and optional streaming, and it integrates authentication hooks so your application can enforce access controls. Recent updates add OAuth 2.0 scope support so MCP servers can act as resource servers and provide finer-grained scope checks; note that server-to-client streaming is opt-in and not compatible with prefork web servers. If you want a Perl-native way to connect text-processing code to modern AI workflows with schema validation, session management and optional streaming, MCP is a good fit.

Win32API::File::Time is a small Perl module that gives you direct control over file timestamps on Windows, letting you read and set a file's creation, modification, and access times. It exposes GetFileTime and SetFileTime and can override Perl's built-in utime so you can update timestamps even on open files, read-only files, and directories by calling the Windows SetFileTime API. You can update only the fields you care about by passing undef or 0 for times you want to leave alone, and the calls return standard success or failure values with errors available in $^E. Be aware that calling GetFileTime itself counts as an access and may change access time, FAT filesystems have coarse time resolution, and some wide-system-call code paths and Windows testing are limited by the author's environment. The author maintains the module and accepts bug reports and offers for co-maintainership via the project GitHub.

Astro::Coord::ECI::TLE::Iridium is a Perl subclass of Astro::Coord::ECI::TLE that models the original-design Iridium satellites and predicts their reflective "flares" for a ground observer. It parses TLE data and reblesses known Iridium vehicles, computes when and where specular or non-specular reflections occur, estimates apparent magnitude with optional atmospheric extinction, and returns detailed flare records including time, azimuth, elevation, magnitude, antenna, virtual image and status. You can control which flare types to report and use satellite status data from SpaceTrack or canned tables. The author warns this is specific to the legacy Iridium hardware and will not work for Iridium Next, it has geographic and platform limits (not beyond about 85 degrees latitude or for non‑fixed stations), and flare functionality is now largely historical because the flaring fleet has been retired. Recent updates were packaging and metadata fixes only and made no functional changes.

JSON::JSONFold reformats pretty-printed JSON into a more compact, readable layout that reduces unnecessary vertical space in arrays, objects and simple nested structures. It can be used as a simple functional API, an object-oriented formatter, a streaming post-processor that writes folded output without buffering the entire document, or as a drop-in replacement for JSON::encode_json and JSON::to_json. Configuration options let you control target line width, indentation, key sorting and preset compacting behavior, and the module can write results to filehandles and return formatting statistics. Use JSON::JSONFold when you want human-friendly JSON that is denser and easier to scan than conventional pretty printing.

pEFL is a Perl binding for the Enlightenment Foundation Libraries that lets you build EFL-based graphical and event-driven applications from Perl using an object oriented API that stays close to the original C calls. It exposes Elementary, Evas and Ecore functionality so you can create windows, widgets, callbacks and events, and it provides Perl-friendly variants of functions (suffix _pv) that return Perl arrays or bless returned objects into the appropriate classes. Helpers such as ev_info2obj and ev_info2s convert C event info into usable Perl values and output parameters from C methods are returned as multiple Perl return values to keep the interface natural for Perl programmers. The binding is described as stable and well tested and aims to follow the C documentation closely, though some advanced features like creating SmartClasses in pure Perl are not yet available. Documentation and examples are available with the distribution and the source and issue tracker are on GitHub.