CPANscan

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.

App::BPOMUtils::RPO::Ingredients provides a command line utility and an exportable function to turn a CSV of product ingredients into a label-ready, grouped ingredient list for Indonesian processed food registration. You give it a simple CSV on stdin and it merges ingredient groups, inner ingredients, QUID values and notes into human readable entries in either Indonesian or English, with an option to control QUID precision. The tool emits a compact Ingredient,%weight CSV suitable for product labels and returns an enveloped result array with HTTP-like status codes and metadata so it can be integrated into scripts and pipelines. It is useful for food manufacturers, label preparers and regulators working with BPOM RPO ingredient declarations.

App::sdif bundles a small suite of command line tools that make diffs easier to read and monitor, most notably sdif for side-by-side diff output, cdif for visually highlighting changed words or characters, and watchdiff for repeatedly running a command and emphasizing what changed between runs. It is aimed at anyone who reviews code or tracks changing text on the terminal and can be plugged into git as a pager so diffs and logs render with nicer, in-context highlighting. The tools support extra tokenization via mecab for better word boundaries in languages like Japanese and are distributed on CPAN for easy installation with cpanm.

RPi::Const is a small utility module that collects and exports the named constants used by the RPi::WiringPi family so you can write clearer Raspberry Pi GPIO code without scattering magic numbers. You can import everything or pick tagged groups such as pin-numbering modes, pin direction and pull-up settings, pin states, PWM mode and defaults, interrupt edge types, and MCP23017 expander registers and pin names. The module only supplies constant values and does not perform any hardware access or control. Note that the suite intentionally does not provide a physical-pin setup constant.

Net::Whois::IP is a Perl helper for looking up WHOIS information about IP addresses by recursively querying registries until it finds detailed contact data such as technical phone numbers. In scalar context it returns a parsed hash of fields for the best result and in list context it can return the full chain of responses from each lookup. You can request raw unparsed responses or enable a mode that preserves all duplicate field values as arrays, and there is an advanced option to override which fields are used in searches though that can break lookups if used incorrectly. For ARIN queries the module may prepend synthesized parent records derived from ARIN summary output and tag them as ARIN-SUMMARY, and those synthesized entries may contain fewer fields than full WHOIS records. This module is suitable for network operators and developers who need programmatic access to IP ownership, contact and allocation details.

WWW::Mechanize is a Perl module that gives you a programmable, stateful web browser for automating interactions with websites. It builds on LWP::UserAgent and adds high level support for finding and following links, filling and submitting HTML forms, automatic cookie handling, SSL, custom headers, redirects, proxies and HTTP authentication, plus a navigable history of visited pages. That makes it a handy tool for web testing, screen scraping and small web robots because you can script sequences of GETs and POSTs, select forms by name or fields and extract page content, links and images without parsing raw HTML yourself. It is not a full browser replacement so it does not execute JavaScript and you will need additional tools if you must interact with JS-driven pages.

JMAP::Tester::WebSocket is a small testing client that wraps JMAP::Tester to talk to JMAP servers over WebSocket. You create it with a ws_api_uri and use its request method to send JMAP method calls and receive parsed responses, making it easy to write automated tests against a server's JMAP implementation. It supports optional logging of requests and responses via the JMAP_TESTER_LOGGER environment variable and includes a configurable timeout (30 seconds by default) to avoid hanging tests. The current release requires JMAP::Tester 0.110 so it can take advantage of improved diagnostic dumping and an abort method on result objects, which helps surface richer debugging information during test runs.