CPANscan

OpenSearch::Client is an unofficial Perl client for OpenSearch that lets Perl applications connect to and interact with OpenSearch clusters for indexing, searching and basic cluster operations. It is derived from the Search::Elasticsearch client so many callers will find the API familiar while it follows the OpenSearch project's diverging API. Documentation is available via OpenSearch::Client::Manual and a companion utility, OpenSearch::Client::Hash, can produce BCrypt, Argon2 and PBKDF2 password hashes for user creation. The module is maintained by Mark Dootson and distributed under the Apache 2.0 license, making it a practical option for Perl projects that need OpenSearch integration.

File::Raw::Archive is a lightweight, streaming archive reader and writer for Perl that focuses on practical, script-friendly access to tar-style archives while letting you add other formats via plugins. It ships with robust tar support that understands ustar, GNU longname tricks, and PAX extended headers and can auto-detect or write gzip-compressed streams. You can iterate entries or build archives with a simple API that includes open, each, list, extract, extract_all and create, and convenience exported functions for one-liners. Extraction supports platform extended attributes by default and protects against path-traversal unless you explicitly opt out, and it can dispatch content to forked workers for parallel extraction on systems with fork. If you need to support zip, cpio, ar or other formats you can install sister modules that register format plugins, making this a flexible choice for tools that inspect, extract, or create archive containers from Perl.

File::Raw is a high-performance Perl file toolkit that exposes simple, easy-to-use functions for common tasks like reading and writing whole files, appending, streaming lines, memory-mapped reads, atomic writes, copying, moving and inspecting file metadata while avoiding PerlIO overhead. Its API gives you slurp/spew helpers, an efficient each_line callback for streaming, a lazy lines iterator, mmap access for zero-copy reads, and a stat call that caches results to reduce syscalls. Built-in helpers cover head, tail, grep/map/count over lines and a small predicate system so you can filter text easily. A plugin system lets you register format and codec handlers such as CSV or gzip and chain them for composed read and write workflows, and there is a C-level XS API so high-performance plugins can be written in native code. The module focuses on speed using direct read/write syscalls and platform optimizations like sendfile and copyfile, and it provides safety features such as atomic_spew for crash-safe writes. Note that iterator use with a plugin is eager and will slurp the file into memory, each_line is recommended for true streaming, and the internal stat cache must be cleared if external processes change files.

Fetch is a modern Perl HTTP client that puts its performance-critical socket, TLS and HTTP/2 code in C while exposing an easy async API in Perl. Each request returns a Fetch::Future so you can await a single call synchronously or run thousands of requests concurrently on Fetch's built-in event loop or on IO::Async, AnyEvent or Hyperman. It supports HTTP/1.1 and HTTP/2 over TLS with protocol negotiation, keep-alive connection pooling, redirects, per-request timeouts, streaming body callbacks, a cookie jar, JSON helpers and native WebSockets. You can observe every outbound hop with request hooks, clone agents to share pools but isolate cookies or headers, and even drive Fetch from C via a small ABI when embedding in XS code.

QR::Code is a compact Perl module for producing QR symbols as scalable SVG with no runtime dependencies, letting you encode byte-mode payloads into versions 1 through 15 at any error correction level and then render them as vector art that embeds cleanly in web pages or is converted to rasters when needed. It can also return the raw module matrix or a PBM text form for tests and further processing, and it supports placing a centre logo, custom module shapes and finder shapes, colours and gradients while enforcing luminance and contrast rules so you do not accidentally produce unreadable codes. The API exposes high level helpers like svg, matrix and pbm, and the distribution installs a C ABI header so other XS modules can call the encoder directly. Recent updates added styled serialization and centre-logo support exposed via ABI version 2, and the latest microrelease adjusted the ABI pointer return type to an unsigned value.

PDF::Make is a full-featured Perl toolkit for creating, parsing, and editing PDF files, offering three levels of API so you can pick the right balance of simplicity and control. At the top level a template-based Markup renderer lets designers keep layout in files while Perl supplies data, which is ideal for invoices and reports. The recommended Builder API provides a chainable, high-level interface that handles pages, text wrapping, fonts, images, and common shapes so you can assemble documents programmatically without wrestling with PDF internals. If you need complete control the low-level XS Document/Canvas layer maps closely to the PDF specification and exposes content streams and object graphs. The distribution also includes parsing and extraction tools, font and image support, forms and interactive features, security features like encryption and signatures, accessibility and redaction support, and output options such as linearization, all with minimal runtime dependencies.

Mojolicious::Plugin::BarefootJS makes it easy to use the BarefootJS server runtime inside Mojolicious apps by registering a "bf" helper that creates a BarefootJS runtime per request and lets you render compiled BarefootJS templates as normal Mojolicious templates. Install it when you want to combine BarefootJS templating with Mojolicious controllers and views. If you are hosting outside Mojolicious or a PSGI framework, the BarefootJS::Backend::Xslate backend drives the same runtime without a web framework.

BarefootJS::Backend::Xslate is a rendering backend that lets the BarefootJS runtime render its templates using Text::Xslate with Kolon syntax, making it easy to use Xslate templates inside any PSGI/Plack app or even a standalone script. It binds the runtime into templates as the bf object so helpers and runtime methods can be called directly, handles JSON encoding and raw-markup output, and builds Text::Xslate in HTML mode so interpolations are auto-escaped by default while helper-produced markup can be marked raw. The backend accepts either a ready-made Text::Xslate instance or a path plus options, and is designed to work with the @barefootjs/xslate compile-time adapter that emits Kolon .tx templates targeted at the runtime. The project is actively maintained with frequent releases, the latest being 0.33.3 on 2026-08-31.

BarefootJS provides the server-side runtime that marked templates produced from JSX/TSX call at render time, handling things like JSON marshalling, raw-string marking, JSX children materialization and named-template invocation while staying agnostic about the template engine or web framework you use. The runtime delegates engine- and framework-specific behavior to a pluggable backend so the same core can drive different hosts; shipping backends include Text::Xslate for PSGI/Plack and a Mojolicious plugin for Mojo apps. The core itself keeps dependencies minimal by relying only on core Perl modules and only pulls in template or framework libraries when a chosen backend requires them. The project is MIT-licensed, actively maintained with frequent releases (latest series through 0.33.3 in August 2026), and is a good fit if you need a portable Perl runtime for server-rendering templates compiled from modern JSX/TSX toolchains.

DBIx::Loop gives event-driven Perl programs a simple way to run DBI database operations without blocking the event loop by returning futures for queries and writes. It is not a loop itself so you supply an adapter for IO::Async, Mojo::IOLoop, AnyEvent, Hyperman or another loop and DBIx::Loop wires query futures into that ecosystem. Internally it chooses one of two execution backends: a universal worker pool that runs blocking DBD calls in forked workers, and a native fast path for drivers that expose nonblocking I/O such as DBD::Pg, so you get concurrency and latency isolation rather than microbenchmarked per-query speed. The API maps closely to DBI with connect/new, query/do, async variants of the select* helpers and a txn block that pins a sequence of statements to a single connection, and errors and results arrive via the returned future. The module includes hooks for observing every statement and a C ABI for XS consumers so other extensions can call it with no Perl frame in the hot path. Note the author’s caveats: DBIx::Loop will not create a loop for you, SQLite workloads can suffer writer contention across multiple worker processes so write-heavy apps should use one worker or raise sqlite_busy_timeout, and statement observers are process-global, permanent and do not receive bind values. If you run a persistent evented server and need to keep the loop responsive while doing database work, DBIx::Loop is designed precisely for that use case.

Apophis is a small, high-performance Perl XS library for content-addressable storage that assigns deterministic UUID v5 identifiers to blobs by hashing their content with SHA-1 via the Horus library. You instantiate it with a namespace so the same bytes produce the same UUID within that namespace and different namespaces yield different IDs, then use simple methods to identify, stream-identify large files with O(1) memory, store (atomic write with deduplication), fetch, verify and remove objects from a two-level hex-sharded filesystem layout. It also supports batch operations and optional metadata and returns a filesystem path for any stored UUID so blobs are directly accessible on disk. A recent notable addition is a public C ABI that lets other XS modules call Apophis primitives without a Perl frame, and recent releases have focused on improving Windows build and runtime behavior.

File::Raw::Hash is a small File::Raw plugin that computes digests and HMACs while leaving the file bytes themselves unchanged, delivering the result into a caller-supplied scalar, hash or array reference so you can checksum or fingerprint data in-place or in a streaming, memory-bounded way. It supports a single-algo mode or lockstep multi-algo runs in one pass and understands common algorithms such as sha256 (the default), sha512, sha1, md5, crc32, xxh64 and blake3, with HMAC mode available for the SHA/MD families and a choice of output formats including hex, base64 and raw. All algorithm implementations are vendored reference code so there are no external crypto dependencies and the plugin composes cleanly inside File::Raw chains so you can hash either on-disk bytes or a decoded representation. Recent releases added a C ABI so other XS modules can call into the runner directly and the latest fix addresses Windows build problems. If you need convenient, dependency-free checksums or content-addressing hooks integrated into File::Raw, this plugin is a good fit.

SPVM is a statically typed language with Perl-like syntax that aims to give Perl programmers a faster, safer toolchain while keeping familiar idioms and modules. It can run scripts directly with spvm, ahead-of-time or JIT compile programs and libraries with spvmcc, and call SPVM methods from Perl via a tidy exchange API, and it provides tight C and C++ binding and resource management for native libraries. The toolchain includes static types with inference and analysis, support for native threads and lightweight goroutines, parallel compilation and linking, debug builds and sanitizer support, and optional LLVM or MSVC toolchains for cross‑platform native builds. SPVM bundles many standard utilities and fast implementations of common operations so it is a practical option if you want Perl-like syntax plus stronger typing, high performance and easy C/C++ integration. Note it has not reached a stable 1.0 release and there is no guaranteed backward compatibility, so be prepared for breaking changes. A recent important change is that native class build configuration files now must use the .build extension instead of .config, so existing native configs should be renamed and spvmdist output updated. If you write performance‑sensitive code, need AOT/JIT compilation or C/C++ interop but prefer Perl syntax, SPVM is worth exploring.

IO::Async::Open3::Simple is a small adapter that lets you run external programs under an IO::Async event loop and receive their stdout and stderr one line at a time via simple callbacks, making it easy to react to process start, output, errors and exit without blocking. It follows the familiar AnyEvent::Open3::Simple style so it is most useful when you are migrating code to IO::Async or want a minimal, callback-based way to spawn subprocesses, while IO::Async::Process remains the more full‑featured alternative for new projects. The run method accepts program arguments and optional stdin content or a setup callback and triggers events such as on_start, on_stdout, on_stderr, on_exit and on_error. Note that it waits for the child’s output pipes to hit EOF before firing on_exit to guarantee delivery of every line, and that IPC::Open3 buffering and deadlock caveats still apply, with writing to stdin unsupported on native Windows builds. This is the initial 0.01 release (2026-08-30), intended as a straightforward, IO::Async-backed replacement for AnyEvent::Open3::Simple.

App::karr is the engine behind karr, a command line kanban system that keeps your board inside Git by storing cards, config, logs, and id metadata in refs under refs/karr/* rather than as files in the working tree. Task cards are plain Markdown with YAML frontmatter and the tool reads and writes them directly to refs so Git remains the transport and source of truth and you avoid file-level merge conflicts for shared task state. There are commands to materialize and import a temporary gitignored tasks/ view for interoperability and grepping, and lower-level modules such as App::karr::Git, App::karr::BoardStore, and App::karr::Task are provided so you can automate or inspect boards from Perl. The installed karr binary shows a board summary by default, auto-discovers repositories by walking upward for refs/karr/*, and also ships official Docker images tuned to avoid creating root-owned project files. If you want a lightweight, Git-first kanban workflow that keeps tasks versioned alongside your repository and accessible to scripts, App::karr is designed for that use case.

Data::JSEmail converts between Email::MIME objects and the JSON mail format defined by RFC 8621 (JMAP Mail), making it easy to turn Perl email messages into the JMAP create/update payloads and to rebuild MIME trees from JMAP bodyStructure and blob references. It understands headers and header arrays, preserves raw header text where needed, extracts text and HTML bodies and attachments as bodyValues or part/blob references, assembles recursive bodyStructure trees, validates content IDs, handles charset choices for 7-bit and UTF-8 content, and provides helpers for dates, addresses (including grouped addresses), message IDs and URLs. The API includes a make() routine with configurable header precedence and a defaults callback so callers can control fallback values, and it exports utilities for standard header defaults. Recent updates clarified licensing and added documentation and a README, and earlier releases improved RFC 8621 compliance and added bodyStructure assembly and header handling to match Cyrus JMAP behavior.

Text::JSContact is a Perl module that converts contact data back and forth between legacy vCard files and the modern JSContact JSON format defined by the RFCs 9553 and 9555, making it easy to bridge older vCard-based systems and newer JSON contact workflows. It performs bidirectional mappings for common fields like names, emails, phone numbers, addresses, organizations and titles and also handles more advanced items such as anniversaries, notes, online services, media, calendars, crypto keys, directory membership and relationship data. The module follows the standards closely and ships with extensive test coverage including RFC 9555 test vectors and CardDAV integration checks, so it is suitable for migrations, CardDAV server clients or any Perl application that needs reliable vCard/JSContact interoperability. The distribution is licensed under the same terms as Perl itself and recent updates clarified licensing and added basic module documentation.

Text::JSCalendar is a lightweight Perl utility for converting calendar data between traditional iCalendar (RFC 5545) and the newer JSCalendar format, making it easier to parse, generate and interoperate calendar feeds and CalDAV data in Perl applications. It can parse vCalendar text into Perl event structures and emit iCal text from event objects, and includes handy utilities such as cached timezone lookup via DateTime::TimeZone, event normalization to remove default-valued fields, and event comparison. If you need to import, export, compare or normalize calendar events in a Perl project or bridge iCalendar and JSCalendar ecosystems, this module provides the core conversions and helpers to do that.

Net::DAVTalk is a lightweight Perl helper for talking to WebDAV servers, originally built to support CalDAV and CardDAV clients but useful for any DAV work. It handles connection setup, Basic or Bearer (OAuth2) authentication, .well-known discovery to find principal and home-set URLs, and sends DAV methods like PROPFIND, MKCALENDAR, MKCOL and DELETE through a configurable HTTP::Tiny-compatible user agent with SSL options and custom headers. Responses are parsed from XML into structured Perl hashes and the module provides handy utilities for namespace management, path conversion between full and relative forms, property queries, UUID generation and user agent control. By default Request throws on errors while the newer SafeRequest API returns a consistent result hash containing payload, http_response and any error so callers can handle failures without exceptions. The module is actively maintained and recent updates added SafeRequest and clarified licensing to match Perl's terms.

Net::CardDAVTalk is a compact Perl client library for talking to CardDAV servers, originally written to map CardDAV operations to an older FastMail API and to serve as an example implementation and test helper for suites like Cassandane. It exposes simple methods to create, update, delete and list addressbooks and contacts, fetch single or multiple cards (including multiget and prop requests), perform sync operations with syncToken, and move contacts between collections while returning metadata like etags. Recent releases moved the API to use JSContact hashrefs and delegate vCard↔JSContact conversion to Text::JSContact, and added Net::DAVTalk and Text::JSContact as dependencies, so callers now pass and receive plain Perl hashrefs rather than VCard objects. If you need a readable, test-friendly CardDAV client for scripting or test automation this module is a good fit, especially when you want examples of CardDAV interactions or integration with FastMail-style servers.

Net::CalDAVTalk is a Perl client for talking to CalDAV servers that presents calendar and event data as easy-to-use Perl/JSON-style structures. It handles discovery via .well-known and SRV, manages calendars and events (list, create, update, delete), supports multi-get and range queries, can produce free/busy results, supports sync-token based polling, and can export calendars as iCalendar files. The module includes Cyrus and Apple CalDAV namespace support, a timezone cache for speed, and a pluggable logger. It was written for FastMail and is tied to an early FastMail API and to Cassandane testing, so some operations are a bit specific to that environment and a few queries are implemented inefficiently or have limited property parsing. If you need a Perl toolkit to script or test CalDAV servers and do not require a polished, generic SDK, this module provides a practical, feature-rich starting point.

Mail::JMAPTalk is a compact, low-level Perl client for communicating with JMAP servers that wraps HTTP::Tiny and handles JSON encoding and decoding for you. It gives you simple methods to make JMAP method calls, call batches of methods, upload and download binary blobs, and authenticate either with basic auth or with the non-standard JMAPAuth token flow, while leaving object-specific JMAP logic to higher-level code. The module returns Perl data structures mirroring the JSON responses, will report errors on unexpected or invalid replies, and can print full request and response traces if you set DEBUGJMAP. Recent updates clarify the licensing and include a LICENSE file, switch to the core MIME::Base64, and make File::LibMagic optional so uploads without an explicit MIME type fall back to application/octet-stream, making the module easier to install and integrate into scripts or custom JMAP clients.

CPAN::Meta is a small Perl class for reading, validating, converting and writing a CPAN distribution's metadata such as META.json or legacy META.yml. It exposes the standard fields and maps them to convenient methods so you can inspect name, version, authors, license, resources, provided packages, optional features and build or runtime prerequisites, compute an effective set of requirements, and decide whether particular files or packages should be indexed. You can load metadata from files or strings, serialize it back to JSON or YAML, request down-conversion to older spec versions, and get deep, unblessed copies for safe manipulation. This is the go-to tool for authors and packaging tools that need to parse, validate or transform CPAN meta information. Recent releases emphasize distribution-only metadata, fix compatibility with newer CPAN::Meta::Requirements, and include minor documentation cleanups.

Text::VCardFast is a Perl module that quickly parses and generates vCard data by converting vCard text into a structured Perl hash and back again, providing vcard2hash and hash2vcard functions. It offers both a pure-Perl and a faster XS (C) implementation and handles common vCard features and RFC-compliant decoding including RFC 6868 escapes and Unicode propagation. The parser exposes options to control multi-valued fields, multi-valued parameters, bare parameter keys, and early exit after a single card so you can tailor output for middleware or bulk processing workloads. If you need low-latency handling of many or large vCards this module is much faster than older CPAN alternatives and is suitable for use in servers or tools that import, export, or transform contact data.

Alien::OpenMP is a lightweight helper that detects and returns the compiler and linker flags needed to build C code with OpenMP using the same compiler Perl was built with. It follows Perl's configured toolchain so XS modules and Inline::C code inherit the correct ABI and linker settings rather than switching compilers based on environment variables. The module supports GCC reliably and has experimental support for Clang, with extra handling on macOS to add include and library paths for an external libomp runtime when needed. It verifies at install time that omp.h and the runtime work, and exposes simple methods like cflags, lddlflags, openmp_version and version, plus built‑in support for Inline::C integration, so it is useful whenever you need a straightforward, portable way to enable OpenMP in Perl-linked C code.

CPANSA::DB is a small, focused module that packages the CPAN Security Advisory reports as a ready-to-use Perl data structure so tools can consult a local copy of known CPAN security issues. It exposes a single subroutine, db, which returns a hash reference containing the advisory records, and it is primarily consumed by CPAN::Audit but can be used by any script that needs offline access to CPAN vulnerability data. Each release is published on GitHub and distributed with a GPG signature and GitHub attestation so you can verify the archive you download, and a JSON export of the same data is also provided for non-Perl consumers. The data is updated regularly with new reports and CVE mappings, making the module a convenient way to embed an authoritative, versioned snapshot of CPAN security advisories into audit or monitoring workflows.

Punk::Passkey brings WebAuthn passkey support to the Punk web stack by offering simple helpers to produce browser credential options and to verify registration and authentication responses. It issues single-use, time-limited challenges stored in the session, returns the PublicKeyCredentialCreationOptions and PublicKeyCredentialRequestOptions structures for navigator.credentials, and verifies incoming attestation and assertion bytes while keeping origin checks tied to the application configuration rather than request headers. The module includes a hardened parsing layer that accepts only the CBOR and COSE forms WebAuthn actually uses and converts public keys and signatures into forms Crypt::JWS can work with, so you store the raw COSE key bytes and the code re-validates algorithm allowlists on every login. Attestation statements are read but not validated by default, with an optional coderef hook if you want to perform full attestation checks, and all verification failures return the same generic failure while logging detailed reasons for operators. Counter handling treats a nonincreasing sign count as an informational clone signal rather than an automatic rejection and provides hooks for applications to record credential use and respond to clone events. This is the initial release of Punk::Passkey and includes database migration scripts for credential storage.

Test::Snapshot makes it easy to capture and re-use expected test outputs by storing them in automatically named files and comparing your current results against those snapshots with a single helper, is_deeply_snapshot. You call it with the value you produced and a short test description and the module derives a filename from the test script name, any surrounding subtest names, and that description, treating a missing file as if it contained undef. Snapshots are written in a human-friendly Data::Dumper format to keep diffs small and readable, and you can opt in to automatic updates by setting TEST_SNAPSHOT_UPDATE so failures still update the stored snapshots for you to inspect under source control. This module is distinct from Test::Snapshots for executables and, as of the latest release, is compatible with Test2::V0, making it a simple choice for tests that need stable, reviewable expected outputs.

Punk::Observe is a single-node OpenTelemetry backend for receiving, storing, querying and visualising traces, metrics and logs in one place rather than a client library. It accepts OTLP over HTTP (protobuf or JSON), authenticates ingest with hashed keys, appends incoming data to a write‑ahead log and stores each signal in formats tuned to its shape so a single query language can span metrics, traces and logs without manual trace id copying. The distribution includes a PSGI ingest app, a storage engine with immutable segments, compression and rollups, a resumable query executor that refuses overly expensive or unsupported scans with actionable messages, a live tail over server‑sent events, and a C-backed UI that renders waterfalls, flamegraphs and charts (Plotly is vendored) while alert evaluation is intended to be driven by the host scheduler. Important operational choices are explicit: timestamps use 64‑bit nanoseconds and cross-perl string handling, retention deletes whole two‑hour blocks rather than single records, cardinality is capped and excess series are folded into an overflow series, and durability has configurable fsync policies. The module deliberately does not support gRPC ingest, clustering, backend tail sampling, PromQL compatibility, or percentiles over downsampled ranges, and it expects to be mounted into a host Punk application with a required admin guard. This is the initial 0.01 release providing the engine, receiver and plugin for self-hosted observability.

Finance::Quote is a mature Perl library that pulls stock, mutual fund and bond quotes from dozens of exchanges and web services around the world, returning a simple table of standard fields such as price, volume, currency, date and dividend info so you can integrate live market data into scripts or applications. You create a quoter object, call fetch with a method name and symbols, and the module consults one or more exchange-specific backends and optional currency conversion modules to produce the results, with configurable timeouts, required-label checks and failover behavior. Currency conversion is pluggable and some backends require API keys, and the module includes handy utilities for date/time normalization, CSV parsing and number scaling. The recent 1.71 release fixes NZX JSON mapping and updates IndiaMutual NAV parsing to an 8-column format with Plan and Option fields and adds SIF support while removing some Morningstar modules. Be aware that you cannot control the internal failover order and results are presented as a two-dimensional hash, which some users find less convenient than nested references.