CPANscan

OPCUA::Open62541 is a Perl XS wrapper for the open62541 C library that lets Perl programs act as OPC UA clients or servers. It exposes objects for Server, Client, Variant, ServerConfig, ClientConfig and a Logger so you can create and configure servers, connect clients, read and write node values, browse address spaces, create subscriptions and monitored items, and register callbacks for asynchronous operations and lifecycle events. The module maps most open62541 functionality into Perl method calls and relies on the open62541 documentation for semantic details. Note that the interface is not yet complete and 64 bit Perl builds are required for 64 bit UA integer types.

Data::NestedKey is an object-oriented Perl helper for easily inspecting and modifying deeply nested hash and array structures using simple dot-separated path strings with optional [n] array subscripts. It lets you read, delete and check for deeply nested values without manual traversal and supports convenient set semantics such as a + prefix to append or merge and a - prefix to remove keys or array elements. Array subscripts are supported for get, exists_key and delete but not for set, and you cannot set directly against an array-rooted structure so arrays must be retrieved and edited directly when needed. The object can also serialize its contents to JSON, YAML, Data::Dumper or Storable and includes options for pretty JSON output, making it handy for manipulating configuration files and API responses.

App::Test::Generator is a toolset for automatically creating black‑box tests for Perl code by turning compact input/output schemas into runnable Test::Most test harnesses that combine randomized fuzzing, deterministic edge cases, optional static corpora, and property‑based tests. It reads YAML or programmatic schemas that describe a routine's parameters and return types and emits reproducible fuzz tests with semantic generators (emails, UUIDs, timestamps, etc.), boundary checks, and optional Test::LectroTest properties, and it can be driven from the command line or used from Perl. The distribution also bundles mutation testing, LCSAJ path metrics, a test-quality dashboard that aggregates Devel::Cover and CPAN Testers data, schema extraction from Perl sources, benchmark script generation, and helpers to deploy GitHub Actions workflows so you can run scheduled fuzzing and collect CI-driven improvements. A recent 0.42 release added corpus minimization to keep fuzz corpora small while preserving coverage, a pod-example tester to turn POD examples into round‑trip tests, a benchmark-generator, and a deploy-workflows command plus better CPAN Testers reproduction scripts, making it especially useful for CPAN authors who want to harden their modules against edge cases and automate continuous fuzz and mutation-driven quality improvement.

Mojolicious::Plugin::BarefootJS is a small plugin that integrates the BarefootJS server runtime into a Mojolicious application. It registers a helper named "bf" that lazily provides a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo and lets you render compiled marked templates as native Mojolicious templates. Install it with $self->plugin('BarefootJS') to expose the helper in controllers and templates, and use BarefootJS::Backend::Xslate if you need the same runtime outside Mojolicious. The module is actively maintained and is released under the MIT license.

BarefootJS::Backend::Xslate is a small adapter that lets the BarefootJS runtime render Kolon-format Text::Xslate templates. It either accepts a ready-made Text::Xslate object or builds one from a list of template paths and options, configures HTML auto-escaping, and provides the runtime hooks BarefootJS expects such as render_named which binds the runtime as the bf object, mark_raw for raw HTML, and a customizable JSON encoder. The module is framework-agnostic so it runs under PSGI/Plack or in plain scripts, and it is intended to be used with the @barefootjs/xslate compile-time adapter that emits .tx templates calling runtime helpers as bf methods. If you use BarefootJS and prefer Kolon/Text::Xslate templates this backend connects the two with minimal configuration.

BarefootJS provides a server-side runtime for templates compiled from JSX/TSX so you can render marked templates and produce client JavaScript from Perl without locking into a particular template engine or web framework. Compiled templates call the runtime for helpers, while backend plugins handle engine-specific tasks like JSON marshalling, raw-string marking, JSX children materialization and named-template rendering. The core uses only Perl core modules and you add a backend when you need one; shipping backends include Text::Xslate for PSGI/Plack and a Mojolicious integration. If you want to generate and render JSX/TSX-based templates from Perl while keeping the freedom to choose your rendering stack, BarefootJS is a lightweight, backend-driven option and it has seen active development with multiple releases through July 2026.

Imager::File::TIFF is the TIFF read/write plugin for the Imager image toolkit, letting Perl programs load and save TIFF images and query available TIFF compression codecs. It integrates libtiff so you can pick compression by numeric code or libtiff name and it exposes helper methods to report the libtiff build and runtime versions used by the module. The code aims for robust handling across multiple libtiff releases and includes fixes for warnings handling and memory leaks introduced by libtiff interactions. A few edge cases remain, for example mixed SampleFormat values may not always be handled perfectly because libtiff can expose only the first value, but most common TIFFs are supported and recent releases have improved compatibility and stability. If you use Imager and need reliable TIFF support or want to enumerate compression options, this module is the relevant interface.

Imager::File::JPEG is the JPEG plugin for the Imager image toolkit that lets you read and write JPEG files and also query the underlying libjpeg implementation used at build time. You use it through Imager for normal image IO and you can call its helpers to get the libjpeg type and version and to detect whether it was built with libjpeg-turbo or mozjpeg. The module also reports support for arithmetic coding and whether encoding or decoding of arithmetic coding is available. This is useful when you need to know which JPEG features and performance characteristics are available on your system.

Imager is a mature, full-featured Perl library for creating, reading, writing and manipulating bitmap images across many common formats. You can draw primitives, render text with font metrics, apply filters and effects, blend and composite images, and perform transformations like scale, crop and rotate, with fine control over color, palettes and alpha channels. It is well suited to generating thumbnails, server-side image processing, simple graphics generation and batch image workflows where you want a Perl-native API rather than calling external tools. The module is actively maintained and recent releases include important security and robustness fixes, for example Imager 1.033 resolves an EXIF parsing issue and fixes several memory leaks, so keep installations current for production use.

Devel-Cover-Report-Codecovbash is a small Perl reporter that converts Devel::Cover output into a codecov.json file you can upload with the Codecov bash uploader. It runs as a Devel::Cover report plugin and writes cover_db/codecov.json by default so you can run cover -report codecovbash and then invoke the Codecov bash script to submit your coverage results. The module is lightweight, MIT licensed, and largely derived from an earlier Devel::Cover Codecov reporter, and recent releases improve robustness by avoiding crashes when statements are missing and by correctly marking lines that contain any covered statement as covered. Use it when you want a quick, compatible way to push Perl test coverage to Codecov.

MojoX::MojoDbWrap is a small, practical adapter that normalizes the common parts of Mojo::Pg, Mojo::SQLite and similar database objects and adds a few handy helpers so you can treat different backends the same way. It forwards basic calls like select to the underlying DB handle, exposes the wrapped object and its class, and provides convenience routines id_of and id_or_insert for finding a record id by condition or creating the row and returning its id when missing, with support for custom id column names. It also integrates optional migrations via a migrations_for mapping and is extensible through a wrappers or inserter_for mechanism so you can plug in custom creation and insert logic or pass an existing DB object. The module is aimed at Mojolicious users or any Perl app that needs a lightweight, uniform DB interface across Pg, SQLite or custom drivers, requires Perl 5.24 or later, and was formally released as an official distribution in version 0.002.

HTTP::Validate is a Perl utility for validating and cleaning HTTP request parameters against reusable, human-readable rulesets so your web routes, forms and APIs only receive well-formed input. You define named rulesets composed of parameter rules (mandatory, optional, multiple, split, aliases, defaults, cleaners) and inclusion rules (allow, require, require_any, require_one, etc.) then call either the procedural check_params or an OO validator to get a result object that contains cleaned values, errors, warnings and convenience accessors. The module ships a set of common validators for integers, decimals, enums, booleans and flags, lets you write or parametrize custom validators, and can auto-generate Pod documentation from the rules so your docs stay in sync with validation logic. It works with Dancer, Mojolicious, Catalyst and similar frameworks and can be used with CGI when combined with a persistent handler. The 1.0 release adds list_rulesets, list_rules and value_list methods and fixes a number of bugs to improve reliability and test coverage.

Tree::DAG_Node provides a simple, battle-tested object for building and manipulating N-ary trees by treating each node as an object you can name, attach attributes to, and link into a parent/children structure. It can be used directly or extended as a base class and protects you from invalid linkages like cycles or multiple parents while offering a rich set of convenience methods for adding, removing and replacing children and siblings, traversing depth first, copying subtrees or whole trees, serializing to and from list-of-lists notation, and rendering ASCII diagrams of your tree. The module also includes utilities for reading and writing tree text with UTF-8, for producing test networks, and for explicit tree destruction via delete_tree to break Perl reference cycles and free memory. The API is large and featureful, so it can feel heavyweight for tiny tasks but is efficient for simple use and flexible when you need advanced tree operations or to subclass it for domain-specific behavior. Note that a couple of helpers such as random_network were written for testing and may not be suitable for production randomization without review. If you need a straightforward, well proven way to represent parse trees, syntax trees, game trees or other hierarchical structures in Perl, this module is likely relevant.

Tree::Cladogram renders phylogenetic trees (cladograms) into image files using either Imager or Image::Magick, reading a plain tab-separated text format that lists parent, placement (above/below) and node names. It ships command-line scripts and sample .clad inputs so you can generate publication or web-ready diagrams quickly and tune appearance with options for branch color and width, margins, title and leaf fonts, font sizes, and spacing; the output image type is chosen by the output filename suffix and Image::Magick in particular supports a very large range of formats. The module builds the tree with Tree::DAG_Node, handles overlap of leaf labels, and provides methods to adjust most drawing parameters programmatically, so it fits easily into scripts or batch workflows. Be aware that font support can vary by renderer and platform so TrueType rendering may require the appropriate backend in Imager or use of Image::Magick, a limitation the author documents and accounted for in testing. Recent updates modernize the packaging and licensing files and add an AI_POLICY.md alongside a refreshed LICENSE.

Crypt::PasswdMD5 is a compact Perl module for creating MD5-based password hashes that interoperate with Unix MD5-crypt implementations and Apache .htpasswd files. It provides unix_md5_crypt and apache_md5_crypt to produce compatible hashed password strings and a utility random_md5_salt to generate salts when you do not supply one. The implementation follows the common FreeBSD-style MD5-crypt so hashes can be used with existing systems that expect that format. Use this module when you need to generate or validate legacy MD5-crypt password entries for authentication, but not as a general-purpose encryption tool.

Dist::Mgr is a practical toolkit and command line helper for automating the full lifecycle of a Perl distribution from creation to release. It scaffolds a Module::Starter-based skeleton, wires up Makefile.PL/ExtUtils::MakeMaker metadata, integrates with Git/GitHub and GitHub Actions for CI, manages version numbers and Changes files, updates copyright years, builds testable dists and can upload tarballs to PAUSE/CPAN. The module is designed as a set of utilities invoked from the provided distmgr script and assumes GitHub and Module::Starter for many workflows. Recent releases improved compatibility with newer Module::Starter and modern Perls and fixed a bug that could mis-handle nested module directories when moving generated files after initialization.

Template::Sluz is a compact, dependency-free Perl templating engine that brings a Smarty-like syntax to Perl projects and makes it easy to separate presentation from code. You assign variables in Perl and render template files or strings with familiar constructs such as {$var} and {$obj.field}, modifiers via the pipe syntax, default values, if/elseif/else conditionals, foreach loops, includes, literal blocks, and comments. Any Perl function can be used as a modifier and you can change the single-character delimiters if your templates contain curly braces. The 0.9.4 release introduced an HTML escape modifier and an optional auto-escape mode with a |noescape override, added alternate delimiter support, and significantly improved performance through caching and inlining. It targets Perl 5.16 or newer, has no CPAN dependencies, and is a good fit when you want a small, familiar templating layer for web pages or simple view rendering while retaining control over escaping and output.

String::Util is a compact Perl utility module that bundles a set of small, practical string-manipulation helpers for everyday scripting and web work. It offers trimming and whitespace tools such as trim, ltrim, rtrim, collapse and nospace, safe output helpers like htmlesc and jsquote, quote and brace stripping with unquote, and simple checks and comparisons including contains, startswith, endswith, eqq and neqq. It also provides ords and deords for converting characters to numeric representations, repeat for simple repetition, crunchlines for collapsing blank lines, sanitize for making filenames or slugs safe, file_get_contents to read whole files into scalars or arrays, and substr_count to count substring occurrences. Nothing is exported by default so you import only what you need and you can opt to export everything with the :all tag. Installable from CPAN via cpanm String::Util, it is a lightweight, handy toolkit if you need reliable small building blocks to clean, check, and prepare text.

Concierge is an orchestration layer that bundles authentication, session lifecycle, and user record storage behind a single, consistent API so your app never has to wire those pieces together manually. It uses Argon2 for password hashing and keeps credentials out of user records, supports multiple backends for sessions and users such as SQLite, YAML, CSV/TSV or in-memory, and stores desk configuration and data in a filesystem directory called a desk. The module returns Concierge::Desk::User objects for three participation levels — visitor, guest, and logged-in user — enforces one active session per user, maps cookie-style user_keys for restore flows, and can convert guest sessions into full accounts. Its component pattern makes it easy to swap in alternative auth methods like LDAP or OAuth or to add additional record stores while preserving the same high-level API. If you want a ready-made, extensible identity layer for web applications that separates authentication, sessions, and user data, Concierge is a practical, well-structured choice.

Concierge::Auth is a tiny runtime factory that turns a fully qualified backend class name into a usable authentication backend instance. It does not guess short names or provide defaults, so you must call Concierge::Auth->new with backend => 'Concierge::Auth::Pwd' or another fully-qualified, conforming class and any backend-specific options. The module require's the named backend at runtime, passes all remaining arguments straight through to that backend's constructor, and returns the backend object directly so you can call domain methods like authenticate, is_id_known, enroll, change_credentials and revoke. It will croak if no backend is supplied or if the backend cannot be loaded or constructed. Recent 0.5.0 changes are a breaking refactor: Concierge::Auth was simplified from a monolithic password implementation into this thin dispatcher and the authentication behavior now lives in backends that implement Concierge::Auth::Base; the distribution also includes a built-in file-backed backend Concierge::Auth::Pwd and generator helpers for backends.

App::Greple::xlate is an add-on for the greple search tool that locates specific text blocks in files and replaces them with machine translations, letting you translate only the parts you want rather than whole documents. It supports modern LLM engines (gpt-5.5 via the llm command) and DeepL, caches translations per file so unchanged text is not re-sent, and can re-translate only edited paragraphs while supplying surrounding context to preserve wording. The module provides masking and anonymization features to protect markup and sensitive strings before they are sent to the API, understands template expressions and YAML front matter so generated documents and macros survive translation, and emits results in several convenient formats including git-style conflict markers and plain translated text. A command line tool and Emacs helper are included and Docker images are available so the workflow runs without local dependencies. In the recent 2.00 release the default LLM backend was moved to the llm command and the module gained context-aware differential translation, anonymization and templating features and cache-seeding for recurring reports, making it especially useful for translating structured documents, templates, and large projects while minimizing API calls and preserving consistency.

Inline::CLIPS is a lightweight Perl wrapper that lets you run CLIPS expert-system programs from Perl. CLIPS is a rule‑based engine for expressing facts, templates and rules, and this module provides a simple object interface so you can feed CLIPS code and commands into a CLIPS executable and capture the output. It locates CLIPS from your PATH, from the INLINE_CLIPS_EXECUTABLE environment variable, or via Alien::CLIPS when available, so you can integrate rule‑based logic into scripts without rewriting CLIPS code. If you need a quick way to drive CLIPS from Perl and return results, this module does that with minimal fuss.

App::FileCleanerByDiskUage is a small Perl utility for reclaiming disk space by removing the oldest files under a given directory until disk usage falls below a configured threshold. You call its clean method with a target path and a disk-usage percentage and it will check the current usage, scan for candidate files only when cleaning is needed, optionally preserve a minimum number of newest files, skip names matching a supplied regex, and either perform removals or run as a dry run for testing. It returns a detailed hashref that lists found files, files removed, any unlink errors, and counts so you can log or act on the results, and it can create a PID file to prevent concurrent runs. Note that if you pass multiple paths only the first is used to determine disk usage, so keep paths on the same partition when using more than one.

IPC::Shareable lets Perl programs share variables by tying scalars, arrays, hashes or even objects to System V shared memory so multiple processes can read and write the same data using a common key string. It supports arbitrarily complex nested structures by mapping each referenced child into its own shared segment and it serializes data with JSON by default or with Storable when you need richer Perl-specific types. The module provides flock-like locking with shared and exclusive locks, optional enforcement and warning modes to catch unsafe reads or writes, plus convenience helpers such as singleton() to permit only one running instance, seg_map and shm_segments for inspection, sysv_info for kernel limits, and a suite of cleanup and testing utilities to remove or reclaim leaked segments. Be aware that nested references consume additional system segments and that overall capacity depends on your OS kernel limits. Recent releases focused on robustness under heavy or parallel test loads and on platforms with small semaphore budgets, adding reclamation of orphaned semaphore sets and avoiding leaks that previously caused failures on OpenBSD and other constrained environments.

Web3::Tiny is a compact, dependency-light Perl toolkit for talking to Ethereum nodes that makes it easy to fetch chain data, read contract state, and sign and send simple transactions. It bundles JSON-RPC transport and Solidity ABI encoding/decoding, provides thin contract and wallet wrappers, and uses core Perl modules for HTTP, JSON and big integers while delegating crypto to a small wrapper around the audited libtomcrypt library. The module supports common Solidity scalar types and one-dimensional arrays, EIP-155 replay-protected legacy transactions, and EIP-55 checksummed addresses, so it is well suited for small scripts and services that need basic onchain interactions without heavy dependencies. It does not implement EIP-1559 transactions, event log decoding, ENS resolution, or complex ABI types like tuples and nested arrays, so choose it when you want a minimal, practical client rather than a full-featured Ethereum framework.

SIRTX::Font is a Perl library for reading, writing and manipulating SIRTX bitmap font files and related bitmap formats. It gives you a font object to inspect and edit glyphs and codepoint mappings, tweak font metadata like size, baseline and version, import fonts from SIRTX, PSF and Roman .hex sources, generate simple missing glyphs, deduplicate unused glyphs with garbage collection and export alias maps or images of glyphs. The module also ships named character lists (ASCII, DEC sets, CP437/850/858 and an SIRTX-specific list) and utilities to test, strip or fill codepoints against those lists, which makes it useful for preparing terminal or legacy bitmap fonts. Recent v0.08 work added unified import_font/export_font APIs, a new SIRTX::Font::Renderer with proportional rendering and size calculation, basic glyph attributes and support for exporting .hex, while some older methods such as import_psf, import_hex and the built in render() are now deprecated. Be aware many utilities are marked experimental, methods will die on error, and glyph attributes cannot yet be stored to font files in this release.

HTML::Object is a comprehensive Perl toolkit for parsing, querying and modifying HTML that aims to be fast and safe by only changing the parts of a document you edit instead of rebuilding and re-encoding the entire tree. It ships three usage layers: a lightweight Element API, a full Web API compatible DOM implementation so you can script HTML much like browser JavaScript, and an XQuery layer that offers a jQuery-like interface for convenient DOM manipulation. The parser accepts strings, files, globs or URLs, supports utf8 handling, exposes utilities to create, traverse and replace nodes, and relies on an external JSON tag dictionary to stay aligned with HTML semantics. If you need to fetch remote pages the module returns the HTTP::Response for inspection and it can be configured to provide a global DOM or enable xquery-style shortcuts. The recent 0.6.2 release made no API changes but fixed a bug in XQuery removeClass, switched to DateTime::Lite by default, updated dependencies and improved the documentation.

Stats::LikeR brings a broad, R-flavored toolkit of statistics and data-frame utilities to Perl, offering fast XS-backed implementations of common numeric reducers, hypothesis tests, modeling and reshaping tools and table I/O so you can do R-like analysis without leaving Perl. It understands multiple data shapes (array-of-hashes, hash-of-arrays, hash-of-hashes and array-of-arrays) and provides convenient operations such as read_table/write_table, add_data/assign, reshape helpers (aoh2hoa, hoa2aoh, aoh2hoh, hoh2hoa), summary and view, binning and quantiles, correlation and covariance, many tests (t, wilcox, kruskal, chi-sq, Fisher, KS), linear and generalized linear models with predict, PCA and more. The API returns plain Perl hashrefs and arrayrefs so results are easy to consume, it tries to follow R semantics where useful and it handles missing data and common edge cases explicitly. The module emphasizes speed and practical usability, but documents a few limitations such as Type I (sequential) ANOVA behavior and some factor-level handling in predict that require manual preprocessing when re-expanding categorical variables. If you want a comprehensive, R-like stats toolbox implemented for Perl with attention to performance and familiar data-frame idioms, this module is very relevant.