CPANscan

Test::RedisServer makes it easy to spawn a real redis-server for integration tests so your code can exercise a live Redis instance without manual setup. It starts a temporary server by default, accepts redis.conf options as a simple Perl hash, and returns a connect_info blob you can feed directly to the Redis client module. You can disable auto-start and use start, exec or stop to integrate with Test::TCP or other test harnesses, and the object cleans up the server and temp files on destruction while also exposing pid and wait_exit for finer control. The module is maintained to work with modern Redis and Perl releases and recent updates fixed tmpdir handling and a compatibility issue with newer Perl Time::HiRes behavior while improving tests and CI. If your tests need a disposable, configurable Redis process rather than a mock, this module is a straightforward choice, but note it requires the redis-server binary to be present on the test system.

Devel::MAT::Dumper is a small utility module that writes a snapshot of a running Perl process to disk so you can inspect its heap later with Devel::MAT::Dumpfile and related tools. It provides non-exported functions to write a PMAT-format heap dump to a file or filehandle and can be configured at import time to automatically dump on die, warn, END, or on receipt of signals (including an unsafe SIGABRT handler to capture native/XS context). You can control the output filename (with an NNN token for unique numbering), the maximum string length to capture, and whether the file is opened eagerly. The module is useful for diagnosing memory leaks, crashes, and mysterious runtime state on production or remote systems where analysis tools may not be installed. It was split out from the main Devel::MAT distribution so the dumper can be deployed independently. Recent updates add support for Perl internals changes such as Magic v2 from Perl 5.45.2 and related bug fixes to stay compatible with newer Perls.

Hyperman is a high-performance PSGI web server that combines a prefork supervisor with a per-worker event loop to run Plack apps efficiently. You start it with your PSGI app and a worker count and it can handle synchronous responses or async ones via Hyperman::Future so handlers can await timers or I/O without blocking the worker. It supports HTTP/2 (via nghttp2) and TLS with client-cert verification and SNI when built with the appropriate libraries, and it exposes simple timer and io_ready futures plus per-worker stats for introspection. A supervisor process manages worker lifecycles with zero-downtime reload and graceful shutdown, and the implementation is mostly XS/C for low-level performance. If you need extreme throughput for Perl web apps and want built-in async, HTTP/2, and TLS support, Hyperman is worth evaluating, but note that per-worker SO_REUSEPORT accepts scaling can behave differently on macOS so that option is off by default there.

ACME::Base64::Hexagram is a playful Perl module that implements a Base64-style encoding using the 64 I Ching hexagrams as its symbol set. It exposes two simple functions, encode_base64h and decode_base64h, to convert strings to and from a hexagram-based representation, so you can produce a whimsical or obfuscated form of data instead of standard Base64. The mapping follows the King Wen order of hexagrams, a detail clarified in the latest release, and the module is best suited for novelty, themed output, or lighthearted obfuscation rather than serious cryptography.

App::plx is a lightweight command-line helper for creating and using per-project Perl execution environments so you can run your app, tests, or one-liners with the right perl, library paths, and environment without manual fiddling. It records a project layout in a .plx directory, lets you choose or resolve a specific perl binary, composes ordered local::lib and lib directories via simple "libspec" entries, and prepends the appropriate entries to PATH and PERL5LIB while clearing other PERL* variables to keep runs hermetic. Once initialized you can run scripts and commands with a single plx myapp or plx --perl ..., inspect or print the environment with --env, bootstrap dependencies with a layout-aware --cpanm helper, and fine tune configs with --config, --which and --commands. There are convenience modes for bare or user-level setups, ways to install plx into the layout and append a shell hook, and a packed standalone script if you lack cpanm. Note that the bundled --cpanm usage is intended mainly for bootstrapping and requires specifying a local::lib target, and the automatic shell install currently supports bash only.

App::BlurFill::Web is a lightweight web frontend for App::BlurFill that lets users upload an image, specify output width and height, and receive a blurred version in the browser or as a downloadable file. It provides a simple root form for uploads, a POST /blur endpoint that processes the image and returns an HTML result page with a download link, and a GET /download/:filename route to fetch the processed image. Defaults are 650 by 350 pixels but both dimensions can be overridden, and it runs as a PSGI application so you can mount it in any Perl web stack or run the provided Dancer2 container. This release separates the web interface into its own distribution and the recent 0.1.0 update pins App::BlurFill 0.1.0 and adopts a dedicated web container for easier deployment.

App::BlurFill is a small Perl library and command line tool for quickly creating blurred background images from an existing picture. You point it at an input file and specify an output width and height (defaults are 650 by 350), and it scales the image, applies a Gaussian blur, and writes a new image, returning the path to the saved file. If you do not provide an output filename it generates one beside the original with a "_blur" suffix. The web interface was split into a separate App::BlurFill::Web distribution, so installing this module gives you a lightweight Perl API and the blurfill command without pulling in web frameworks such as Dancer2, Plack, or Starman.

App::ElasticSearch::Utilities bundles a collection of Perl command-line tools and a compact library to simplify interacting with Elasticsearch and OpenSearch clusters. It provides ready-made scripts for searching and aggregating index contents, monitoring cluster and node metrics, performing index maintenance and alias management, and copying or applying settings across indices, while also exposing a programmatic API so you can write your own Perl utilities using helpers like es_connect and es_request. The toolkit supports TLS and basic auth with a secure password-exec mechanism, pattern and date-aware index selection, human-friendly size and count formatting, and a noop mode to avoid accidental changes, with configuration driven by simple YAML files. The recent 9.0 release refactors connection handling and centralizes version detection into a Connection component to improve compatibility with different server versions and produce clearer error messages.

Data::Identifier is a format‑independent identifier object that gives you a single, consistent way to work with many kinds of identifiers such as UUIDs, OIDs, URIs and other well known types like GTIN, IBAN and DOI. It stores both the raw value and its type, offers conversion and normalization routines, can generate new identifiers, and provides helpers to extract or produce UUID/OID/URI/ISE forms, compare and sort identifiers, and supply human friendly names or persistent tagnames. The module does some validation and deduplication but does not guarantee to catch every invalid value so you should not rely on it as the sole validator. There are performance knobs such as the experimental option to disable OID support and a register method to cache frequently used identifiers. Recent changes in v0.32 add a global allow_use option to permit selected helper modules, improved support for subobjects, and a digest algorithm generator to expand generation options.

Map::Tube::Plugin::Graph is a Moo role that plugs into the Map::Tube family to turn tube network data into graph objects and rendered maps. It can produce a multiedged Graph object for programmatic graph analysis or hand that graph to GraphViz2 to generate images of an entire network or a single line. You can render PNG, SVG, PDF, DOT/GV and other formats, pick layout engines like dot or neato, output to a file or STDOUT, or return base64-encoded image data for embedding. Key methods are as_graph to get the Graph, render for flexible output, as_png and as_image convenience helpers, and list_drivers/list_formats to discover available GraphViz options. The module requires the GraphViz2 Perl interface and the GraphViz executables, so you need GraphViz installed and Perl 5.8.8 or newer. It is a good fit if you want to visualize or export tube-style maps and also do graph-theory work on the network.

Convert::Pheno is a Perl conversion engine for clinical and phenotypic data that lets you translate between common standards such as Beacon v2 Models Format (BFF), Phenopackets v2 (PXF), OMOP-CDM, REDCap, CDISC-ODM, CDISC Dataset-JSON, FHIR R4, openEHR and simple tabular forms. It is the library behind the convert-pheno command line tool and can operate on decoded in-memory Perl data structures or on file/stream routes, returning converted structures for in-memory calls or writing output and returning a completion status for streaming and file-based routes. You create a converter with Convert::Pheno->new and specify the route via the method argument; mapping-based conversions require Mapping V2 files and older mapping formats are rejected. Failures and unsupported inputs raise exceptions so callers should wrap conversions in eval or other error handling. Full usage details, examples and the project citation are provided in the project documentation.

Net::NATS2::Client is a compact Perl client for the NATS messaging system that makes it easy to connect to a NATS server, publish messages, subscribe asynchronously, and perform request/reply interactions. It supports message headers and header-aware publish and receive operations, optional TLS via IO::Socket::SSL options, configurable read buffer size, and synchronous request waiting for use cases like JetStream APIs, while JetStream features are accessed through a companion Net::NATS2::JetStream module. The client can be configured to attempt automatic reconnection and will restore subscriptions on reconnect, but reconnection is off by default and failed publishes are not retried automatically to avoid accidental duplicate delivery. UTF-8 flagged strings are encoded to UTF-8 when sent so text payloads behave as expected. The module is actively maintained under the MIT license.

Number::ZipCode::JP is a lightweight Perl module for validating Japanese postal codes against Japan Post rules. It accepts common input styles such as a single 7-digit string, a hyphenated form like 100-0001, or separate area and suffix parts, and lets you restrict checks to area-specific codes, company or P.O. box codes, or both. You create an object, set or change the target zip code, optionally import the category table you need, and call is_valid_number to get a simple true or false answer. The module ships with maintainable tables and is updated regularly to track postal changes, making it a handy choice for scripts and applications that need to verify Japanese addresses before processing or storing them.

Common::CodingTools is a lightweight utility module that bundles a handful of ready-made constants and small helper functions you will often reimplement in scripts, making common checks and text/file operations trivial to import and use. It provides named boolean and status constants like TRUE/FALSE, ON/OFF, ACTIVE/INACTIVE, CLEAN/DIRTY and others for clearer code, plus grouped import tags so you can pull in only what you need. Useful convenience functions include slurp_file for reading a whole file into a string, ltrim/rtrim/trim for trimming whitespace, center for basic text centering, tfirst for title-casing, schwartzian_sort for fast custom sorting, and uc_lc/leet_speak for playful case transformations. Recent updates fixed the Schwartzian sort and added the leet_speak alias, and the module is aimed at scripts and small projects that want readable constants and a few handy text and file utilities without pulling in heavier dependencies.

MojoX::Authentication is a batteries-included helper for Mojolicious applications that simplifies common authentication needs by offering local credential logins (in-memory or SQLite) and SAML 2.0 single sign-on support. It wires into your app with an app_startup helper that installs the authentication plugin and injects the current user into the stash, and it exposes opinionated controller helpers for credential login, logout, initiating SAML2 redirects and handling the SAML2 SSO response. You can supply or let it discover a model object, configure the stash key used for templates, and set a default provider name for SAML workflows which assumes a single identity provider by default. The module aims to get you up and running quickly with sensible defaults while still letting you override routes and models as needed, and it requires Perl 5.24 or newer.

Schedule::Cron lets you embed a cron-like scheduler inside a Perl program so you can call Perl subroutines on crontab-style schedules rather than spawning separate scripts with system cron. You define jobs with familiar five- or six-field crontab expressions, add or remove entries at runtime, and choose whether each entry uses a default dispatcher or a specific subroutine with arguments passed literally or via eval. The module supports daemonizing, optional forking so each job runs in its own process, a nofork mode for in-process execution, logging hooks, a customizable sleep hook for integrating IO, and utilities to list, update or compute next run times. It also offers convenience features like a global timeshift and control over process name and logging verbosity. One caveat is daylight savings handling around the backward clock change, which the authors note can produce inconsistent behavior depending on time zone due to the underlying date parser. If you need a lightweight, flexible scheduler inside a long-running Perl program with dynamic job control, Schedule::Cron is a solid fit.

Net::SAML2 is a Perl toolkit for implementing the SAML 2.0 Web Browser SSO flow on the Service Provider side, letting your app build and sign AuthnRequests, generate SP metadata, handle Redirect, POST and SOAP bindings, decrypt EncryptedAssertions and verify IdP responses. It handles common tasks like creating redirect URLs, parsing POSTed SAML responses, validating signatures and metadata, and integrates with many IdPs such as Auth0, Azure, Google, Okta and Shibboleth, so it is useful if you need to integrate Perl web apps with SAML identity providers. Note that it is SP-only and expects XML metadata from the IdP. Recent releases include important security hardening that defends against XML signature wrapping and now require a trust anchor (cacert or cert_text) to validate Responses and Assertions, so upgrading is strongly recommended if you rely on response verification.

XML::Sig is a Perl toolkit for creating and verifying W3C XML Digital Signatures, useful when you need to authenticate or tamper-proof XML documents or fragments such as SAML messages. It can insert signatures into XML or verify signatures already present, supports RSA, DSA, ECDSA and HMAC methods and can embed X.509 certificates, and it understands the usual canonicalization methods and transforms needed so signatures remain valid across equivalent XML serializations. The API is straightforward with sign($xml) to produce signed XML and verify($xml) to check signatures, it can sign elements identified by an ID or by an xpath via id_attr, and after verification you can retrieve the embedded signer certificate. The recent 0.71 release includes important security fixes that enforce a safe subset of characters for ID attributes and reject duplicate or ambiguous ID references, making signature verification more robust. If you work with SAML, XML-based protocols, or any system that must sign or validate XML at the element level, this module is likely relevant.

Task::WebDyne::PAGI is a simple task-style meta-distribution that bundles and installs the Perl modules needed to use PAGI together with WebDyne, saving you from tracking down each prerequisite manually. Install it with cpan or cpanm and it will pull in the required dependencies so you can get on with building your application rather than resolving module requirements. The package is maintained by Andrew Speer and is distributed under the same license terms as Perl itself.

DB::Handy is a self-contained pure-Perl relational database engine that stores tables as fixed-length binary files in a directory and presents a familiar DBI-like API so you can use connect, prepare, execute and fetch methods without installing DBI or any XS modules. It implements a substantial subset of SQL including SELECT with JOINs and subqueries, set operations, aggregates, indexes and common DDL and DML commands, and it offers a low-level engine API for direct control and a VACUUM command to reclaim space. It is a great choice for small local applications, scripts, tests and prototypes that need zero external dependencies and simple persistent storage. Be aware of important limitations though: there are no transactions and AutoCommit is always on, VARCHAR always uses 255 bytes on disk, there are no BLOBs or composite indexes, JOINs accept only simple equality ON clauses in many cases, and FLOAT data files are not portable between different machine architectures. File locking uses flock but failures are ignored so concurrent writers on some network filesystems can interleave writes. If you need a lightweight, easy to embed SQL engine for single-writer or local use DB::Handy fits well, but use a full DBMS such as SQLite for transactional, multiuser or large-object workloads.

Router::Ragel is a high-performance URL router that compiles your route patterns into a single Ragel-generated finite-state machine and embeds it as C via Inline::C so matching runs as a fixed-cost DFA walk instead of per-route regexes. You declare routes with static segments, named placeholders and optional typed constraints, call compile to generate the matcher, and then use match to get the handler and positional captures for a path. It is aimed at applications with many routes or very high request rates and typically outperforms regex- and trie-based routers, but it requires the external ragel binary, a C compiler and make at runtime and produces a process-local shared library so you should compile before forking or warm the Inline::C cache at deploy time. Treat patterns as code because compile emits C from type expressions and validate any untrusted patterns, and note that patterns and paths must be byte strings, matching is exact about slashes, adding routes after compile invalidates the compiled matcher, and when several routes match the most recently added wins. If you need extreme throughput and can meet the build and deployment constraints, Router::Ragel is a very fast, compact routing choice.

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.

Speak is a small Perl module that converts text into spoken audio via Google’s text-to-speech engine and plays it through your speakers. It provides a single speak function that accepts a message as a scalar, reads text from a filehandle, or falls back to the system clipboard and lets you choose the voice language via a parameter, an environment variable, or a simple configuration file. The module logs activity to a file, supports muting either by an environment variable or by creating a small sentinel file, and depends on Clipboard, LWP::UserAgent and URI::Escape so it will use the network to contact the TTS service. Use Speak when you want quick audible notifications, accessibility prompts, or simple voice output from Perl scripts.

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.