CPANscan

Matplotlib::Simple is a lightweight way to produce matplotlib graphics from Perl without learning the Python API by hand. You pass Perl hashes and arrays describing your data and plotting options and the module writes a Python 3 script (saved in the system temp directory) that uses matplotlib to render bar, boxplot, hist, scatter, imshow, violin, pie, hexbin, hist2d and many other plot types, with support for subplots, overlays, shared colorbars and common axis and style options. The module can either execute the generated script for you or leave it for manual editing and it requires a working Python 3 and matplotlib installation; the proportional-area Venn helper now wraps the matplotlib-venn library when you install it. Recent updates added the unified "p" subplot argument, improved cross-platform behavior and in version 0.31 added the venn_proportional_area helper while removing Term::ANSIColor as a dependency.

Mojolicious::Plugin::BarefootJS connects the BarefootJS server-side template runtime to Mojolicious so you can render BarefootJS templates inside your Mojolicious app. It registers a per-request helper called "bf" that lazily creates a BarefootJS runtime backed by BarefootJS::Backend::Mojo and adds the supporting hooks so compiled marked templates behave like native Mojolicious templates. If you are not using Mojolicious there is a separate backend using Text::Xslate for PSGI hosts. This plugin is simple to install, MIT licensed, and useful whenever you want to integrate BarefootJS rendering into a Mojolicious application.

BarefootJS::Backend::Xslate is a small adapter that lets the BarefootJS runtime render Kolon-style Text::Xslate templates. It wires a Text::Xslate instance into BarefootJS so templates can call the runtime as the bf object and use its helpers and filters. The backend builds Xslate for HTML-escaping by default and supports mark_raw values for helpers that emit raw markup. You create it with a template path or a prebuilt Xslate instance, can override the JSON encoder, and then call render_named to render templates with the runtime bound. Use this module when you want to run BarefootJS templates with Xslate in any PSGI/Plack application or even outside a web framework.

BarefootJS is a lightweight server runtime for templates compiled from JSX/TSX into a marked template plus client JavaScript, letting Perl applications render component-style templates without tying you to a particular template engine or web framework. It delegates framework-specific tasks such as JSON marshalling, raw-string marking, JSX children materialisation and named-template rendering to a pluggable backend so the same runtime can drive different rendering engines, and shipping backends include BarefootJS::Backend::Xslate for Text::Xslate/PSGI and BarefootJS::Backend::Mojo for Mojolicious. The core intentionally pulls in only standard Perl modules unless a chosen backend requires extras, making it easy to adopt in existing PSGI or Mojolicious apps. The module is MIT licensed and actively developed, so it is a good fit if you want to bring JSX/TSX-style server rendering into Perl while keeping your rendering backend flexible.

Chandra::Same::Boy is a Chandra widget that embeds the Same::Boy Game Boy / Game Boy Color emulator into a native webview window so you can play ROMs inside your Chandra GUI. It renders a pixelated, scaled canvas, forwards real keyboard input, supports save states and battery-backed saves with autosave, and provides controls for pause, reset, fast-forward and audio management. You create it with a Chandra::App and a ROM, call mount before running the app to inject the canvas, input bridge and a ~60fps game loop, and you can hot-swap cartridges, save or load state files, and listen for events such as rom loaded, frame, fps and save actions to integrate with your UI. The widget also includes SGB multiplayer input support, a toolbar and HUD with ROM title and measured FPS, native file open for hot-swapping and toast feedback for actions. This is the initial 0.01 release.

Chandra provides Perl bindings to the webview-c library so you can build cross-platform desktop apps with HTML, CSS and JavaScript while keeping your application logic in Perl. It exposes a simple OO interface to create windows, load URLs or data URIs, run or control the event loop, execute JavaScript and register Perl callbacks that JavaScript can call back into. The distribution also includes higher-level helpers such as Chandra::App and a growing component set including forms, tables, modals, toasts, system tray integration and IPC helpers to speed building interactive UIs. On Windows Chandra prefers the modern Edge WebView2 runtime and will automatically fall back to legacy MSHTML when WebView2 is not available so installing the WebView2 runtime and WebView2Loader.dll is recommended for the best web feature support. The recent release documents a per-frame on_tick hook for games and animations and adds on_close and on_reload callbacks to support graceful shutdown and hot-reload workflows.

Same::Boy is a Perl extension that embeds the SameBoy emulator core to let Perl programs run Game Boy and Game Boy Color ROMs, render frames, capture audio, handle controller input, and manage saves and save states. It exposes a simple API to choose the hardware model, step frames or single CPU cycles, read the current framebuffer or an RGBA buffer ready for web canvases, pull interleaved audio samples, press and release buttons, import cheats, and use rewind or full snapshot persistence. The SameBoy core and permissively licensed boot ROMs are compiled into the module so there are no external dependencies and it runs out of the box. This makes the module useful for developers building emulation-based tools, testing ROM behaviour, generating video or audio output from ROMs, or integrating Game Boy emulation into Perl services. Version 0.01 is the initial release.

Text::Sass is a pure-Perl, lightweight implementation of the Sass and SCSS stylesheet languages that converts Sass/SCSS into CSS and can also translate CSS back into Sass. It implements a practical subset of the language and exposes simple methods such as sass2css, scss2css and css2sass so you can use it without compiling C libraries. The module supports custom functions and recent fixes improved nested selectors and the parent selector (&) in includes. Do note that variables are currently global and the implementation is not as complete or as fast as libsass-based bindings, so consider Text::Sass::XS if you need full conformance or high performance. This module is a convenient choice for small projects, quick prototyping, or environments where installing XS modules is impractical.

Ham::ADIF is a Perl module that lets developers and amateur radio operators read and work with the common ADI and ADX logging formats used by ham radio software. It provides a simple object interface with a constructor and parsing methods for ADI, ADX, or mixed files so you can quickly import log data into your own scripts or applications. The module relies on the companion Ham::ADIF::ADI and Ham::ADIF::ADX components and follows standard Perl practices, making it a practical choice when you need to automate log processing or build interoperability between logging tools. It is distributed under the GNU General Public License.

ClearPress is a lightweight Perl web framework for quickly building simple data-driven web apps with a loosely MVC-inspired structure. It provides a ready project layout and a scaffolding script to create models that represent database rows, view classes backed by Template Toolkit templates, and standard CRUD handlers for list, read, create, update and delete actions. Templates have easy access to useful objects such as the requestor, model and SCRIPT_NAME to build links and forms. Configuration is handled via data/config.ini and the framework uses familiar Perl components like CGI, Template and Config::IniFiles so it fits into existing Perl toolchains. ClearPress favors explicit model definitions rather than automatic schema introspection, which keeps things simple but means schema changes are handled manually. It also does not include built-in authentication and its views act more like controllers than in classic MVC, so it is best suited for rapid development of small to medium CRUD-oriented applications.

Tk::CodeText is a Perl/Tk text widget that gives your GUI application a programmer-focused editor similar to Scintilla, with features you would expect from a lightweight code editor such as syntax highlighting via Syntax::Kamelon, visible line numbers, collapsible code folds, a status bar with document and formatting controls, autocomplete and auto‑bracketing, automatic indentation and block indent/unindent, comment/uncomment commands, bookmarks, an advanced word-aware undo/redo stack, search and replace, theming support and file load/save utilities. It is designed to be embedded in Tk apps or used via the bundled codetext executable and exposes many configuration options and methods so you can tailor highlighting, matching pairs, scrollbar behavior and more. Recent updates improved autocomplete behavior and made the search box independent of the status bar while adding a patch-apply method to XText. One known caveat is that matching of braces and brackets does not consider quoted strings, so matches inside string literals may be treated as code.

CPAN::MetaCurator is a toolkit for building and maintaining a local SQLite database of curated CPAN metadata and related Perl Wiki content, aimed at producing a browsable, machine-readable representation of module information. It ingests CPAN package lists, tiddlers JSON and exported Perl Wiki HTML, optionally reads CPAN::MetaPackager databases, and provides modules and scripts to validate data, search the database, and export the result as a jsTree HTML view with clickable nodes and cross references for "See also" links. The project includes utilities to rebuild the database, gather per-module notes, escape HTML for safe output, and serialize a DAG node tree for later use, so it is useful to maintainers who want to create a navigable curated index of Perl modules and topics. The distribution is actively maintained by Ron Savage, is open source under the Perl 5 license, and recent work added MetaCPAN recent parsing, persisted DAG trees, and other improvements to the export pipeline.

Wildling is a Perl library that expands compact pattern strings into every possible combination according to a shared wildcard grammar, making it easy to generate wordlists, domain name ideas, test data, and similar sets. You feed it one or more pattern expressions and optional named dictionaries, and it returns a client object you can iterate with next(), fetch by index, inspect the total count, and rewind when needed. The module follows the same syntax and command line behavior as the cross-language Wildling project, so patterns are portable and a browser sandbox and docs are available upstream. A returned undef signals that enumeration is exhausted, and a bundled CLI lets you use Wildling from the command line as well.

OSLV::Monitor is a lightweight Perl extension for LibreNMS that gathers OS-level virtualization metrics from container and jail backends and returns them as JSON for easy integration. It auto-selects a backend based on the operating system or lets you pick FreeBSD or Linux cgroups explicitly, and it provides simple configuration options for cache location, time scaling, and include or exclude name filters using regular expressions so you only collect the containers you care about. Usage is straightforward: create a monitor object, call load to initialize the backend, and call run to perform a poll and get structured output suitable for further processing or ingestion into LibreNMS. This module is a practical choice if you need focused, configurable monitoring of OS-level virtual instances within a LibreNMS setup.

JQ::Lite is a pure-Perl, jq-compatible JSON query engine and command-line tool that brings familiar jq-style filters to environments where the jq binary or XS modules cannot be installed. You can use it as a library or via the bundled jq-lite CLI to traverse and transform JSON with dot notation, optional keys, array slicing and flattening, boolean select filters, pipes, map/walk and a large set of built-in helpers for aggregation, string and collection manipulation. It works with only core modules by default while allowing faster decoders like JSON::XS when available, and it is designed for minimal, locked-down, containerized, or air-gapped systems. The project is mature and actively maintained; current release 2.49 tightens argument validation for slice and bracket-slice operations and includes ongoing bug fixes and refinements to keep behavior aligned with jq.

Mail::DMARC is a Perl implementation of the DMARC email authentication and reporting standard that lets MTAs, spam filters and mail senders check whether incoming messages align with a sender domain's policy and handle reporting. You feed it connection metadata plus SPF and DKIM results, call validate, and it returns a Result object that indicates pass, fail and the policy disposition like reject, quarantine or none. The distribution implements current DMARCbis (RFC 9989) while remaining compatible with the original RFC, performs organizational domain discovery, and includes tools to send, receive, view and persist aggregate reports in an SQL-backed store tested with SQLite, MySQL and PostgreSQL. It offers a Pure Perl engine plus an optional XS binding to libopendmarc, aims to implement all MUSTs and SHOULDs in the spec, and keeps a small dependency footprint when reporting features are not used.

Font::Metrics gives you accurate glyph advance widths, kerning adjustments, and basic typographic metrics for the PDF Standard 14 fonts and for TrueType/OpenType fonts loaded from disk, so you can measure text in points at any requested size. It exposes simple methods to get a single character's advance, the width of a string, ascender and descender distances, cap and x heights, natural line height, and the kerning adjustment for a pair of characters; note that string width does not apply kerning automatically so you can add kern_pair between pairs when you need exact layout. Standard 14 metrics come from Adobe AFM data and include the most visually important Latin kern pairs for Helvetica and Times families while Courier, Symbol and ZapfDingbats have no kerning. TrueType/OpenType loading reads the usual font tables including head, hhea, hmtx, cmap, OS/2, kern and GPOS and merges kerning from kern and GPOS with GPOS taking precedence, and cap/x height values come from OS/2 when available with sensible fallbacks for older fonts. This initial release implements the core measurements and table parsing needed for accurate typography and page layout.

EV::Kafka is a high-performance, asynchronous Kafka client for Perl that implements the Kafka binary protocol in XS and integrates with the EV event loop, making it suitable for low-latency, high-throughput producers and consumers against Redpanda and Apache Kafka 0.11 and newer. It gives you a full cluster client with metadata discovery, broker connection pooling, key-based partitioning, producer features like configurable acks, idempotence and transactions, and consumer features including manual partition assignment or consumer groups with automatic rebalancing, offset commits and heartbeats. The module is pure XS and does not depend on librdkafka and it supports TLS and SASL (PLAIN and SCRAM) plus optional compression when the corresponding libraries are present. Usage follows an EV-style lifetime model so you must keep the client object live like an EV watcher and callbacks are guaranteed to fire or return errors on shutdown. Note the module treats all data as raw bytes so you must encode UTF-8 yourself, DNS name resolution is blocking unless you pre-resolve hostnames, GSSAPI and OAUTHBEARER are not implemented, and TLS on Linux can deliver SIGPIPE unless your application ignores it. If you need a fast, full-featured Kafka client embedded in an EV or AnyEvent application and can live with those caveats, EV::Kafka is a strong choice.

DBIx::Class::Schema::GraphQL introspects a DBIx::Class schema and generates a ready-to-run GraphQL::Schema so you can expose your database as a GraphQL API with minimal effort. It maps SQL column types to basic GraphQL scalars, exposes relationships as object or list fields, and creates root Query entry points including singular lookups and plural all<Source>s queries with filtering, ordering, and both offset and cursor pagination. It also generates create, update, patch, and delete mutations for each source and supports composite primary keys. Note the deliberate limitations: relationship fields are unfiltered, mutations accept only flat scalar inputs, custom SQL types map to String, and cursor pagination relies on primary key order. In the recent v0.0.3 release a security fix was added to prevent SQL injection by validating orderBy.field against the source's declared columns. The to_graphql method returns the GraphQL::Schema plus a context you can pass to GraphQL::Execution to run queries and mutations.

Dancer2::Plugin::Feed is a lightweight Dancer2 plugin that lets you generate RSS or Atom feeds from your web app without dealing with raw XML. It wraps XML::Feed and XML::Feed::Entry and exposes create_feed plus convenience shortcuts create_atom_feed and create_rss_feed. You pass feed metadata either in your Dancer2 config or as parameters and provide entries as an arrayref of hashrefs with keys like title, link, summary, content, author, issued and modified. The plugin sets the appropriate Content-Type header for the chosen format and surfaces format-related errors via exception roles so you can handle them in route code. If you want quick, configurable feed generation integrated with Dancer2, this module does the job while delegating the XML heavy lifting to XML::Feed.

AsposeCellsCloud::Role is a lightweight helper within the Aspose Cells Cloud Perl SDK that centralizes configuration and API client creation so the rest of the SDK can obtain ready-to-use service objects. It exposes access to a shared Configuration object for credentials, endpoints and defaults, and delegates client construction to an ApiFactory so API modules do not need to repeat setup code. If you are integrating Aspose Cells Cloud into a Perl application this role simplifies managing connection details and reusing a consistent, preconfigured API surface across your code.

Catalyst::View::Wkhtmltopdf is a Catalyst view that turns HTML or Template Toolkit output into PDF by invoking the wkhtmltopdf command line tool. You configure the view in your app, stash either raw HTML or a template name plus options like page size, margins, filename and disposition, then forward to the view or call render to produce a PDF response or receive a filehandle. The module exposes many wkhtmltopdf options and allows per-request overrides and custom tmpdir and allowed asset paths. The recent 0.6.0 release fixed a command injection vulnerability (CVE-2026-16766), improved argument handling, added more option support and now returns a filehandle instead of raw contents. Note that wkhtmltopdf itself is no longer maintained and relies on old QtWebKit libraries so do not use it with untrusted HTML and consider migrating to a maintained PDF-generation solution.

EV::Gearman is a high-performance Perl client and worker for the Gearman job server built on the libev event loop and implemented in XS so there is no libgearman dependency. A single EV::Gearman object can act as both client and worker, supports foreground and background submissions, synchronous or asynchronous worker handlers, pipelining for high throughput, automatic reconnect and per-request timeouts, and the Gearman admin text commands over the same connection. It exposes simple callbacks for job progress, completion and errors and lets async workers defer completion until later so you can integrate timers or other IO. The module operates on raw byte strings so you must encode/decode UTF-8 yourself and it enforces practical limits such as a 256 MiB packet cap and a 16 MiB admin reply cap. Note that DNS name resolution is currently synchronous and can block the event loop, and some server queue types may not execute scheduled epoch jobs with certain gearmand versions, so validate against your deployment. If you need an efficient, event-driven Gearman client/worker in Perl with low-level control and maximum throughput, EV::Gearman is a strong choice.

Business::ISBN::Data is a companion data package for Business::ISBN that provides the official ISBN range and publisher code information derived from the ISBN Agency's RangeMessage.xml, so Business::ISBN can validate, parse, and format ISBNs correctly. The module is normally loaded automatically by Business::ISBN and ships with a copy of RangeMessage.xml while also falling back to built‑in data or a RangeMessage.xml found in the current directory, and you can point it at an alternate file by setting the ISBN_RANGE_MESSAGE environment variable before loading Business::ISBN. Note that the data structure changed to address an ISBN‑13 prefix bug so you should use Business::ISBN 3.005 or later. The data are updated frequently and available on GitHub, and a recent fix stopped unintended autovivification of ISBN_RANGE_MESSAGE to avoid accidental creation of that variable.

Socket::MsgHdr is a lightweight Perl module that exposes the low level sendmsg and recvmsg socket calls and gives you a convenient object to describe message buffers, peer addresses, and ancillary control data such as file descriptor passing and IPv6 packet options. You create a Socket::MsgHdr object to allocate receive buffers or to pack outgoing data, use the cmsghdr method to build or parse control messages like SCM_RIGHTS, and then call sendmsg or recvmsg just like the C APIs while benefiting from a Perl-friendly interface that also exports into IO::Socket. It is aimed at developers who need advanced socket features rather than simple TCP/UDP I/O, and it notes some portability gaps because the XS layer currently uses RFC 2292 CMSG macros and does not support legacy msg_accrights layouts on very old systems. A recent update makes recvmsg populate the object’s msg_flags field so you can inspect message-level flags after a receive.

Data::NDArray::Shared provides a compact, typed N-dimensional numeric array that lives in shared memory so multiple Linux processes can read and write the same data concurrently. It supports fixed numeric dtypes (floating and signed or unsigned integers), 1 to 8 dimensions with row-major layout, and can be backed by a file, an anonymous mapping inherited across fork, or a transferable memfd. You get element and flat-index access, bulk fills and zeroing, reshape without copying, reductions like sum and mean, in-place scalar and element-wise arithmetic, and convenient conversion to and from PDL when available, including an optional zero-copy PDL alias for in-place PDL operations. Mutations are serialized with a futex-based write-preferring rwlock that includes dead-process recovery so crashes leave the array consistent, though integer arithmetic wraps to element width and very large integer sums may lose precision when returned as double. The module requires 64-bit Perl and Linux only. The 0.03 release fixes a use-after-free bug in add/subtract/multiply, tightens security and robustness, and bumps the on-disk format so files from 0.02 are rejected and must be recreated.

Data::Log::Shared is an append-only, lock-free shared-memory log designed for Linux systems running 64-bit Perl. It lets multiple concurrent writers append variable-length entries and lets readers replay from any offset, which makes it a good fit for audit trails, event sourcing and debug logging. Persistence is optional via a backing file, memfd, or an existing file descriptor, and readers can block waiting for new entries or skip slots abandoned by crashed writers. Truncate marks old entries as logically invalid but does not free physical space, while reset reclaims space but must only be used when no other process is using the log. The API provides append, read_entry, each_entry, tail and count inspectors, wait_for tailing, sync and unlink, and eventfd hooks for notifications. Backing files are created with conservative permissions by default and the module emphasizes high throughput in concurrent append and read workloads.

Data::KDTree::Shared provides a shared-memory k-d tree for fast spatial indexing and nearest-neighbour queries across processes, letting you store up to 16-dimensional points (each with a 64-bit id) and then perform single nearest, k-nearest, axis-aligned box, and radius queries far faster than scanning every point. Points are appended cheaply and the tree is automatically bulk-balanced on first query after inserts so query depth stays logarithmic regardless of insertion order. The index can be shared via a backing file, an inherited anonymous mapping after fork, or a memfd passed between processes, and queries run concurrently while mutations are serialized with a futex-based lock that includes dead-process recovery. The module requires 64-bit Perl on Linux and uses a fixed capacity chosen at creation, so you should size the index up front; there are also practical limits noted around reader-slot exhaustion and a very unlikely PID-reuse caveat for crash recovery.

Data::Intern::Shared is a Linux-only, 64-bit Perl module that stores each distinct byte string once in shared memory and assigns it a compact uint32 id that is stable and usable across processes. It is designed so shared data structures can keep fixed-size integer keys instead of duplicating strings, saving memory and making interprocess coordination simpler. You can create anonymous mappings, file-backed mappings, or transferable memfd mappings to share the same table across forked or unrelated processes. Lookups and intern operations are constant time and the implementation supports concurrent access with writer-preferring locking and crash recovery. Be aware that interning is permanent so there is no per-string removal, keys are treated as raw bytes so wide strings must be encoded first, and the capacities for number of strings and total arena bytes are fixed at construction. The recent 0.03 release changed the on-disk format so existing 0.02 files are refused and must be recreated, and earlier releases hardened security by creating backing files with a secure default mode.

Data::HyperLogLog::Shared is a Linux-only, 64-bit Perl module that implements the HyperLogLog probabilistic distinct-count sketch in shared memory so many processes can estimate the number of unique items seen without storing those items. It keeps a compact array of one-byte registers in an mmap region (default precision 14 uses about 32 KB and yields roughly 0.8% relative error), and exposes simple methods to add single items or batches, read the rounded estimate, merge another sketch of the same precision, clear the sketch, and inspect stats. Processes can share the same estimator via a backing file, an anonymous mapping across fork, or a memfd passed between processes, and mutations are protected by a write-preferring futex-based rwlock with dead-process recovery. The module creates secure backing files by default and supports syncing and unlinking the backing store. Limitations called out by the author are Linux and 64-bit only, no detection of PID reuse in the rare crash-recovery path, and a highly unlikely corner case if more than 1024 concurrent reader processes crash while holding the read lock.