CPANscan

PDF::Make is a comprehensive Perl toolkit for creating, reading, and editing PDF files that offers both a recommended high-level, chainable Builder API for common document tasks and a low-level XS API for direct, fine-grained control of PDF internals. With the Builder you can generate pages, manage fonts and layout, add wrapped text, images, outlines and tables of contents with simple chainable calls, while the Document/Page/Canvas API exposes raw PDF objects and content streams for advanced needs. The distribution also includes parsers and readers for importing and extracting text, tables, annotations and form data, support for standard fonts and embedded JPEG/PNG images, interactive features like links and AcroForms, document features such as layers, watermarks and redaction, plus security options including encryption and digital signatures. It is designed to be feature-rich yet self-contained at runtime apart from Object::Proto for the Builder layer, so it is suitable whether you need quick programmatic PDF generation or full control over PDF structure and serialization.

Kubernetes::REST is a focused Perl client that makes the Kubernetes API easy to use from Perl by returning typed IO::K8s objects instead of raw hashrefs and by automatically building resource URLs from object metadata. It provides simple, familiar operations for listing, getting, creating, updating, patching and deleting resources, plus higher level conveniences such as idempotent ensure, batch ensure_all and ensure_only with pruning, streaming watch and log support, and pod port‑forward, exec and attach when your HTTP backend offers duplex I/O. The HTTP layer is pluggable so you can use the default LWP backend, HTTP::Tiny, or supply an async backend, and the client can load the cluster resource map from OpenAPI or accept custom mappings for CRDs. It handles kubeconfig and in‑cluster credentials, preserves raw bytes for pod logs while decoding object data as UTF‑8, and exposes building blocks for async wrappers. A recent noteworthy change adds patch_status and update_status to write through the /status subresource, addressing the case where the API server strips status from writes to the main endpoint and letting you update object status correctly for CRDs and built‑in kinds.

Net::Async::MCP is an IO::Async-based, non-blocking client for the Model Context Protocol that lets Perl programs talk to MCP servers via three interchangeable transports: in-process (direct MCP::Server calls), stdio (subprocess over stdin/stdout), and streamable HTTP. It exposes an async Future-based API (usable with Future::AsyncAwait) to perform the MCP handshake, list and call tools, fetch prompts and resources, and open subscriptions while surfacing server-initiated notifications and input requests back to the application. The client supports configurable protocol version, client capabilities, per-request headers, timeouts and stall timeouts for HTTP, and provides high-level helpers so a caller rarely sees low-level JSON-RPC details. If you need to integrate a Perl service with MCP-compatible model servers, handle long-running tool calls, or respond to server prompts from an async event loop, this module is relevant. The recent 0.004 release improves reliability across transports, adds an on_subscription_end event to notify when a subscription stream ends, and fixes streaming, pagination, header handling and input_required round trips so subscriptions and notifications work robustly over HTTP and stdio.

DBI is the standard database interface for Perl that gives your scripts a consistent, portable way to talk to many different databases by delegating the actual work to driver modules. It supplies a familiar set of operations like connect, prepare/execute, fetch, placeholders and bind values, plus helpers for common patterns such as selectrow or selectall, transaction control with AutoCommit/commit/rollback, quoting and metadata queries. DBI is intentionally a thin, stable layer that handles driver loading, error handling, tracing and callbacks while letting DBD::* drivers implement engine specifics, so some advanced features depend on your driver. It is mature, well documented and widely supported by the Perl community and tooling, making it a good choice whenever you need database access from Perl.

Punk::OAuth2 brings OAuth2 and OpenID Connect support to Punk web applications by providing the client-side authorization code flow with PKCE, signed single-use state, OIDC nonce handling, and id_token verification so you can add "Log in with Google" or similar to your app with confidence. The distribution's behavior lives in Punk::Plugin::OAuth2 and supplies convenient presets for Google, GitHub, and generic OIDC discovery, plus keywords and helpers to build login routes and manage refreshes while keeping sessions lightweight by default. The package also includes optional server and resource-server components for issuing and validating tokens, and most of the protocol and crypto work is implemented in XS for performance with Crypt::JWS used for signature checks. If you are building a Punk application that needs standard OAuth2/OIDC authentication or a compact OAuth2 server or resource checker, this module is directly relevant; if you are not using the Punk framework it will be less useful. This is the initial 0.01 release which introduces the full client flow, presets, helpers, and the accompanying server and checker tools.

MIDI::Stream is a small realtime toolkit for converting between raw MIDI byte streams and higher-level MIDI events, providing a decoder to parse incoming bytes into events and an encoder to turn performance or system events into bytes for MIDI hardware or other software. The classes are stateful and intended to represent a single MIDI port or device, so you should use one instance per stream to avoid running-status confusion, message collision, or tempo inaccuracies since there are no merge facilities. The module supports event callbacks for reacting to parsed messages and the recent 0.006 update fixes callback cancellation bugs and adds regex support for event-name matching when registering callbacks. Note that a prior 0.005 release introduced an incompatible encoder option named "concat" that changes whether multiple messages are concatenated or returned as an array, so review the change log when upgrading.

rainbarf is a small Perl utility that renders compact, eye-catching resource usage charts for inclusion in tmux or GNU screen status lines, letting you see CPU, memory and battery trends at a glance. It generates a tiny visual bar you can drop into your terminal multiplexer configuration so you have continuous, unobtrusive monitoring of system resources while you work. This makes it a good fit for developers and sysadmins who want lightweight, real-time indicators in their terminal workflow without switching to a separate monitoring tool.

GD is the standard Perl wrapper around the libgd graphics library that lets you create, edit and output bitmap images from Perl code. It provides an object model for images, fonts, polygons and a simpler GD::Simple layer, and supports drawing primitives like lines, rectangles, arcs and filled polygons, color and alpha control, brushes and patterned fills, text rendering with built-in bitmap fonts and TrueType via stringFT when libgd is built with FreeType, and animated GIF assembly. You can create images from scratch or load common formats and write PNG, JPEG, GIF, BMP, TIFF, WebP, HEIF and AVIF and other formats depending on your libgd build, and the module exposes copying, resizing, resampling, rotation, many interpolation methods and a range of image filters such as blur, emboss, negate and pixelate. It supports truecolor images and palette images, alpha blending and saving of alpha channels, and offers utilities for color allocation and palette management. The exact feature set depends on the installed libgd version so some older or optional behaviors may be deprecated or unavailable, but for most web and script-based image tasks GD gives a low-level, scriptable way to generate and manipulate bitmaps directly from Perl.

Mojolicious::Plugin::BarefootJS plugs the BarefootJS server runtime into Mojolicious so you can do server-side rendering with BarefootJS inside a Mojolicious app. The plugin registers a "bf" controller helper that lazily creates a per-request BarefootJS runtime backed by BarefootJS::Backend::Mojo and lets you render compiled BarefootJS templates as native Mojolicious templates. It is the right choice when you want tight integration of BarefootJS SSR with Mojolicious, while BarefootJS::Backend::Xslate is provided for non-Mojolicious or PSGI hosts. Recent updates make the build manifest load lazily and cache by mtime and size so starting the server before the first build no longer breaks stash seeding and manifest rewrites are picked up without restarting the server.

BarefootJS::Backend::Xslate lets the BarefootJS runtime render its templates using Text::Xslate with Kolon syntax, making it easy to use Kolon ".tx" templates that call the runtime as a bf object. You can pass a prebuilt Text::Xslate instance or give template paths and options and the backend will build a type=>'html' Xslate that auto-escapes interpolations while supporting helpers that return raw markup via mark_raw. The module exposes the operations the runtime needs such as render_named, encode_json and materialize, lets you override the JSON encoder, and requires no special function map because the compile-time @barefootjs/xslate adapter emits calls as bf methods. It is framework agnostic so it runs under PSGI/Plack or standalone and is actively maintained with frequent releases.

BarefootJS is a small, actively maintained server-side runtime for rendering JSX/TSX that have been compiled into marked templates and client JavaScript, designed to plug into any Perl web stack. It does not do template rendering itself but provides the runtime API the compiled templates call at render time and delegates environment-specific tasks such as JSON marshalling, raw-string handling, JSX children materialisation, and named-template rendering to a pluggable backend. That lets you drive different template engines and frameworks from the same runtime, with ready-made backends for Text::Xslate and Mojolicious and a core that only depends on Perl core modules. If you need to serve compiler-produced JSX/TSX templates from a Perl app and want to keep rendering decoupled from your framework, BarefootJS gives you a lightweight, backend-agnostic way to do that, and the project shows frequent releases and active maintenance.

Crypt::JWS is a Perl module for creating and validating JSON Web Signatures (JWS) using OpenSSL's libcrypto, letting you produce compact JWS tokens and verify them against RSA, ECDSA, or HMAC algorithms (RS256/384/512, ES256/384/512, HS256/384/512) while supporting both OpenSSL 1.1 and 3.x. It provides simple high-level functions to sign and verify tokens, a peek function to inspect an untrusted header for routing, and helper primitives for base64url, SHA and HMAC digests, constant-time equality checks, and cryptographic random bytes. Verification is deliberately strict and privacy-preserving, returning only the payload or undef on any failure and requiring an allowlist of permitted algorithms to avoid algorithm confusion. Keys and thumbprints are managed via the companion Crypt::JWS::Key module and verify can accept a key callback for JWKS-style routing. For C/XS consumers the distribution also exports a stable C ABI so other modules can perform JWS operations in native code for high-performance or embedded use cases. Use Crypt::JWS if you need a straightforward, OpenSSL-backed JWS implementation in Perl or want to embed JWS signing and verification into XS extensions.

Affix is a high-performance Foreign Function Interface for Perl that lets you call native libraries and functions from C, Rust, Zig, C++, Go, Fortran and more without writing XS or compiling glue code, using JIT-compiled trampolines to achieve near-native call speed. It provides a rich, C-like type system for primitives, structs, unions, enums, SIMD vectors and pointers, zero-copy “live” views that map C memory to ordinary Perl hashes and arrays, and convenient APIs for binding functions, creating callbacks, allocating and casting memory, and pinning Perl scalars to C globals. Affix handles cross-platform library discovery for Unix, macOS and Windows, supports variadic functions and filehandle/Socket interoperability, and ships companion tools to generate bindings and build polyglot shared libraries. If you need to integrate high-performance native code into Perl or manipulate C data structures directly, Affix gives you the tools and safety rails to do it cleanly. The recent v1.2.4 release focused on stability and correctness, plugging several memory-leak and lifetime issues around casts and aggregate pins and improving safety for bitfields, wide strings and cross-architecture calling on ARM64 and other platforms.

Stats::LikeR is a high-performance Perl toolkit that brings many of R's convenient statistical routines and data-frame style helpers into Perl, implemented mostly in XS so common operations run fast. It covers tidy-data reshaping and querying (agg, group_by, melt, pivot_table, concat/rbind, merge, join, select/drop columns, assign, filter), numeric summaries and transforms (mean, median, quantile, rank, scale, interpolate, fillna/ffill/bfill), a wide suite of statistical tests and estimators (t test, wilcoxon, chi-square, fisher, anova/aov, oneway_test, kruskal/dunn, binomial tests, correlations, ROC/AUC/DeLong, BEDROC), regression and modeling (lm, glm with Poisson and negative binomial, coxph, survfit, logrank), and convenient table I/O (read_table, write_table) while accepting multiple common frame shapes (array-of-arrays, array-of-hashes, hash-of-arrays, hash-of-hashes). The API is aimed at people who like R idioms but need to stay in Perl, and many routines are numerically validated against R and SciPy so you get both familiar behavior and careful tail/precision handling. Recent maintenance releases focused on correctness and robustness, with fixes that bring chisq_test into bit-for-bit agreement with R 4.6.1 and further bug fixes and XS improvements in versions 0.296 and 0.297, so the module is a good choice if you need fast, R-like statistics inside Perl.

Geo::Coder::Free is a Perl module that lets you run geocoding locally by assembling a SQLite database from free data sources like OpenAddresses, Who's On First, MaxMind and GeoNames and then converting street addresses into latitude and longitude from Perl code or the command line. It includes helpers for common address formats, a sample CGI web front end, and configuration via environment variables so you can customize which datasets to use and optionally store data in MariaDB or Redis. The trade off is upfront work to download and import large datasets and to install tools such as App::csv2sqlite, and some features are incomplete: reverse geocoding is not fully implemented and coverage has limits (MaxMind provides only cities, OpenAddresses is not global, and a few parsing edge cases and occasional lookup failures are documented). If you want a self-hosted, open-data geocoder and can accept the setup effort, this module provides a practical, code-friendly way to avoid paid or rate-limited online services.

Langertha::Knarr is a Perl-based, protocol-bridging LLM hub that exposes many kinds of backends to standard clients by speaking the wire protocols used by OpenAI, Anthropic, Ollama and agent ecosystems such as A2A, ACP and AG-UI. It can run as a standalone async server or in Docker or PSGI, supports native token-by-token streaming, and uses a pluggable handler model so you can route requests to local engines, per-session agents, raw passthrough proxies or remote agent clients while adding decorators for tracing and JSONL request logging. Knarr normalizes handler results into a single response shape, preserves tool calls and usage data, supports optional API-key auth and discovery routes, and is a good fit when you need to present a common OpenAI-style or Anthropic-style interface for a variety of engine providers or to bridge different agent ecosystems. The recent 1.101 release fixes a crash that could occur when engines returned usage metadata and a separate Langfuse serialization error that could turn completed upstream calls into 500s, and it also refreshed model defaults and expanded environment-driven engine detection and documentation.

SSVC is a Perl implementation of the Stakeholder-Specific Vulnerability Categorization framework that helps teams prioritize software vulnerabilities based on the needs of different stakeholders. The module provides ready-made methodology implementations such as CISA, Deployer, Supplier and coordinator variants, lets you create SSVC objects with decision-point values, and returns a recommended action via a simple decision method. It supports parsing and emitting the compact SSVCv2 vector string for the CISA methodology and can convert SSVC objects to JSON for interoperability with other tools. The API also includes introspection helpers so tools can list available methodologies or query decision point definitions, and you can register your own custom methodology class if you need to extend the system. The recent 1.01 release fixes a timestamp issue in to_vector_string and adds a simple example CVE-to-SSVC calculator to help get started.

Punk::GraphQL adds a GraphQL-over-HTTP endpoint to Punk applications so you can expose a GraphQL API with minimal wiring. It hooks into Punk as a plugin and uses GraphQL::Houtou for parsing and execution, giving native-VM performance. You declare a graphql route with a schema file and supply resolver mappings that point to controller classes or specific controller methods, plus an optional context builder and guard for authorization, and you can enable GraphiQL for interactive queries. Pick this module when you want to serve GraphQL from a Punk app and map fields to existing controllers while leveraging a fast, XS-backed execution engine.

Protocol::Sys::Virt implements the LibVirt RPC protocol in Perl and provides the low-level message serializers, deserializers and transport primitives you need to build LibVirt-compatible clients and tooling that do not rely on the blocking Sys::Virt API. It is aimed at people who want a truly asynchronous way to talk to libvirt from Perl and supplies URI parsing, stream handling and helpers for typed parameters so you can integrate with event loops or Future/async frameworks. The module follows libvirt release tags to keep protocol mappings current and is best used as a building block for non-blocking clients rather than as a turnkey server implementation. Recent updates track libvirt v12.6.0 and fix a test-suite failure on older Perl versions while adding support for an 'argv' URI query parameter and new domain announce interface (de)serializers.

Log::Log4perl is a mature, full featured logging framework for Perl that brings the familiar power of Java's log4j to Perl applications. It provides category-based loggers and standard severity levels so you can turn logging on or off for specific components without changing code, route messages to multiple destinations via flexible appenders (file, screen, DBI and many Log::Dispatch options), and format output with powerful pattern layouts. Configuration can be done in external files or in code and can even be reloaded at runtime with init_and_watch, while easy_init and stealth loggers give a one line setup for quick scripts. Advanced features include nested and mapped diagnostic contexts (NDC and MDC), message filters, runtime level adjustments and performance optimizations for suppressed messages, with safe-eval options for embedded Perl in configs if you need them. The module is actively maintained and the latest release includes a fix for Catalyst integration so shared Catalyst processes no longer lose log messages.

Lingua::TokiPona::Word is a small Perl module that models the limited vocabulary of the constructed language Toki Pona as normalized, unique word objects so you can work with words rather than raw strings. It provides multiple constructors (from strings, other objects, ISE values or Under-ConScript Unicode Registry code points), string and UCSUR accessors, equality and ordering operations, and a known() method to list all words or stopwords, with synonyms kept distinct. The module keeps the full lexicon in memory so you always get the single canonical instance for a given word, which makes it handy for language tools, indexing, simple NLP tasks or storing multilingual identifiers in databases. The latest release added more words, a natural_language accessor, interoperability with Lingua::famibeib::Word and an implementation of the Lingua::Generic::Interface::Word interface.

App::Netdisco is an open source, web‑based network management application that discovers devices via SNMP and stores collected data in PostgreSQL so you can locate machines by MAC or IP, see the switch port they use, manage ports (shutdown, VLAN, PoE), inventory hardware, and generate network diagrams. It bundles a web frontend with a built‑in server and a backend daemon for polling and performing actions, and it supports plugins, a DBIx::Class database API, Docker images for easy deployment, and an online demo to try before installing. The project targets administrators of real networks, documents installation and upgrade steps, and requires Perl 5.10+ and PostgreSQL 9.6+ with additional system packages for full functionality.

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.

ClarID::Tools is a reference implementation and command-line toolkit for the ClarID specification, which defines compact, human-readable identifiers to make biomedical metadata integration more consistent and interoperable. The distribution provides a CLI for generating and validating ClarIDs, CSV preprocessing utilities and bulk export helpers, versioned codebooks and schemas, and a Docker image to simplify reproducible workflows. It supports multiple codebook versions and focuses on consistent encoding and platform-independent outputs, so it is useful if you manage samples, specimens, experimental records or other biomedical metadata and need concise persistent identifiers. Recent 0.04 updates migrated the documentation to Docusaurus, added the 0.04 codebook/schema family with stricter duration formatting, expanded CSV preprocessing support (including Python deps in the Docker image), and synchronized CPAN and Docker builds; the package declares Perl 5.32 as the minimum tested version. The author requests that published work using ClarID-Tools cite the accompanying journal article.

Circle::Miner is a small Perl module that integrates basic mining workflows for the Circle blockchain into your Perl programs. It lets you fetch a block to mine for a given wallet address, run a mining step using an external mining binary with optional multi-process threading to search nonces, and post a successfully mined block back to the network. The API is straightforward with methods to create a miner object, fetch a mineable block, perform mining (the mined result is read from a local mined.txt file) and submit the block, and the submit method enforces a 34-character address that begins with "1". This module is useful if you want to automate mining tasks from Perl but you must provide the OS/architecture-specific external miner executable it depends on. The recent 0.03 release mainly revamps the documentation and earlier updates added common debug configuration.

Circle::User is a Perl module in the Circle::Chain SDK that handles common user account tasks such as sending verification codes, registering and logging in (by password or one-time code), logging out, setting and checking a payment password, resetting passwords, and managing contacts and user profile data. Its API exports a set of simple functions that return response hashes with HTTP-like status codes so you can check success or error conditions easily. The module supports sending codes by email and by phone with phone registration limited to mainland China. Use it alongside the other Circle modules like Circle::Common, Circle::Wallet and Circle::Block when building applications on the Circle platform.

Lingua::Lapine::Word is a small utility for representing and managing words in the fictional Lapine language. You construct canonical word objects with new (for example new(string => 'Frith') or from another object), and the module deduplicates instances so identical words share a single object. Words can be registered to remain in memory for later lookups and the class method known lets you enumerate known words or all known items. A natural_language method returns the language tag (Lapine) so the objects play nicely with other Lingua modules. This is an initial v0.01 release aimed at projects that need a simple, consistent way to model and track Lapine vocabulary.

File::Sticker is a Perl toolkit for reading and writing file metadata and keeping a synchronized database of that information, making it easy to manage metadata across many files in a standardized way. It can extract metadata from files, add, replace or delete fields including multi-value tags, derive new values via plugins, and write changes back into files. It also exposes database operations such as updating or removing file records, querying by tag expressions, listing faceted tags, checking for missing or overlooked files, and moving files while updating the DB. A small internal selector picks the appropriate "scribe" for a file type and derive_values can compute metadata without modifying the input, so this module is a good fit when you need scriptable, centralized control and searchability of file metadata.

PlackX::Framework is a lightweight micro‑framework built on Plack for creating PSGI web applications. It wires together a handler, request and response objects, and a small routing DSL so you can define routes and filters with minimal ceremony and call MyApp->app to get a PSGI app. Request and response objects extend Plack::Request and Plack::Response and provide a per-request stash and a flash cookie helper. The framework will auto‑create or load MyApp::Handler, ::Request, ::Response, ::Router and other pieces in your application namespace to keep setup simple. Template Toolkit support, URI helpers and a simple config layer are optional and pluggable so you can add them only when needed. The project favors low memory use and fast startup compared with larger frameworks and keeps dependencies small. It is still marked experimental and recent releases have focused on documentation and test fixes with the distribution published to CPAN in 2026.

App::news supplies small utility routines used by the script/news package that powers a web front end for a news server. Its primary tool is wrap, a plain-text reformatter for mail and news bodies that leaves short lines alone, wraps longer lines to about 72 characters, and preserves quoted blocks when they use the customary ">" marker. The module also offers ranges and sranges helpers to turn lists of message numbers into arrays suitable for XOVER queries and to convert those arrays back into compact, human-readable range strings like "1-2,4". The module is authored by Alex Schroeder and distributed under the GNU Affero GPL.