CPANscan

Image::WebP is a lightweight Perl wrapper around Google's libwebp that lets Perl programs inspect, decode, and encode WebP images. You create an Image::WebP object and use WebPGetFeatures to read image metadata such as width, height, alpha presence and a status code. WebPDecodeSimple converts WebP bytes into raw pixel buffers returned with width and height and supports formats like RGB, BGR, RGBA and BGRA. WebPEncodeSimple turns raw RGB or RGBA data into WebP bytes and accepts options for quality, lossless mode and stride when you need control over encoding. The module raises an exception for invalid WebP input, preserves a historical misspelling of the lossless option for compatibility, and is released under the Artistic License 2.0.

Alien::SNMP is an "Alien" installer that downloads, builds and installs the Net‑SNMP C library together with the matching Perl XS modules so that your Perl programs can use SNMP without relying on the system package. It builds the client tools and the SNMP/NetSNMP::* Perl modules from the same pinned Net‑SNMP source so the XS layer is always compiled against the exact libnetsnmp it ships, and it exposes simple helpers like bin_dir, cflags and libs so programs can find the bundled command line utilities and link flags. The distribution deliberately does not ship MIB files or an snmpd agent so symbolic OIDs work out of the box and you add MIB collections yourself via MIBDIRS or SNMP::addMibDirs, and it is designed to be installed into perlbrew, local::lib or an alternate perl without shadowing the system library. Recent fixes ensure installs honor INSTALL_BASE and similar prefixes, build with the perl running Makefile.PL, and resolve previous macOS and musl/Alpine installation failures, though there is a known link issue on FreeBSD 9. If you need a self‑contained, up‑to‑date Net‑SNMP client and matching Perl bindings for non‑system perls or for parsing large MIB collections, this module is a good fit.

SION is a Perl encoder/decoder for the SION serialization format, a Swift-literals-derived alternative to JSON that supports a few extra types and conveniences such as nil, distinct Int and Double values with lossless C99 hexadecimal floats, UTF-8 strings, raw binary data (.Data), dates (.Date), extension types (.Ext), non-string dictionary keys and comments. The module offers both simple functional helpers encode_sion/decode_sion and a JSON::PP-style object interface with familiar options like utf8, ascii escaping, pretty printing, canonical key ordering, allow_blessed/convert_blessed and max_depth. It maps SION types to natural Perl equivalents and provides helper classes SION::Date, SION::Data and SION::Ext to represent or force special types, while booleans follow JSON::PP conventions and native booleans are supported on newer Perls. This is the initial 0.01 release, suitable if you want a richer, Swift-compatible interchange format with a familiar Perl JSON-style API.

App::Codit is a Perl/Tk graphical editor and lightweight integrated development environment built specifically for working with Perl. It provides a multi-document tabbed interface based on Tk::AppWindow and uses the Tk::CodeText widget for editing with syntax highlighting, code folding, auto-indent, auto-brackets, auto-complete and an advanced word-based undo stack, while tab and indent styles are fully configurable. Codit is extensible by plugins and ships with a rich set of them including Git, FileBrowser, PodViewer, Snippets, SearchReplace and Sessions, and it also supplies a base class to help you write your own plugins. Configuration is available through a settings window and the codit command supports options for icon themes, plugin control, sessions and default syntax selection. Development has been active through 2026 with recent updates adding Critic and Diff plugins, improving Git and file browser behavior and fixing a range of issues, so it is a practical choice if you want a Perl-focused GUI editor that is customizable and plugin-friendly.

Mojolicious::Plugin::BarefootJS wires the BarefootJS server runtime into Mojolicious so you can render client-style templates on the server with minimal fuss. It registers a per-request "bf" helper that instantiates a BarefootJS runtime backed by BarefootJS::Backend::Mojo and lets you treat compiled marked templates as Mojolicious templates. If you run outside Mojolicious there is a Text::Xslate-based backend available as BarefootJS::Backend::Xslate. Recent releases made the build manifest load lazily and cache by mtime/size so starting the server before the first bf build no longer breaks server-side defaults and manifest changes are picked up without a restart.

BarefootJS::Backend::Xslate is a small adaptor that lets the BarefootJS runtime render Kolon ".tx" templates with Text::Xslate, offering a framework-agnostic way to produce HTML from BarefootJS templates. You can give it a ready Text::Xslate instance or point it at template directories and it will build an HTML-escaping Xslate engine by default, with hooks for a custom JSON encoder and Xslate options. It is designed to be paired with the @barefootjs/xslate compile-time adapter so templates call runtime helpers through a bound "bf" object, and the backend implements the runtime operations you need such as render_named, encode_json, mark_raw and materialize. Use this module when you want to write BarefootJS views in Kolon syntax and render them with Text::Xslate in any PSGI/Plack app or in standalone code.

BarefootJS provides a lightweight, framework- and template-engine-agnostic server runtime for templates compiled from JSX/TSX into "marked" templates plus client JavaScript. It hands off framework-specific work such as JSON marshalling, raw-string marking, materializing JSX children, and named-template rendering to a pluggable backend that you inject, so the same runtime can drive Text::Xslate under PSGI/Plack or Mojolicious via Mojolicious::Plugin::BarefootJS. The core ships with only core Perl module dependencies, keeping it small unless you load a backend that requires additional libraries. Choose BarefootJS when you want to render JSX-style templates on the Perl server while retaining flexibility over template engines and web frameworks. The project is actively maintained with frequent releases.

CallBackery is a Mojolicious-based framework for building appliance-style web front ends that pair a Perl backend with a Qooxdoo rich client. It provides a ready-made application skeleton that wires in configuration (default etc/callbackery.cfg with an environment override), a pluggable database layer, security headers, and an RPC service/controller so backend actions can be exposed to the frontend as JSON-RPC calls. The distribution bundles helpers for common UI patterns like forms, tables, downloads and uploads, plus session and access handling and a plugin system for GUI components, letting you describe screens and actions rather than reinvent HTTP plumbing. Recent work modernized the RPC protocol and tightened session handling, and the latest release improves configuration restores by using SQLite s online backup API so live connections remain valid and partial restores are avoided. The module is GPL licensed and maintained by Tobias Oetiker.

MooX::Role::JSON_LD is a lightweight Moo/Moose role that makes it easy to produce JSON‑LD markup from your objects for use with schema.org and other Linked Data consumers. To use it you apply the role to your class and implement two simple methods: json_ld_type returns the schema type name and json_ld_fields returns an arrayref describing which object attributes to export; that array may contain strings for direct attribute names, hashes for renaming, or coderefs for computed/composed values. The role exposes json_ld_data for a Perl data structure, json_ld for a JSON string, and json_ld_wrapped for a ready‑to‑embed <script> tag, and the JSON‑LD context is configurable (defaults to https://schema.org). Recent releases tightened output semantics to emit the @context only at the top level and fixed a packaging issue by adding a missing MRO::Compat dependency, so it now behaves cleanly with nested objects and modern Perl setups.

Neovim::Ext provides a straightforward Perl interface to the Neovim editor so you can control the editor from Perl or run Perl code as a Neovim plugin host. It exposes common Neovim operations such as calling Vimscript functions, executing commands and Lua, evaluating expressions, pushing simulated user input, querying runtime paths and attached UIs, subscribing to events, and running or stopping the Neovim event loop, and it includes a start_host helper to turn your process into a plugin host. If you want to automate editing tasks, integrate Perl tools with Neovim, or write plugins in Perl this module gives you the necessary API surface without needing to dig into Neovim internals. The module requires Perl 5.22 or newer and the most recent release includes fixes to keep tests working with newer Neovim versions.

MCP is a Perl library that turns a Mojolicious route or a stdio process into a server that speaks the Model Context Protocol, letting you expose tools, user-selectable prompts and read-only resources to AI models. It implements the stateless 2026-07-28 revision of MCP and handles JSON-RPC over stdio and Streamable HTTP, with automatic JSON Schema validation for inputs and outputs so your handlers see only valid data. You register named tools as callables that return text, structured data, media or resource links and you can write asynchronous tools with Mojo::Promise, report progress and logs back to the client and react to cancellations. The server supports per-request visibility and scope checks for authenticated callers, optional subscription streams for out-of-band notifications, and convenient testing via Test::Mojo and MCP::Client. It deploys like any Mojolicious application and works with preforking servers because the protocol is stateless, but features that need per-process state such as notification streams require special handling and a shared state_secret across workers. If you want a Mojolicious-native, schema-aware way to expose Perl functions and documents to modern AI clients, MCP provides a compact, pragmatic framework to build and secure those integrations.

Tk::GtkSettings is a small Perl module that helps Perl/Tk applications match the look of GTK desktops by reading your GTK configuration and applying its fonts and colors to Tk via X resources. It provides a one-call convenience function applyGtkSettings plus more granular tools to load GTK files, decode GTK font and color formats, generate xrdb/Xresources/Xdefaults output, and manage groups of widget option mappings so you can tweak or extend which Tk widgets get themed. It only operates on Unix/X11 systems and is harmless on Windows and Mac where it simply does nothing, and it works under the module’s assumption of 8-bit color depth when adjusting colors. If you want your legacy Perl/Tk GUIs to blend with modern GTK themes without hand-tweaking every color and font, this module makes that straightforward. Recent releases have broadened widget coverage and added refinements such as a new guideColor option for the ListBrowser widget to better match desktop themes.

Getopt::Guided is a Perl module for parsing command line options that follows the POSIX getopts rules while adding modern conveniences for script authors. It provides an iterator-style getopts() that writes parsed flags and option values into a user-supplied hash and can operate on a supplied argv array, and it offers processopts() to bind parsed options directly to scalars, arrays, hashes, or callback functions so you can implement option semantics like version or help handling in order of precedence. The module supports common, multi-value (list) and key=value (map) arguments, negatable and incrementable flags for patterns such as verbosity, and it will restore @ARGV and warn on parse errors rather than leaving a half-parsed state. readopts() can prepend defaults from a simple rcfile and print_version_info() helps implement a standard -V behavior. Recent updates added true HASH destinations and explicit map option support and improved robustness by catching exceptions raised by callback handlers, making the module a safe, POSIX-compliant choice when you want predictable, flexible option parsing in Perl scripts.

Mail::Milter::Authentication is a Perl milter daemon that integrates email authentication into your mail flow by applying and reporting on standards like SPF, DKIM, DMARC, ARC and BIMI. It runs as a preforking Net::Server process and is built from modular handler components so you can enable policy checks, RBL lookups, DMARC reporting, metrics and custom processing without rewriting the server. The module handles logging, metrics export, and rejection or quarantine actions when policies require it and provides hooks and protocol-specific classes for extending behavior. It is aimed at mail server operators who want a configurable, extensible way to enforce and report on modern email authentication, and the latest release fixes a DNS timeout cache recursion with Mail::DMARC 2.x that could otherwise exhaust process memory.

Affix is a high-performance Foreign Function Interface for Perl that lets you call native C, Rust, C++, Go, Fortran, assembly and other code directly from Perl without XS or external compilers by generating JIT trampolines for near-native call speed. It provides a rich, C-like type system for primitives, pointers, structs, unions, enums, SIMD vectors and variadic functions, plus zero-copy "live" views that map Perl hashes and arrays directly onto C memory, managed allocation helpers, pointer arithmetic, callbacks, library discovery and a suite of debugging and introspection tools. If you need to bind functions, manipulate raw memory, pass Perl subs into native callbacks, or build fast language bridges, Affix gives you a full toolkit that works cross-platform. The recent v1.1.0 release delivers a major V2 Pin system backed by Perl magic VTables to eliminate tied-variable overhead for memory access, a new Const[...] wrapper to enforce read-only C memory at the Perl level, improved bitfield and enum handling, and numerous ABI and platform fixes. Note that some global operations such as registering types or bindings are not thread-safe and should be done in the main thread before spawning worker threads.

Zuzu is a small Perl helper for running ZuzuScript code from Perl. It provides two simple functions: zuzu_eval parses and evaluates a ZuzuScript source string and zuzu_evalfile loads a UTF-8 script file and evaluates it, with both calls returning the result of evaluation. You can pass runtime options to control execution, for example to restrict module access or add library paths, so it is convenient for quick one-off execution, embedding Zuzu snippets in Perl programs, testing scripts, or running script files without building a larger integration.

Dancer2::Plugin::OIDC makes it easy to add OpenID Connect authentication and OAuth 2.0 token validation to Dancer2 web apps. It lets your application act as an OpenID Connect Relying Party and as a Resource Server by validating access tokens issued by an external provider. The plugin wraps the OIDC-Client library, creates client objects from your configuration, automatically installs the callback routes, and exposes an oidc(...) helper that returns a request- and session-aware OIDC::Client::Plugin instance. It supports multiple providers, token exchange for calling downstream APIs, verification of access tokens and building user objects from claims. It does not implement an OpenID Provider and the author recommends storing session and token data on the backend rather than in client-side cookies.

Sys::Export is a high-level toolkit for building a trimmed-down copy of an operating system tree for things like chroot environments or initramfs images. It automates inclusion of required libraries and interpreters for the files you select, lets you rewrite paths and user or group IDs and updates references where possible, and supports injecting generated or external files into the export. The module is mainly a convenience wrapper that creates an OS-specific exporter (for example Sys::Export::Linux) and exports simple functions such as add, skip, find, rewrite_path and finish so you can script what to include without dealing with exporter objects directly. It also provides utilities for lazy file data handling, memory-mapping fallbacks, compact file-attribute shorthand, and helpers for writing file extents. If you need to assemble minimal runtime images or chroot trees this makes the job much easier, but be aware that only Linux is fully supported at the moment.

Mojolicious::Plugin::OpenAPI::Modern is a Mojolicious plugin that wires an OpenAPI::Modern object into your app so you can drive request and response validation from an OpenAPI specification. You configure it with a raw schema, a filename, a canonical document URI, or by handing it an existing OpenAPI::Modern object, then use the provided helpers in controllers to access the parsed spec via openapi and to run validate_request and validate_response to check incoming requests and outgoing responses against your API contract. The plugin also saves useful route and operation metadata in the stash under the openapi key and provides an after_response hook so you can run non-mutating response checks for logging or telemetry. Recent releases include support for explicitly setting document_uri and an after_response option, plus small fixes to keep tests and dependencies aligned with OpenAPI::Modern.

OpenAPI::Modern validates HTTP requests and responses against OpenAPI v3.0, v3.1 and v3.2 documents and uses JSON::Schema::Modern to perform full, spec‑compliant JSON Schema evaluation. It converts incoming request and response objects into Mojolicious message types and returns rich result objects that include deserialized parameter, header, cookie and body data along with precise error locations, making it easy to see why a message failed validation. The module understands many OpenAPI features such as path, query and cookie parameter styles, media‑type decoding (including application/json and application/x-www-form-urlencoded), content encodings and default population, and it bundles up‑to‑date metaschemas so you can validate or extend schemas immediately. You can preload and cache documents for faster startup in preforked apps. Be aware that multipart bodies are not yet implemented and the Authorization header is not automatically checked against security schemes, and conversions from non‑Mojolicious message types are best‑effort and may reveal differences in header handling. Recent updates improved path matching for URL‑escaped characters and fixed edge cases involving the root path.

Devel::MAT is a Perl Memory Analysis Tool for loading and inspecting heap dump (.pmat) files so you can diagnose memory leaks and understand what is keeping data alive in a running program. It wraps a dumpfile and exposes a set of analysis Tools and a simple UI that let you explore Perl scalar/array/hash/code values, trace inrefs and outrefs back to roots, locate symbols, globs and stashes, and run commands to count, size or diff objects. The toolset is extensible via a Devel::MAT::Tool API so third‑party modules can add custom analyses or UI pages. The dump format has been made more extensible over time to ease forward compatibility and the project is actively maintained; a recent update modernised the code for Perl 5.20 and fixed a bug in the show command by adding the missing show_UNDEF handler.

Syntax::Kamelon is a fast, programmable syntax highlighting and code folding engine that uses Kate editor XML definition files to recognize and format source code and other structured text. It replaces the older Syntax::Highlight::Engine::Kate and loads Kate XMLs directly so you can use the existing language definitions or supply your own, while formatter plugins let you output highlighted content as HTML, ANSI, or any custom format by subclassing Syntax::Kamelon::Format::Base. The module supports hooks for custom commands on matches, can suggest a lexer by filename, and offers controls for indexing the available XMLs or rebuilding them on the fly at startup. It is well suited for server side highlighting, report generation, custom editors, and automated code formatting and runs significantly faster than earlier versions. Be aware that some upstream Kate XMLs are imperfect and a few Kate tag features were intentionally omitted, and that regex differences in newer Perl releases can produce small mismatches for a handful of definitions.

App::SlideServer is a lightweight Mojolicious web application that converts a Markdown or loose HTML file into a browser-based slideshow with a presenter interface and real-time synchronization over websockets. It automatically upgrades your source into a standard slide DOM, splits content into individual slides, injects the JavaScript and CSS needed for fullscreen presentation and presenter notes, and broadcasts slide state so multiple viewers can follow or a remote device can control the show. The module supports stepwise animations via data-step attributes and automatic stepping for lists, lets you plug in your preferred Markdown processor, and can optionally watch the source file for live reloads using Linux::Inotify2. Authentication for the presenter is handled by a presenter_key and the app is easy to run as a web server or extend by subclassing. A few advanced behaviors such as scoped per-slide styles and deferred inline script execution are noted as TODO and presenter-only notes are currently enforced by CSS rather than backend filtering.

XML::PugiXML is a lightweight Perl binding for the pugixml C++ XML parser that gives you very fast parsing, XPath querying, DOM-style navigation and easy tree modification and serialization from Perl. It exposes familiar document and node methods to load or save XML, run XPath or compiled XPath expressions, read and write attributes and element text, clone or insert nodes, and control formatting options when producing output. The module expects UTF-8 input and marks all outputs as UTF-8, and it uses a reference-counted model where node and attribute handles keep the document alive but become explicitly stale if the underlying node is removed or the document is reset so you should use valid() to test handles. pugixml does not process external entities and does not expand user-defined entities by default, so it avoids common XXE and entity-expansion attacks. If you need a faster alternative to XML::LibXML for parsing, XPath, DOM traversal or manipulation, this binding is a solid choice. Recent updates (0.08) fix several memory-safety issues such as use-after-free and stale-handle corner cases, tighten handling of embedded NULs, and add thread-safety precautions by skipping cloning of internal objects across ithreads.

EV::Future is a tiny, high-performance async control-flow library for EV-based Perl programs that provides primitives like parallel, parallel_map, parallel_limit, series, series_map and race so you can run many tasks concurrently, with limits, or sequentially using a simple done-callback convention. Tasks are offered in two styles: the task form where each array element is a coderef invoked with a single done callback, and the map form where a worker is called for each data item as ($item, $done). In non-void context each call returns an EV::Future::Handle that reports active and pending counts and can cancel remaining work, which makes it easy to monitor and abort operations. The implementation is XS-optimized for low overhead and offers a safe default mode that wraps task execution and drops double-calls, plus an unsafe mode for roughly double the throughput at the cost of uncaught exceptions possibly abandoning an operation and of unsafe behavior if done is called twice. The author documents a few silent traps to watch for such as non-coderef tasks being treated as instant no-ops, tied arrays being ignored by the task form, and never handing the raw done callback directly to EV watchers. The recent 0.06 release added the map variants and series_map, introduced the EV::Future::Handle with cancel/pending/active, and bumped the minimum Perl to 5.14 while fixing several edge-case bugs.

MooX::Role::SEOTags is a small Moo role you can mix into page objects to automatically generate common SEO meta tags for web pages, including HTML title and description, canonical link, OpenGraph properties and Twitter/X cards. It expects your class to provide basic attributes such as og_title, og_type, og_description and og_url, with og_image and a few other fields optional, and offers methods to emit individual tags or grouped outputs like core_tags, og_tags, twitter_tags or a single tags call to print everything. The module is useful when you want a consistent, testable way to produce metadata for social preview and search indexing without handcrafting HTML for every page, and recent updates added a consolidated core_tags method plus support for meta title, og:site_name and og:image:alt.

Data::PerfectHash::Shared provides a tiny, immutable on-disk set that you build once and then mmap read-only from any number of processes to perform extremely fast, lock-free membership tests. It supports integer keys or arbitrary byte strings, stores the full keys on disk to guarantee zero false positives, and answers has() queries in worst-case O(1) with a very small index footprint so the same image can be shared across processes and survive restarts. You create a builder to add keys and write a .phs image, or use the convenience build_int/build_str one-shot methods, and readers use load to validate and mmap the file then call has, each_key, count, type, or unlink. The on-disk format is validated at load time to avoid misreads and bounds-checked per lookup to limit risks from untrusted files, but images are immutable and only loadable on hosts with the same byte order. Performance is excellent for read-heavy scenarios and the index is compact at roughly four bits per key. This initial release also introduces a compact CHD index that byte-packs per-bucket displacement entries (1 to 4 bytes each) for on-disk format version 2.

Statistics::Krippendorff computes Krippendorff's alpha, a flexible measure of inter‑rater agreement, from your coded data. It accepts input as an array of hashes or arrays so you can identify coders by name or by position and it handles missing values; you get the coefficient via the alpha method. The module includes built‑in distance functions for nominal, ordinal, interval and ratio data and for set‑valued annotations via Jaccard and MASI, and you can provide a custom delta function for specialized similarity measures. Small helpers let you validate units and inspect value frequencies to make sure your data meet the requirements. A recent update greatly accelerated the coincidence-matrix construction so large datasets that formerly took hours now complete in seconds.

Tk::ListBrowser is a Perl/Tk canvas widget that gives you a highly configurable, graphical list browser for desktop GUIs, letting you display items as a simple vertical list, a horizontal bar, a grid of rows or columns, or a hierarchical tree or hlist. It supports images and multiline text per item, sortable and draggable headers, optional side columns, keyboard and mouse selection, on-the-fly filtering, and a wide range of layout and cell-size options so you can tune appearance and behavior. You manipulate content programmatically with intuitive methods to add, remove, hide, show, sort, and refresh entries, and you can switch arrange modes without losing data, though tree-style hierarchies need a one-character separator to work properly. The widget is optimized for small to medium lists of a few hundred items, custom fonts can slow refresh, and there is an autorefresh mode and tools to control background refresh cycles to balance responsiveness.

SPVM::Go brings the Go programming language's concurrency model to SPVM by providing lightweight goroutines and typed channels so you can spawn many concurrent tasks and coordinate them with selects, wait groups, contexts, timers and signal helpers. The runtime uses the libuv event loop so blocked goroutines do not busy-wait but are suspended efficiently, keeping CPU usage low and allowing thousands of concurrent routines in a single process. It offers simple APIs to create goroutines, make buffered channels, wait on I/O with timeouts and sleep in nanoseconds, and notes that certain scheduler and I/O wait methods must be called from the main thread. A SPVM_GO_DEBUG environment switch is available for debugging.