CPANscan

Imager::File::HEIF is a plugin for the Imager toolkit that adds read and write support for HEIF/HEIC files by talking to the libheif library. It lets you load HEIF images and write them back with control over encoder, compression type and parameters via heif_* tags such as heif_quality, heif_lossless, heif_compression and heif_encoder, and provides methods to list and inspect available encoders and decoders and the compression types supported by the installed libheif. Recent releases add support for the "heix" brand for monochrome files and use a newer libheif API to detect mono versus color images without an extra decode, as well as richer encoder probing and parameter APIs and dump_encoders/dump_decoders helpers. The module requires libheif (1.11.0 or later) plus libde265 and libx265 development files to build and its exact capabilities depend on how libheif was compiled. Be aware that HEIF’s H.265 compression is patent-encumbered and libx265 is GPL licensed, and HEIF processing can be resource intensive.

RPi::SPI is a lightweight Perl module for talking to SPI peripherals on a Raspberry Pi or any Unix-like system with SPI support. It lets you use the Pi's hardware SPI channels (CE0/CE1), free up those chip selects by driving any GPIO as the CS line while still using the hardware SPI engine, or run a fully software bit-banged SPI bus by supplying BCM pin numbers. You create a connection with new(), optionally set a transfer speed (defaults to 1 MHz) or a bit-bang delay, and use rw() to write a buffer and receive the simultaneous readback as a Perl array. It is useful for controlling sensors, ADCs, displays and similar SPI devices, and it will die if it cannot open the SPI device.

WiringPi::API is a Perl XS wrapper around the wiringPi C library that gives Perl programs direct control of Raspberry Pi GPIO, pin modes and common peripherals. After calling one of the setup*() routines it exposes digital read/write, PWM, software PWM/tone, ADC support, I2C, SPI (including bit-banged SPI), serial, LCD control, shift-register support and a BMP180 pressure sensor interface so you can drive sensors, displays and actuators from Perl. It also provides a robust interrupt subsystem with cooperative dispatch, background-process handlers and a worker helper for running periodic or background tasks without needing threads. The module requires wiringPi 3.18 or newer and the wiringPiDev library for LCDs and documents Pi 5 differences such as alternate-function mapping and the fact that the 8-bit bank byte operations are unsupported on Pi 5. Recent updates added PCF8574 I2C expander support, spi_no_cs and spi_bit_bang for flexible SPI chip-select and software SPI, and a number of correctness and test-suite hardening fixes.

SPVM::Go brings the Go language's concurrency model into SPVM by providing goroutines, channels, select, timers, and related helpers so you can write lightweight concurrent tasks and channel-based communication inside an SPVM program. It integrates with libuv to register waits for timers, I/O and channel operations on an event loop so goroutines are suspended without busy-waiting, keeping CPU usage low and allowing many concurrent goroutines. The API lets you spawn goroutines, create buffered or unbuffered channels, use select, sleep, and perform I/O waits, but certain scheduling and I/O wait calls must be made from the main thread and will raise exceptions on invalid timeouts or I/O timeouts. If you want Go-style concurrency primitives in SPVM, SPVM::Go is a practical, efficient port with companion modules and a GitHub repository for more details.

SPVM::Sys is a comprehensive system-level API for SPVM that exposes file I/O, directory and file manipulation, sockets and networking, time and timers, process and user management, signals, environment variables and handy utilities like glob and file test operators, all in a single, consistent interface. It wraps the usual low-level system calls and POSIX-style helpers so you can open, read, write and lock files, create sockets, select or poll, fork and exec processes, set signal handlers, query user and group info, and inspect file metadata with the familiar file-test semantics. The module is implemented with cross-platform concerns in mind and automatically handles Windows filename encoding differences, and it offers portable helpers such as a set_tcp_keepalive function that adapts to each OS. If you are writing SPVM programs that need direct control over files, networks or process behavior this module provides the primitives you need without reimplementing OS interactions. Note that a few behaviors vary by platform, for example some signal and kill semantics are limited on Windows, so consult the docs when targeting multiple OSs.

CPAN::MetaCurator provides tools for managing a curated CPAN metadata database (cpan.metacurator.sqlite) and for turning that metadata into web-friendly content. It helps prepare and export Perl wiki pages, convert Perl.Wiki.html into a jsTree structure, rebuild wiki trees, patch site index pages and upload updates, and it can produce a machine-readable changelog by converting Changes into Changelog.ini. The module is aimed at CPAN maintainers, site operators and module authors who need to assemble searchable, browsable metadata and keep a curated CPAN index in sync. It is open source, maintained by Ron Savage, and uses Perl 5 with production releases starting at version 1.00.

Dist::Zilla::PluginBundle::Author::ETHER is a ready-made collection of Dist::Zilla plugins and sensible defaults assembled by Karen Etheridge to automate building, testing, documenting and releasing Perl distributions. Drop [@Author::ETHER] into your dist.ini and you get a Git-aware gather-and-manage workflow, woven pod, metadata and license handling, comprehensive test scaffolding, automatic prereq reporting, version management and GitHub release integration with a set of configurable options like installer backend, server, offline "airplane" mode, cpanfile support and a fake-release mode. The bundle is author-oriented so it mirrors Karen's best practices while still allowing removal or adjustment of individual plugins for customization. If you want a well-maintained, opinionated starting point for minting and releasing CPAN modules this bundle saves you from assembling dozens of plugins yourself. The latest release also adds release notes into the git tag message and a brief note in generated pod about the $VERSION format it inserts.

CBOR::Free is a compact, high-performance XS implementation of the CBOR binary data format for Perl that makes it easy to encode Perl scalars, arrays, hashes and tagged values into CBOR and to decode CBOR back into Perl data structures. It gives you control over string handling so you can choose whether Perl strings become CBOR text or binary, supports optional preservation of shared and circular references, understands the CBOR indirection tag for scalar refs, and maps booleans and nulls to sensible Perl equivalents while signaling errors as exceptions. The module is designed for speed and low memory use, is suitable for IPC or interop with other languages, and is licensed like Perl itself, but it is still marked experimental so its API can change and you should review the changelog before upgrading. Recent improvements include an opt-in option to reject duplicate map keys during decoding and various maintenance fixes.

Data::BloomFilter::Shared provides a compact, shared-memory Bloom filter for Linux running 64-bit Perl, letting multiple processes efficiently share a probabilistic "seen before" set without storing the items themselves. You can add items, test membership, bulk-add or merge filters built with the same geometry, and tune the tradeoff between memory and false-positive rate so a negative test is exact while a positive test is "probably present". The bit array can be shared via a backing file, inherited across fork, or exported with a memfd descriptor, and concurrent mutation is protected by a futex rwlock with dead-process recovery so many processes can add and query safely. The module exposes convenience methods for construction, introspection, estimated cardinality, syncing and unlinking the backing file, and it enforces byte-oriented inputs so you should UTF-8 encode wide-character strings first. Note it is Linux-only, requires 64-bit Perl, and file-backed mappings default to owner-only permissions unless you override them.

HTML::OSM is a Perl helper for embedding interactive OpenStreetMap maps powered by Leaflet.js into web pages, letting you add markers from coordinates, address strings or geocoder objects and layer in GeoJSON, heatmaps, GPX tracks and choropleth fills without writing raw JavaScript. It emits two HTML fragments for your page head and body so you can drop the required CSS, JS and initialization script into templates, and it includes a built-in Nominatim search box with temporary search markers plus clear and reset controls. Geocoding results are cached via CHI (default in-memory, 1 day) and you can supply your own cache object, and outbound Nominatim calls can be rate-limited with a min_interval setting to respect API limits. Choropleth colouring is computed server-side and baked into the emitted JS, and heatmap and GPX features load their respective Leaflet plugins when needed. Note the author's listed limitations: markers added via add_marker cannot yet be removed individually, cloning via new on an existing object bypasses parameter validation, config-file keys are not revalidated, and turn-by-turn routing is out of scope.

Perl::Critic::PJCJ is a small collection of Perl::Critic policies designed to help teams keep Perl code consistent and readable. It includes RequireConsistentQuoting, which encourages simpler and more predictable string quoting by preferring interpolated strings, reducing unnecessary punctuation, and using bracket delimiters in a consistent order, and ProhibitLongLines, which flags lines that exceed a configurable length (80 characters by default) to improve readability across editors and displays. You can enable the rules in your .perlcriticrc, on the command line, or by selecting the pjcj theme. The distribution is authored by Paul Johnson and is released under the same license terms as Perl.

Schedule::Easing is a lightweight Perl utility for gradually exposing or suppressing log lines and event messages over a configured time window so you can ramp alerts or roll out noisy signals without any external state. You give it a list of pattern-based rules and start/end timestamps and it will deterministically include a growing percentage of matching events between tsA and tsB according to simple parameters begin and final and a selectable curve shape such as linear, step, or power. Rules can base their selection on numeric captures or on a digest of one or more captured fields so identical items are treated consistently over time, and there are convenience rules to always pass or always block matches. Lines that match no rule are emitted by default and you can run either a live match check or ask the module to compute when specific events would be emitted. It is designed for staged alerting and activation scenarios where you want predictable, stateless throttling behavior instead of ad hoc suppression. The most recent release added md5 digest substitution support and a type=pass rule for simpler configurations.

Dist::Surveyor inspects a directory of installed Perl modules and tells you which CPAN distributions and release versions those files came from, making it easy to audit or reconstruct a local collection. You call its single exported function determine_installed_releases with a list of search directories and simple options such as a regex to limit matches, skipping modules that are core in your Perl version, including remnants from older releases, or mapping irregular release names to key modules. Results are returned as MetaCPAN-style release records augmented with a mirror-friendly download URL and dist_data that reports how much of a release is present, so you can see which releases are fully installed. The module talks to MetaCPAN via Dist::Surveyor::Inquiry and supports caching, is used by the dist_surveyor utility, and can feed Dist::Surveyor::MakeCpan to build a mini-CPAN from discovered releases. Note that it requires network access to query MetaCPAN and uses HTTP::Tiny with fallbacks for SSL if needed. A recent fix (2026) corrected how module versions are retrieved from the MetaCPAN API so version mappings are now reported correctly.

MojoX::Authentication is a lightweight, batteries-included helper for Mojolicious apps that makes it simple to add authentication by supporting local logins with in-memory hashes or a SQLite-backed model and remote logins via SAML 2.0. It provides an app_startup helper that installs Mojolicious::Plugin::Authentication and injects the authenticated user into the stash under a configurable key, plus opinionated controller wrappers for credential login, SAML2 initiation and SAML2 SSO postback and a logout helper, which makes it quick to wire common flows into your routes. The module follows simple conventions such as expecting form parameters named username and password and assumes a single SAML2 identity provider by default while offering accessors for the provider name and the authentication model. Minimum Perl version is 5.24. This is an initial release with minimal tests but a working example included, so it is a good choice if you want a straightforward, convention-driven way to add authentication to a Mojolicious application and are comfortable extending the provided model or hooks.

Net::Async::MCP is an IO::Async-based asynchronous client for the Model Context Protocol that lets Perl programs talk to MCP servers without blocking the event loop. It uses pluggable transports so you can talk to an in-process MCP::Server, run an external MCP server as a subprocess over stdin/stdout, or connect to a remote server via a streamable HTTP transport. The API returns Future objects and works with Future::AsyncAwait; call initialize first, then you can list and call tools, fetch prompts and resources, ping the server, and shut down cleanly. This module is a good fit if you need nonblocking, protocol-compliant access to MCP-compatible models or tool servers from an IO::Async application. Recent changes fixed the InProcess transport to provide a real MCP::Server::Context for compatibility with newer MCP::Server releases and the HTTP transport supports streaming responses and session management.

Thread::CSP provides a lightweight, share-nothing threading model for Perl inspired by Communicating Sequential Processes. It spawns independent threads that do not clone the entire parent interpreter and uses Channel objects to send and receive cloned values between threads, making it easy to build isolated worker pipelines and producer/consumer patterns; threads are started with spawn(module, fully_qualified_sub, @args) and return a Promise-like object that resolves when the thread finishes. The project is experimental and intended for evaluation rather than production, but recent releases improved memory handling and allocation for promises and channels and fixed leaks in thread argument handling while improving cross-platform compatibility.

CPAN::Requirements::Dynamic provides a compact, declarative way for CPAN authors to declare conditional dependencies in a distribution's metadata and to evaluate which prerequisites apply in a given build or test environment. You describe a list of expressions that pair a condition such as Perl version, OS, environment variables, build configuration or the presence of a compiler with either a set of module requirements or an error message, and the module evaluates those rules to produce the applicable phase and relation of dependencies. It supports logical operators like and, or and not, understands phases like runtime, build and test and reads rule sets from YAML or JSON files, and the constructor accepts a configuration object and a pureperl-only flag to control behavior. This is useful when you need to express platform specific, feature gated or environment driven prerequisites, and the recent 0.003 release fixes an undefinedness warning in config_defined.

CPANSA::DB provides the CPAN Security Advisory dataset as a ready-to-use Perl data structure. It exposes a single subroutine, db, which returns a hashref containing all advisories and is primarily used by CPAN::Audit but can be used by any code that needs programmatic access to CPAN security reports. Each release includes a .gpg signature and GitHub attestations so you can verify the archive and module file, and a JSON file with the same data is also available for non-Perl consumers. The project is published on GitHub with attestations and GPG signatures to help ensure you are using authentic advisory data.

Mojolicious::Plugin::Fondation::User is a ready-made user management component for Mojolicious apps built on the Fondation set of plugins. It creates a complete "users" table with Result and ResultSet classes, supplies a REST controller with standard CRUD endpoints under /api/user, and provides an optional Bootstrap-based HTML UI. Passwords are automatically hashed with Argon2 using Crypt::Passphrase and the hashing work is offloaded to the DBIx::Class::Async worker so your event loop stays responsive. The API never exposes the password field. Handy ResultSet helpers let you query active users, users created today, or the latest users, and built-in translations include English and French. Use this module when you want a plug-and-play user schema, endpoints, and UI integrated into the Fondation/OpenAPI workflow.

Dist::Zilla::PluginBundle::Codeberg is a convenience bundle for Dist::Zilla that wires in Codeberg support so you can publish and maintain CPAN distributions hosted on Codeberg. It automatically adds the Codeberg::Meta and Codeberg::Update plugins to populate META fields like homepage, bugtracker and wiki and to create or update the remote repository, and it picks up your Codeberg credentials from git config or an optional ~/.codeberg file created by Config::Identity; you must create a personal access token with the api scope. Configuration options let you control which homepage or bug URL gets written, which git remote to inspect, whether to follow upstream forks, and the explicit repo name when needed. If you use Dist::Zilla for releasing modules and host your code on Codeberg this bundle saves manual metadata and repo setup work. Recent releases update the module to use the Forgejo/Codeberg API and remove the installer entry from dist.ini.

Dist::Zilla::PluginBundle::GEEKRUTH is an opinionated, ready-made Dist::Zilla configuration that bundles and preconfigures the collection of plugins D. Ruth Holloway uses to build, test, version and release Perl distributions. It automates common release work such as contributor tracking, metadata (MetaYAML/MetaJSON), POD weaving and README generation, compile and release tests, automatic prerequisite detection, changelog and semantic versioning, and the git commit/tag/push steps so you do not have to assemble all those pieces yourself. You can tweak a few arguments like authority (default cpan:GEEKRUTH), builder (default MakeMaker), development and release branch names, upstream remote, autoprereqs_skip and a remove_plugin option to drop parts you do not want. This bundle is most useful if you want a proven, full-featured release pipeline modeled on Ruthie’s workflow rather than a minimal or highly bespoke setup. Recent notable changes moved the workflow to Codeberg and added a SecurityPolicy plugin.

Mojolicious::Plugin::Fondation::Setup provides an interactive web-based setup wizard for Fondation applications that discovers available plugins on MetaCPAN, reads each plugin's declared setup metadata, and builds a step-by-step configuration workflow served at /setup. Users can pick which plugins to enable, complete per-plugin configuration screens whose fields are pre-filled from any existing config, and persist progress using a file-backed workflow so no database is required. When the wizard completes it writes a $moniker.conf file with the selected plugins and their settings and shows a confirmation page, and it will warn if Mojolicious::Plugin::Config is not enabled so you know to load the generated config. This plugin is a convenient way to assemble and configure Fondation plugins through a guided UI rather than hand-editing configuration.

Mojolicious::Plugin::Fondation::Layout::Bootstrap is a small plugin for the Mojolicious web framework that provides a ready-made Bootstrap-based page layout for projects following the Fondation convention. It helps developers drop a consistent, responsive layout into their Mojolicious apps without writing repetitive template code, making it easier to get a Bootstrap look and structure up and running quickly. The module is intentionally lightweight and focused on layout, so it integrates easily with existing application code and other plugins.

UTF8::R2 is a pragmatic Perl module that gives you explicit UTF-8 codepoint handling without flipping Perl's internal UTF8 flag, so existing byte-oriented programs keep behaving and you avoid common mojibake problems. By importing its mb namespace you get mb::length, mb::substr, mb::tr and other mb:: helpers and you use a $mb{qr/...} wrapper to build regular expressions that match Unicode codepoints rather than raw octets. It supports several UTF-8 variants including RFC3629, RFC2279, WTF-8 and ja_JP-optimized forms, runs on Perl 5.005_03 and later, and deliberately leaves core built-ins working in octet semantics so you opt in to multibyte behavior only where you call the mb APIs. This makes the module useful for porting old scripts or for developers who want clear, noninvasive UTF-8 handling, with the trade off that it only supports UTF-8 encodings and requires the mb:: function names and $mb{qr/...} form for codepoint-aware operations.

Chandra::Markdown is a small helper for Chandra web apps that converts Markdown into HTML and integrates it into your app UI, making it easy to display documentation or content pages. You create it with a reference to your Chandra app and then use render to get HTML or set/append to update a target element in the webview; it supports GitHub-flavored Markdown and has options for line break behavior and built-in CSS. It can also scan a directory of .md files, register routes for each file, produce a navigation block, and build a searchable index that you can query with search or expose to users via a ready-made search_widget that registers the necessary invoke handler. This initial release provides the basic rendering, routing, navigation and search features you need to serve Markdown-based docs inside a Chandra application.

Mojolicious::Plugin::Fondation is a plugin manager for Mojolicious that makes it easy to assemble a web app from modular "bricks" by loading plugins recursively, merging their configurations, and sharing their templates and static assets with the main application. It resolves plugin dependencies and soft ordering, combines configuration from direct parameters, app config files and plugin defaults with predictable merge rules, and automatically registers plugin templates, controllers and public assets through post-load actions that you can extend with custom action classes. Fondation also provides a registry and helpers, supports zones so plugins can inject HTML or JavaScript into named layout areas, and offers a deferred finalization hook for plugins to run code after everything else is loaded. It is ideal if you want to compose a modular application where many plugins contribute routes and resources while avoiding duplicate loads and managing priorities. Note that to be fully recorded and receive the finalization callback a plugin must return $self from its register method.

Markdown::Simple is a compact, high-performance Perl module that converts Markdown to HTML with GitHub Flavored Markdown as the default and an easy functional call markdown_to_html or an object interface for reusing the parser across many renders. You can switch to strict CommonMark or toggle individual features like tables, strikethrough, task lists and autolinking, control soft-break behavior, and strip Markdown to plain text with strip_markdown. The implementation is in XS and includes SIMD acceleration on supported CPUs for much faster rendering, and recent releases have focused on portability and build fixes across platforms such as OpenBSD. Use it when you want a fast, configurable Markdown-to-HTML converter in Perl, especially for batch or high-throughput workflows.

Mojolicious::Plugin::Fondation::Workflow::UI::Bootstrap provides five template helpers that render Bootstrap 5 UI elements for Fondation::Workflow objects so you can quickly add workflow displays and controls to Mojolicious EP templates. The helpers return ready-to-embed HTML when given a Fondation::Workflow::Proxy and include workflow_state, which renders a colored badge using per-state fondation metadata for label, color and icon; workflow_actions, which builds a Bootstrap button group with data-action and optional confirmation text for each available action; workflow_progress, which prints a text-based state tree that highlights current, visited and future states using history-aware backtracking and cycle detection; workflow_history, which emits a vertical timeline of all history entries; and workflow_graph, which returns a raw Mermaid.js flowchart definition for inclusion in a pre block with class mermaid or for external rendering. The plugin requires Fondation::Layout::Bootstrap and Fondation::Workflow, falls back to raw names and bg-secondary when fondation metadata is absent, and returns an empty string when passed undef or an invalid workflow.

Search::Trigram is a lightweight Perl module that builds a trigram-based inverted index for fast, approximate text search and ranking. You add UTF-8 documents to the index and then query with short phrases; results are returned as scored matches (doc_id, score, text) ranked by Dice coefficient over shared trigrams, with a default result limit of 10. The module treats trigrams case-insensitively at the UTF-8 byte level, lets you mark documents as deleted, and provides an optimize operation to compact posting lists and purge deletions. It also exposes simple counters for live documents and distinct trigrams, making it a handy choice when you need quick fuzzy substring matching without a heavyweight search engine.

Mojolicious::Plugin::Fondation::Workflow brings the Workflow CPAN state-machine into the Fondation Mojolicious world, providing a controller helper to create and fetch workflows and a Proxy wrapper with convenient methods such as actions, state_fondation, execute and history. Workflows are defined as YAML files extended with Fondation UI metadata used by a Bootstrap renderer and can persist either via a DBI persister for full apps or a file persister for DB-free wizards, so setup flows can run without a database. Per-workflow persister settings are supported and the plugin will warn rather than fail if no DSN is configured. When Fondation::User is present the plugin also wires a belongs_to relation so workflow history entries can resolve back to users without adding a hard dependency. This module is a good fit for Fondation apps that need authorized, UI-driven state machines. Initial release provides the workflow helper, the Proxy object and basic authorization integration.