CPANscan

Punk::Authorisation provides row-level authorization for Punk web applications by letting you define simple, application-owned rules that answer whether the current user may act on a specific database row. It supplies a plugin that installs a rule DSL and controller helpers so you can write checks like $c->may('doc.edit', $doc) and get clear outcomes, with refusals translated into the correct HTTP responses to avoid leaking the existence of other users' rows. The distribution also offers an optional grants table (Punk::Model::Grant) when you need delegated permissions and integrates with Punk's auth configuration for role ladders. This initial release extracts the logic from Punk::DIY and includes a demo application that exercises every rule against every row.

Tomba::Finder is the official Perl client for the Tomba.io Email Finder API that makes it easy to discover and verify contact data from Perl code. It exposes one-line methods for common tasks like searching a domain for known emails, generating the most likely address from a name and domain, verifying deliverability, enriching a profile from an email, finding author or LinkedIn emails, locating phone numbers, searching companies, managing leads and API keys, and running bulk operations. The module acts as a simple facade mapping API endpoints to Perl methods while also offering standalone submodules if you need more granular control. If you are building contact discovery, lead enrichment, or data verification into Perl scripts or apps, this module provides a ready-made, documented interface to the Tomba service and includes examples and links to full API docs.

Punk::APIKey is a plugin for Punk applications that provides a complete API key system for issuing and validating bearer tokens. Keys are generated once, stored as a digest, and presented to clients as an "Authorization: Bearer" token, while the framework enforces scoped access, per-key rate limits, revocation, and checks against the key owner’s current standing. The distribution includes a default database model and Sqitch schema for SQLite/Postgres/MySQL, a command-line tool for issuing, listing and revoking keys, and a ready-to-run example application that demonstrates minting, using, demoting, suspending and revoking keys. If you need token-based API access with scope control and operational features like rate limiting and owner-aware enforcement, this module provides an out-of-the-box solution for Punk apps. This is the initial 0.01 release.

Weather::NHC::TropicalCyclone is a lightweight Perl client that reads the National Hurricane Center's CurrentStorms.json and presents each active storm as a Storm object so your code can list, inspect, and fetch details for current or archived tropical cyclones. It can fetch live data from NHC or load saved JSON from a file or memory, offers simple validation with warnings for any unknown fields that are preserved, and provides helpers to fetch basin RSS feeds. The constructor accepts a HTTP::Tiny-compatible object for testing or custom transports and fetch accepts options like timeout, save_to, and url for mirrors or replay. The parser is intentionally tolerant of additive changes to the feed and is kept up to date with NHC formats through the 2026 season, making this module a good fit for developers building monitoring, replay, or archival tools that need programmatic access to NHC storm status.

PDL::IO::Matlab lets Perl Data Language (PDL) arrays be saved to and loaded from Matlab .mat files by wrapping the matio C library, with both a simple functional API and an object-oriented interface. It supports Matlab formats 4, 5 and 7.3 and can read and write real multi-dimensional arrays, with optional zlib compression when available. The module only handles PDL-compatible numeric arrays so other Matlab datatypes will raise errors, and users should be aware that 1-D PDLs must be represented as 1xN or Nx1 in Matlab because Matlab has no native 1-D vectors. Also, PDL uses row-major ordering while Matlab uses column-major ordering so indices will appear transposed unless you explicitly handle that. Octave compatibility has quirks such as overwriting of duplicate variable names in MAT5 files and errors if MAT73 support is not present in the linked libmatio. Recent updates refresh libmatio to 1.5.30 and add a check that prevents creating MAT73 files when the installed libmatio lacks HDF5 support, with some test modernisation; compression support and other build improvements were added in earlier releases. Overall this is a practical tool for exchanging numeric arrays between PDL and Matlab/Octave when you stick to real numeric arrays and mind the format and dimensionality caveats.

Aion is a modern object system for Perl 5 that gives you a Moose-like way to declare classes and roles with typed, validated attributes and flexible aspects. You define features with has(...) and use aspects such as is, isa, default, lazy, coerce, trigger and others to generate accessors, predicates and clearers while enforcing constructor parameter rules and runtime type checks. Roles can declare requirements, inherit and refine interfaces, and even add new aspects to features, and method signatures can be validated with the :Isa attribute. Aion also integrates a dependency injection pattern via its pleroma container and the eon aspect, making it a compact, extensible alternative to Moose/Moo/Mouse for Perl developers who want strong attribute validation, role composition and DI support without the heavier Moose machinery.

Sisimai is a Perl library that parses bounced email messages and turns them into easy to use structured data, returning Perl objects or JSON so you can programmatically see the recipient, sender, SMTP codes, delivery status and a categorized bounce reason. You call Sisimai->rise with a mailbox path, Maildir, file, STDIN or even a string to get an array of Sisimai::Fact objects and you can call Sisimai->dump to get JSON output, with options to include delivered or vacation results and an origin field that records the source. The module ships parsers for many MTAs and a comprehensive set of reason detectors, and it offers helper methods like engine, reason, match and version plus a callback feature to extract or store custom data during processing. It is actively maintained and requires modern Perl, and recent releases added support for newer Perls and fixed a ReDoS vulnerability in HTML parsing while continuing to refine MTA patterns and status code handling.

File::Access::Driver is a lightweight Perl class that wraps common file operations into a single, easy API so you can create, truncate, delete, check existence and write file content without hand‑rolling filehandle management. You set files by directory, filename or full path and can enable an in-memory buffer or persistent open filehandles for better performance. The module is a "batteries included" convenience layer that reduces boilerplate and centralizes resource cleanup, and it reports problems via getErrorCode and getErrorString rather than throwing exceptions so you can inspect status after each call.

Object::Meta is a small Perl class for holding a piece of raw data together with separate meta information while keeping the two clearly distinct. You create an Object::Meta and then set or retrieve data fields and metadata fields independently. You can also declare an index field and set its value so instances can be automatically indexed and used in an Object::Meta::List. The object can be cleared of its contents without losing the index configuration. It is lightweight and avoids the need to write detailed definition modules, so it is useful when you need a simple, indexable container that carries both payload and metadata.

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.

Algorithm::UrataniTakeda implements the Uratani-Takeda multiple-string search algorithm to let you find many patterns in a text quickly by combining ideas from Aho-Corasick and Boyer-Moore, with behavior similar to Commentz-Walter. You construct it with a list of patterns and then either call search with a callback that is invoked for each match, use matches to collect all matches, or use first to get the first match. The callback may return false to stop further searching. This is an experimental implementation that requires Perl 5.26 or later, the initial release is on GitHub, and issues or test cases should be reported there.

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.