CPANscan

WebService::Client is a lightweight Moo role that wraps common HTTP client boilerplate so you can build API-specific clients quickly. Compose it into your class, set the required base_url and any auth headers in BUILD, and you get convenient get, post, put, patch, delete, head and options methods that handle request construction, optional JSON serialization via JSON::MaybeXS, and response deserialization for you; by default these methods return decoded Perl data structures while a special "v2" mode returns a Response object. The role provides a default LWP::UserAgent, accepts settings like timeout, retries, logger, content_type, array_query_style (php or rfc) and custom serializer/deserializer coderefs, and it raises HTTP::Response exceptions for error responses except that GETs returning 404 or 410 yield undef. If you need a simple, tested foundation for talking to RESTful services this role saves you from rewriting the same request, header and encoding handling, and the recent 1.0100 release added head and options support and improved header, content-type and query-encoding behavior.

Lemonldap::NG::Portal is the portal component of the Lemonldap::NG Web‑SSO system that provides a ready-made, extensible way to handle web authentication, authorization and accounting for protecting web applications. It runs as a PSGI/Plack application and wires together configurable authentication backends, user databases and optional plugins so you can add LDAP, CAS, Apache auth, multi‑auth setups, password management, notifications and second‑factor modules without rewriting your apps. The portal manages sessions, produces headers for downstream applications, supports AJAX JSON responses or HTML templates, and reloads configuration and plugins cleanly at runtime. If you need a mature, plugin‑driven single sign‑on portal to centralize login, access control and session handling across multiple web services, this module is directly relevant and provides the hooks and documentation needed to customize authentication and UserDB plugins. Recent development added more flexible auth and userDB modules, password plugin support and notification and session handling improvements.

Lemonldap::NG::Manager is the web-based administration interface for the Lemonldap::NG Web-SSO platform, implemented as a PSGI/Plack REST server with an AngularJS front end. It exposes a documented REST API and bundles front-end static files plus tools to generate configuration trees, making it easy to manage sites, virtual hosts, SAML and OIDC partners, sessions, notifications and second-factor settings from a browser. You can run it with plackup or any Plack launcher and override settings via the lemonldap-ng.ini file or by passing an options hash to run(), with manager-specific options for access protection, enabled modules, languages, logging and template locations. The distribution also includes a configuration builder and CLI helpers for automation and a script to pre-generate the static structure used by the UI. Note that older SOAP support was removed and replaced by the portal/REST approach as of the 0.9 series.

Lemonldap::NG::Handler is the Apache protection module of the Lemonldap::NG Web Single Sign-On system and here serves as an alias for the ApacheMP2 implementation. It plugs into Apache to protect web resources, enforce SSO and session rules, perform redirects and logins, and integrate with the Lemonldap::NG manager and shared configuration so you can centrally control access across sites and virtual hosts. The project supports Apache 1 and 2 environments and common deployment needs such as CGI handling, proxying, cross-domain authentication, logout coordination, and features added in recent releases like SOAP-based basic auth, POST-based login for non‑compatible apps, enhanced logging, and a double-session mechanism. The module is GPL‑licensed and is maintained by the LemonLDAP::NG team; use the project site and OW2 issue tracker to download it or report bugs.

Lemonldap::NG::Common is the shared resource package for the Lemonldap::NG Web single sign-on system, providing the common configuration files, templates and support scripts used by the Manager, Portal and Handler components. It is not a standalone SSO service but a required part of a Lemonldap::NG deployment or customization, so install it when you are setting up or extending Lemonldap::NG on Apache to keep components consistent and avoid duplicating common assets. The project is open source under the GNU GPL and you can find downloads and report issues via the Lemonldap::NG and OW2 GitLab pages.

App::karr is the core library behind the karr command line tool that implements a Git-native kanban board stored under refs/karr/*. Tasks are Markdown payloads with YAML frontmatter and board configuration is kept sparsely in refs rather than as files in the working tree. Commands materialize a temporary view, let you create, move, claim and log cards, then serialize changes back into Git refs so the repo stays free of a persistent board tree and ordinary file-level merge conflicts are avoided. The distribution exposes reusable components for automation such as App::karr::Git for low-level ref work, App::karr::BoardStore for loading and saving tasks, and App::karr::Task for task objects, and it ships the karr CLI and Docker runtime images for running agents or embedding karr into other environments. Use this when you want your issue or kanban state to remain Git as source of truth without adding tracked files to the project. The recent 0.500 release focuses on robustness and interoperability, fixing UTF-8 handling, making restores and ref writes atomic, strengthening concurrency with compare-and-swap for id allocation and log writes, improving locking and board-identity checks to avoid accidental wipes, and generally hardening the tool for multi-clone and automated-agent use.

Lingua::Generic::Interface is a lightweight Perl abstraction that defines a common, language-agnostic API for accessing and manipulating linguistic data, letting you write tools that work with different languages or backends without changing application logic. The module itself does not perform language processing but specifies the standard methods and behaviors that language-specific implementations can follow so they interoperate cleanly. This is useful when building multilingual pipelines, adapter layers, or plugin systems that must remain agnostic to particular language resources. The package is an initial release (v0.01) and is distributed under the Artistic License 2.0.

Mozilla::CA provides a ready-to-use copy of Mozilla's trusted Certificate Authority bundle in PEM format so OpenSSL-based Perl modules can verify TLS server certificates; the module exports a single function, SSL_ca_file(), which returns the absolute path to the bundled PEM file for use with clients like IO::Socket::SSL or LWP::UserAgent to enable standard certificate validation and hostname checks. The bundle is regularly updated from Mozilla, most recently refreshed on 2026-08-13 with additions and removals of root certificates to reflect current trust decisions. The distributed CA data and the module are licensed under the Mozilla Public License 2.0.

MCP::Run is a Perl base class that makes it simple to expose a command-execution tool over the MCP protocol so other processes can ask the server to run shell commands and receive exit code, stdout, and stderr. It registers a configurable "run" tool that accepts a command plus optional working directory and timeout, and subclasses provide the actual execution by implementing an execute method; MCP::Run::Bash is the provided ready-to-use implementation that runs commands under bash. The module offers security and policy hooks via an allowed_commands whitelist and a validator coderef, lets you set sensible defaults for working directory and timeout, and provides a format_result hook to control the returned text. It also integrates optional output compression and filtering aimed at making command output more compact and LLM-friendly, and it includes convenience entry points for running as a stdio MCP server or installing compression hooks. The recent 0.104 release cleans up compressor behavior by normalizing undef streams and avoiding warnings when transforms drop lines, and it fixes filter resolution so the most specific command filters reliably win.

OpenAPI::Modern lets you validate HTTP requests and responses against an OpenAPI v3.0, v3.1 or v3.2 document at runtime. It loads your OpenAPI spec and uses the JSON::Schema::Modern evaluator to check request and response bodies, headers and parameters, returning a structured result object with a pass/fail flag, detailed error locations and the deserialized data extracted from the message. It works natively with Mojolicious message objects and can convert common framework request and response types, supports multipart bodies, media-type content encoding, bundled metaschemas and caching for large specs, and offers options for debugging and populating defaults. This module is useful for API servers, clients and test suites that need automated conformance checks or runtime introspection. Note that message parsing is performed with Mojolicious objects so parsing raw network messages into Mojo::Message is recommended, a few uncommon OpenAPI features are not yet implemented, and the module does not itself enforce Authorization header schemes.

require::relative is a tiny Perl helper that lets you require files using relative paths, so you can pull in a nearby script such as a shared test helper without converting to an absolute path or fiddling with @INC. It is aimed at test suites and other situations where multiple files share configuration or setup, and lets you include those shared files with a simple use require::relative "../test-helper.pl".

Device::Chip::BME280 is a Perl driver for the Bosch BME280 environmental sensor that talks to a host over I2C. It builds on the BMP280 driver to add humidity support while inheriting temperature and pressure features, and it is designed for asynchronous use returning Future objects for operations such as mounting an adapter, reading converted sensor values with read_sensor (pressure in Pascals, temperature in degrees Celsius, humidity in percent) and reading raw ADC values for testing with read_raw. You can read or change chip configuration including humidity oversampling via OSRS_H and mount with a non-default I2C address if needed. Recent updates also add automatic handling of BMP280 variants and detection of failed sensors that report all-zero ADC readings.

Text::Hogan is a Perl port of Twitter's hogan.js that brings Mustache templating to Perl by compiling templates into pure Perl code for very fast rendering. It implements the full Mustache specification, including lambda sections, and aims to behave statement-for-statement like hogan.js so templates are portable between the JavaScript and Perl ecosystems. The module is useful when you need simple logic-less templates, want to precompile templates for repeated high-performance rendering, or require compatibility with existing hogan templates. Recent releases focus on modernizing dependencies and improving compile and runtime speed, so it is a mature, actively maintained choice for Mustache templating in Perl.

Scalar::ValueTags lets you attach metadata to Perl scalar values so that provenance or other annotations travel with the value whenever it is assigned or combined with other values. You register a value-tags type that defines how tags are stored and merged and then use simple functions to add, remove, query, or clear tags; available behaviors include unique string sets, counted hashes, append-only arrays, and de-duplicated reference arrays so you can choose the merging and storage model that fits your needs. It is useful for tracking data flow, auditing, or applying source-based access logic without changing the underlying data structures. The implementation relies on Perl core value-magic (Magic v2) so you should check value_tags_enabled to confirm support on your Perl build. The author notes that the module currently does not throw automatically if value tags are unavailable and that debugging support is not yet implemented.

Dist::Starter is a lightweight command-line utility for bootstrapping Perl distribution skeletons from reusable templates, providing a diststarter script that accepts a distribution or module name and fills a template with sensible defaults for abstract, author, license, minimum Perl version, initial version and more. It can derive author info from the system GECOS, git config or environment variables, supports custom template and output directories, and offers a dry-run mode that prints the generated context as YAML so you can inspect values before writing files. Defaults are configurable via an XDG-style run-control file and templates can include additional "share" placeholders for richer scaffolding. The module is currently alpha and still documents a few TODOs, and the recent 0.2.0 release added license and initial-version options, improved author info handling, introduced share placeholders and now normalizes a provided module name to a distribution name.

Acrux is a compact Perl utility collection that supplies building blocks for application development, offering logging, file locking, a Damm checkdigit/digest implementation and small helpers for parsing and formatting so you do not have to reinvent common chores. It is presented as a companion to Acme::Crux and aims to be a lightweight, practical toolkit for developers who need simple, well scoped services such as configurable logging backends, lock file management and utility routines. Recent updates added a richer file lock metadata (including owner UID) and an optional system-level flock mode, and the logging defaults were changed to STDERR with explicit options to target stdout, stderr or syslog if needed. The project is actively maintained and distributed under the Artistic License 2.0, so Acrux is worth a look if you want straightforward, reusable utilities to support Perl applications.

Business::NAB is a Perl namespace that bundles a set of modules for reading and creating the file formats used to exchange payments and reports with the National Australia Bank. The top‑level package itself does not implement logic but links to focused modules for BPAY batch payments and remittance files, Australian Direct Entry payments, returns and reports, account information (NAI/BAI2) files, and XML acknowledgements. A companion Types package provides reusable type constraints for the namespace. Use this distribution when you need to build, parse, or validate NAB interchange files from Perl, and note the project is open source with source and contribution information available on GitHub.

IO::K8s provides typed Perl objects and serialization tools that model the Kubernetes API so you can build, validate, serialize and deserialize Kubernetes resources with correct JSON types and predictable structure. It lets you create API objects programmatically, inflate JSON or Perl hashes into typed objects, load and validate YAML manifests (including multi-document files), export to YAML or JSON, and extend support for Custom Resource Definitions either by writing small APIObject-based classes or by auto-generating classes from a cluster OpenAPI spec. The module also supports pluggable resource maps so third-party CRD providers like Cilium can be merged in, and it includes a compact Perl DSL for manifest files (.pk8s) when you prefer code over YAML. IO::K8s uses Moo for light, fast classes and is designed to work with Kubernetes::REST for sending requests to clusters. Noteworthy in the recent 1.105 release is the removal of legacy individual *List classes in favor of the unified IO::K8s::List and a full sync to Kubernetes v1.36 plus related CRD provider updates; if you still depend on the old list class names install IO::K8s::Deprecated for compatibility guidance.

CXC::Astro::Regions is a Perl library for describing and manipulating the geometric "regions" astronomers use to mark sources and areas of interest in image and data analysis, making it easy to generate DS9, CIAO, and CFITSIO style region descriptions from Perl code or to convert between those formats. It targets common tasks such as building region files, applying region-based filters to data, and integrating region definitions into processing pipelines, and it includes format-specific helpers (CXC::Astro::Regions::DS9, ::CIAO, ::CFITSIO) so you can produce output compatible with popular astronomy tools. A recent enhancement adds CFITSIO support for using circle, box, and ellipse regions as FITS row-filter functions with extra parameters for column names, and note that a prior release renamed several DS9 parameter names which may require updating older scripts.

Perl::Critic::Policy::PreferredModules is a configurable Perl::Critic policy that lets teams declare which modules should be preferred, discouraged, or banned and optionally provide replacement suggestions and explanations. You enable it from your .perlcriticrc and point it at a Config::INI file where each section names a module or a builtin function and can include keys like prefer, reason, severity and message, plus a for list to limit a recommendation to specific functions. The policy understands partial replacements so you can recommend a writer-only drop-in while leaving readers alone and it inspects import lists and actual calls to determine whether a use of a module or a builtin should be reported. It also handles parent/base and conditional loads via use if so those cases are not silently missed. To be precise about whether a preferred module actually exports a symbol the policy may load that module or parse its source as a fallback, which requires running Perl::Critic with the --allow-unsafe flag for the loading behavior to be enabled, otherwise the policy is skipped for those checks.

Music::Scales generates musical scales from a given keynote and scale name and returns them as note names, MIDI note numbers, PDL-format strings, or as semitone-offset hashes. It supports ascending and descending forms for direction-sensitive scales such as melodic minor and recognizes about 30 built-in scales and modes with abbreviated name lookup. The module attempts sensible enharmonic spellings based on the key, offers a user override for sharp or flat preference, exports its functions and core scale lists by default, and includes an is_scale helper to validate names. Recent updates focused on documentation and packaging while earlier releases added MIDI and PDL output. The author notes a few remaining enharmonic edge cases.

PAGI::FastAPI::RateLimit::Driver::Redis is a Redis-backed storage driver that lets PAGI::FastAPI rate-limiting middleware keep centralized hit counts across multiple workers or servers. It requires you to pass an existing Redis client and works with common clients such as Redis, Redis::Fast, or Mojo::Redis. The driver uses Lua scripts so increments and TTL setup are performed atomically, which prevents race conditions during heavy concurrent request bursts. Its async API returns Futures and provides increment_async to atomically bump a counter and set the TTL for new buckets, get_async to read the current count without touching the TTL, and reset_async to delete a bucket. You can also configure a key_prefix to namespace keys, making this a good choice when you need consistent, high-performance rate limiting for clustered Perl web applications.

PAGI::FastAPI::RateLimit::Driver::CHI is a storage driver that plugs CHI-backed caches into PAGI::FastAPI's rate-limiting middleware so you can use Memcached, Redis, file caches or any other CHI-supported backend to store and share request counters across worker processes and distributed nodes. It expects an initialized CHI instance and accepts an optional key_prefix (defaults to 'pagi_rl:') to avoid namespace clashes. The driver provides async-compatible methods to increment, read and reset counters that return Future objects so it integrates with PAGI's async pipeline, but because CHI itself is synchronous slow or blocking backends can block your event loop so consider a native async driver like the Redis driver for very high concurrency. This is the module's initial CPAN release (v0.0.1).

PAGI::FastAPI is an asynchronous micro-framework for modern Perl (5.36+) inspired by Python FastAPI that makes it easy to build non-blocking, type-checked web services. It blends the PAGI async protocol with Future::AsyncAwait so route handlers can be written as async subs and it validates query parameters and JSON/form bodies using Type::Tiny before your handler runs. The framework includes dependency injection and middleware hooks, builtin support for WebSockets and Server-Sent Events, automatic OpenAPI 3.1 generation with an interactive Swagger UI, and convenience features like CORS, CSRF, rate limiting, bot protection, and mounting of sub-apps. Authentication is intentionally left pluggable and the companion PAGI::FastAPI::Security distribution provides ready-made credential extractors. You compile your app into a PAGI-compatible async code reference for servers or testing. Note that the framework is loop-agnostic by design but you may need to take care when integrating libraries that use a different event loop, such as Mojo::IOLoop, to avoid blocking or reactor mismatches.

JSON::Schema::Modern is a Perl evaluator and validator for JSON Schema that implements the current draft 2020-12 and earlier drafts so you can check Perl data structures or JSON strings against rich, standards-compliant schemas. It supports configurable output formats, short-circuiting, collection of annotations, applying default values back into results, and extension points for custom formats, media types, encodings and vocabularies so you can adapt validation to OpenAPI or other ecosystems. You load or register schema documents into the evaluator and reuse or cache them for performance, and helper methods let you traverse and validate schemas as well as fetch resolved schema fragments. The distribution does not automatically fetch schemas from disk or the network so referenced documents must be added explicitly and some format validators rely on optional CPAN modules, and the module warns that pattern and regex evaluation can be dangerous with untrusted schemas. In the latest updates the package improved application/x-www-form-urlencoded handling to be spec compliant, added a canonicalize_uri utility, and tightened validate_schema to respect format constraints.

Punk::Queue is a durable, database-backed job queue for Perl that implements its hot paths in C for speed and atomicity. Jobs are stored as rows in SQLite or PostgreSQL and are claimed and recorded by multiple worker processes so work survives crashes and restarts. It provides a rich enqueue API with priority, delay, dependencies, uniqueness keys, per-queue and per-task defaults, and a worker runtime that atomically dequeues, performs and records results or failures. Retries use randomized exponential backoff to avoid thundering herds and three layers of timeout handling protect the system while the supervisor can forcibly kill long-running children. The queue preserves a full per-job log across attempts, offers migration and schema versioning, a repair action to tidy crashed state, simple leasing and counted locks, broadcasting to workers, and admin-friendly listing and stats endpoints. Because Punk::Queue delivers at-least-once semantics tasks must be idempotent by design. This is the initial 0.01 release.

Punk is a lightweight, performance-focused MVC web framework for Perl that compiles and freezes routes, guard chains, handlers, helpers and mounts at to_app time so dispatch is a simple fast lookup with no per-request interpretation. It gives a compact DSL for HTTP routes plus WebSocket and Server-Sent Events endpoints, guard scopes, static mounts, view engines, model backends and plugins and can mount OpenAPI 3.1 specs to auto-generate controller stubs and validate requests. Built-in features include signed cookie sessions, single-use CSRF tokens, CORS handling, an outbound user agent per worker and an async-friendly runtime based on futures so handlers can await work without pinning a worker when run on an evented server such as Hyperman. The distribution ships a generator that scaffolds a running app, plus CLI commands for development, route inspection and config checking, and it supports non-blocking model backends like DBIx::Loop. Recent fixes in 0.05 addressed a segfault on older Perls and updated dependency minimums to improve installability.

Template::Stencil is a high‑performance Perl template engine that compiles a compact {% %} template grammar into packed bytecode and renders it with a C interpreter to produce a ready‑to‑send scalar buffer. It provides variable output with automatic HTML escaping and a raw opt‑out, chained filters (built‑in and user‑registered), conditionals, nested loops with rich loop metadata, scoped set bindings, static includes, and a single‑pass wrapper/layout mechanism so you can render pages and layouts without intermediate strings. Templates are cached and revalidated by mtime for files or by content hash for string templates and the engine is tuned for minimal per‑render allocations and system calls to maximize throughput. Options let you control auto escaping, strict mode, deterministic hash ordering, UTF‑8 handling and an optional HTML pretty step via an external formatter. The design fits prefork and threaded deployments because each interpreter owns its engine and XS consumers can call the engine directly through a C ABI. Caveats to note are that templates cannot call methods on blessed objects, hash key iteration is sorted by default, and several advanced features such as dynamic include names, arithmetic in expressions and streaming renders are reserved for future releases. Use Template::Stencil when you want a fast, predictable and escape‑safe templating solution for Perl web output.

Markdown::Simple is a compact, high-performance XS module that converts Markdown to HTML with GitHub Flavored Markdown as the default but with options to select strict CommonMark or toggle individual features. You can use the simple functional API for one-offs or create a persistent renderer object to reuse the parser arena when converting many documents in a loop, which reduces allocation overhead and improves throughput. It supports GFM extras like tables, strikethrough, task lists and autolinks, offers a strip_markdown helper to produce plain text, and can optionally syntax-highlight fenced code blocks when Eshu is present. Recent releases added GitHub-style heading ids and a render_with_toc method that returns the document headings for building a table of contents, fixed several memory leaks and platform load issues, and include SIMD acceleration and a small C ABI for embedding in other code. Keep in mind the renderer is not safe to run concurrently in the same interpreter so use one session per thread or worker.

DBIx::Loop lets you run DBI database work without stalling an event loop by presenting a single future-based API that offloads blocking drivers to a worker pool or uses a native non-blocking path when available (DBD::Pg). You always provide the event loop adapter (IO::Async, Mojo::IOLoop, AnyEvent, Hyperman, etc.) and then use query and do to get immediate futures, use txn to run a block pinned to one connection, and call the async variants of DBI's select* helpers; results come back as simple data structures so you can compose continuations or bridge into your loop's await mechanism. This module is designed for concurrency and latency isolation in event-driven servers rather than micro-optimizing a single query, and it supports common needs like cached prepares, max-queue backpressure, and safe pool behavior across forks. Noteworthy in the recent 0.02 release are robustness and integration improvements: pool-worker death and fork-safety bugs were fixed, selectall_rowhash was added to preserve row ordering as hashrefs, and a public C ABI was introduced so XS code can efficiently drive DBIx::Loop futures. If you need non-blocking DBI behavior inside your evented application and are prepared to supply or adapt a loop, DBIx::Loop is a practical, production-minded choice.