CPANscan

exact::conf is a small extension that brings Config::App's cascading, merged configuration handling into the exact application framework so you can manage layered app settings with minimal wiring. It exports a single helper, conf, which returns a Config::App object and can be loaded via the exact extension interface or directly; you can also opt out of Config::App's default import behavior so you can supply nonstandard config file locations at runtime. The module is useful for Perl developers building exact-based applications who want a simple, tested way to load and merge environment or site-specific configuration files. The recent 1.09 update adds a security policy to address CPANSec guidance.

Config::App builds a single merged application configuration from multiple YAML or JSON files so you can manage defaults and layered overrides per host, per user, or per environment. It searches up a project directory tree or loads remote files over HTTP, supports include, optional_include and preinclude so files can be combined in different orders, and can record the project root so relative library paths from your config can be injected into @INC. Selectors use pipe-delimited host|user|env strings with a '+' wildcard to apply overrides and the module exposes simple methods to read and write values, return the full merged config, and a find() variant that quietly returns undef if no config is found. The constructor defaults to a singleton for efficiency but you can request separate instances, and all included sources are tracked for debugging. The latest release adds support for preinclude embedded in a section to give finer control over include ordering within scoped overrides.

XML::Enc is a Perl module that adds XML Encryption support so you can encrypt and decrypt XML payloads using public and private keys. It implements standard XML-Enc algorithms and offers a choice of symmetric ciphers like AES and Triple DES and key transport schemes such as RSA-OAEP and RSA 1.5, with sensible defaults of aes256-cbc for data and rsa-oaep-mgf1p for key transport. You create an object with a certificate or private key and call encrypt or decrypt on XML strings, and you can control options like OAEP parameters, label hash, KeyName, and whether to include the XML declaration which is useful for cases like SAML responses. If you need to embed standards-compliant XML encryption into a Perl application for secure transmission or storage of XML documents this module is a straightforward choice.

App::Prove::Plugin::Metrics is a plugin for the prove test runner that emits pass-rate metrics from Perl unit tests so you can feed results into files or external tooling for dashboards and CI. It constructs metric names from configurable pieces such as a prefix, test filename, subtest path and optional assertion label, and lets you control separator characters, allowed characters, and how many nested subtests to include. Output can be written to a plain file or passed to a custom module that provides a save function and may supply default configuration via configureHarness. Metric values can be simple boolean pass/fail flags or rollup percentages. This is useful when you need machine-readable test metrics from existing prove runs. Note that the plugin assumes prove is using the standard console formatter and that rollup behavior may change or be inaccurate under some configurations.

MARC::Validator is a small utility that discovers and exposes validation plugins for MARC bibliographic records so you can see which rule modules are available to validate your catalog data. Its primary method, plugins, returns the names of installed MARC::Validator::Plugin::* modules using Module::Pluggable, making it easy for scripts and tools to enumerate and load field-specific checks such as ISBN, 008/leader consistency, unique identifiers, indexes, UDC, and more. The package is lightweight and focused on plugin discovery rather than performing validation itself. Recent releases expanded many field checks and improved ISBN formatting reporting, and the latest patch fixed packaging metadata in the MANIFEST. Source, license, and authorship are on the project repository.

BitTorrent::Simple is a minimal BitTorrent client that lets you download a single .torrent file to a target directory with a no-frills command-like interface. It implements the basic BitTorrent protocol so you can fetch content but does not include advanced features such as DHT, peer exchange, or simultaneous multiple downloads. Use it when you want a small, easy-to-understand downloader for scripting, testing, or embedding simple torrent capability into a Perl tool. If you need trackerless operation, peer discovery, or a full-featured client, this module will be too limited.

Lingua::Text is a lightweight helper for storing and retrieving the same piece of text in multiple languages, letting you keep all translations in a single object and fetch the right version based on the system LANG or an explicit language argument. You can construct an object from a hash or a single string, set or read language-specific values via methods like $obj->en('Hello') or $obj->fr('Bonjour'), and call as_string to get the current or requested language text. It can also encode stored strings into HTML entities for safe output, but it does not provide a decode method so you should avoid double-encoding. Recent updates validate language codes in the AUTOLOADed accessors and restrict them to two-letter codes. The module is helpful for simple internationalization tasks, though note the unusual license wording that limits personal use to a single computer and asks other users to contact the author.

SimpleMock is a lightweight, extensible mocking framework for Perl that makes it easy to stub subroutines, database access, HTTP clients and simple filesystem calls in tests. It ships with model-driven mock formats for SUBS, DBI, LWP::UserAgent and Path::Tiny and lets you add more models under SimpleMock::Model so teams can share reusable mock definitions. You register mocks globally or temporarily with register_mocks and register_mocks_scoped, and the module maintains a layered stack so scoped mocks override outer ones and are removed when the scope ends. Model modules validate and normalize mock data and provide conveniences such as canned DBI query results and return-value handlers. Be aware that mocks are not versioned so you must ensure compatibility with the real modules you mock, and the author notes potential issues with some XS modules or code that overrides CORE::require; clearing mocks will not restore original sub implementations. The project is on GitHub and contributions to add common adapters are welcome.

SPVM is a statically typed language with Perl-like syntax that lets you write high‑performance code while keeping familiar Perl idioms. It supports ahead‑of‑time and just‑in‑time compilation, can produce standalone executables, and provides tight C and C++ integration plus a Perl binding so you can call SPVM methods from Perl or wrap native libraries. The ecosystem includes many standard and CPAN‑style modules, built‑in support for threads and lightweight coroutines, static typing with inference and analysis, and a focus on performance for numeric and system code. Be aware the project has not reached 1.0 and does not guarantee backward compatibility. Recent work has strengthened the build and packaging toolchain, adding a robust parallel build engine (including Ninja‑style content hashing) and improved cross‑platform linker behavior, and the documentation has been consolidated to make the language and builder APIs easier to use.

Loo is a fast, pure-XS utility for inspecting Perl data structures and for deparsing code references back into readable Perl source. It mimics the familiar Data::Dumper interface while adding built-in ANSI colour output, per-element colour and theme controls, and convenient functional shortcuts Dump, cDump, ncDump and dDump to force or suppress colouring. The object interface exposes Dumper-style options like Indent, Sortkeys, Maxdepth and Deparse plus Colour and Theme for fine-grained appearance and formatting control, and a utility to strip ANSI escapes is provided for plain-text use. Colouring is auto-detected from the environment but can be overridden, making Loo useful for debugging, logging and interactive inspection. Recent updates improved deparsing accuracy and compatibility across Perl releases with fixes for list context, custom ops and several older-Perl edge cases.

Developer::Dashboard gives you a single local home for everyday development tasks by combining a lightweight browser dashboard, a shared CLI entrypoint, and a prompt status layer that all read the same runtime data. It organizes bookmarks, saved pages, quick notes, repeatable actions, background collectors that prepare cached health checks, and compact indicators that drive both the web UI and your shell prompt. The tool also includes helpers for opening files and resolving module or Java class names, small data query commands for JSON/YAML/TOML/properties, and a project-aware Docker Compose resolver so common container workflows live behind one command. It supports layered runtime lookup so project-local ./.developer-dashboard trees can override home defaults without losing shared fallbacks, stages built-in helper scripts privately to avoid polluting your PATH, and provides simple skill extensions you can install from Git for repo-scoped tooling. It is implemented in Perl but works across polyglot projects and ships sensible security defaults like owner-only runtime permissions and optional self-signed HTTPS for the web UI. Recent releases tightened the skill layering behavior so same-repo child layers no longer shadow their base skill and improved the layered skill dispatch, bookmark and config inheritance while adding test coverage for those cases.

Text::ASCII::Convert is a Perl module that normalizes text by replacing non-ASCII characters with visually similar ASCII characters so the result is pure 7-bit ASCII. It accepts either Unicode strings or UTF-8 octets and always outputs characters in the 0x00-0x7F range. The module is aimed at use cases like spam detection and text normalization where attackers or writers substitute accented or foreign letters to hide words because it maps by appearance rather than meaning. That means some letters are transliterated in surprising ways on purpose, for example an eszett may become a capital B and Greek letters may map to visually similar Roman letters. Characters with no ASCII lookalike are turned into spaces and runs of spaces are collapsed, zero-width obfuscation characters are stripped, and control characters such as tabs and newlines are preserved.

CGI::ACL is a lightweight Perl module for CGI scripts that decides whether a client may run a script by checking the client's IP address and geographic origin. You can allow or block individual IPs or CIDR ranges, permit or deny specific countries, and optionally integrate with CGI::Lingua to detect the client's country. It also offers a deny_cloud helper that uses verified reverse DNS lookups to block traffic from major cloud providers, which is handy for reducing bot and scraper traffic. Restrictions are evaluated with the all_denied method and the module supports runtime configuration via environment variables or Object::Configure. Note that IP-based rules can be circumvented by VPNs or proxies.

Mo::utils::IRI is a compact helper for Perl projects using the Mo lightweight object system that provides a single exported function, check_iri, to validate that an object attribute holds a well-formed IRI. You call check_iri($self, 'key') and the module uses the IRI library to parse and validate the value, emitting an Error::Pure error if the value is invalid and otherwise returning undef, so it slips into existing Mo-based validation flows with minimal fuss. It depends on the IRI and Error::Pure modules for validation and error reporting. Recent updates improved how the IRI constructor is used, added support for errors emitted by the IRI module, and included tests to strengthen reliability.

Crypt::OpenSSL::PBKDF2 is a thin Perl wrapper around OpenSSL's PBKDF2 key derivation function that lets you derive cryptographically strong binary keys from passwords or other binary secrets. You call derive for text passwords and derive_bin for binary passwords, supplying the password, salt and its length, iteration count and desired key length, and you can pick the hash algorithm (default SHA1) from any digest supported by your OpenSSL installation. The module produces raw binary keys suitable for use as encryption keys or password verifiers, runs fast because it uses OpenSSL, and will croak on error. It requires the OpenSSL library to be installed and supports modern digests such as SHA-2, SHA-3 and others as they are provided by OpenSSL.

Test2::Harness2::ChildSubReaper is a tiny XS wrapper that lets a Perl process ask a Linux kernel to become a "subreaper" so orphaned descendant processes are adopted by it instead of init, which helps long-running harnesses reliably wait for and clean up grandchildren that double-fork or call setsid. It exposes two simple functions, have_subreaper_support() to detect whether the build and platform support PR_SET_CHILD_SUBREAPER and set_child_subreaper() to enable or disable the flag on the current process. The API is deliberately minimal, it returns success or failure and sets errno on error rather than throwing exceptions, and it is safe to install on non-Linux systems because the XS code falls back to a stub that returns ENOSYS when the kernel feature is not available.

NBI::Slurm is a Perl toolkit for creating, configuring and submitting jobs to SLURM-managed HPC clusters. It provides NBI::Job and NBI::Opts classes so you can define a job name, command, output and error files, and resource requests such as queue, threads, memory and walltime, generate the SLURM header and submit or track the job from Perl code. The distribution also bundles command-line utilities for common tasks like submitting jobs, listing queues and interactively inspecting jobs, making it easy to integrate SLURM workflows without writing raw batch scripts. Recent updates improved the interactive viewer so you can inspect StdOut and StdErr files and added persistence of completed jobs for later inspection. This module is intended for Linux SLURM environments and aims to simplify routine HPC job management.

Chandra provides Perl bindings to the webview-c library so you can build cross‑platform desktop UIs with HTML, CSS and JavaScript while driving them from Perl. It gives a simple API to create and show a window, run or control the event loop, evaluate or dispatch JavaScript, inject CSS and bind JavaScript calls back to Perl callbacks, and to control window properties like title, size and fullscreen. Chandra supports macOS (WebKit/WKWebView), Linux (WebKitGTK) and Windows, where it prefers the modern Edge/WebView2 runtime but will automatically fall back to the legacy MSHTML engine when WebView2 is not present, so you should install the WebView2 runtime for best web feature support and ensure WebView2Loader.dll is available. If you want a higher level application framework or extra helpers look at the companion Chandra::* modules such as Chandra::App. Recent releases added an Edge/WebView2 backend for Windows for Chromium rendering and new components like Chandra::Canvas.

Image::Size is a lightweight Perl utility for quickly discovering an image file's width and height without loading the whole image into memory. You call imgsize with a filename, an open filehandle, or a scalar reference to in-memory data to get numeric width and height plus an optional type identifier, or use helpers html_imgsize and attr_imgsize to produce ready-made HTML width/height attributes or option lists for CGI and Tk. It recognizes a long list of common formats such as GIF, JPEG, PNG, TIFF, BMP, PSD, SWF, WebP and icons, and will fall back to Image::Magick when needed to handle other types. The module caches results for filenames and checks file mtimes to avoid repeated work, offers controls like $NO_CACHE to disable caching, and exposes its cache so you can tie it to shared memory in multi-process web servers. There are a few format-specific knobs such as GIF_BEHAVIOR to choose how animated GIFs are measured and PCD_SCALE to pick a PhotoCD resolution, and note that caching only works for filenames and Image::Magick requires filenames rather than handles.

Net::Z3950::FOLIO is a Perl library that implements the application logic of a Z39.50 server for querying and retrieving bibliographic, holdings and item data from a FOLIO inventory back end, and is the engine behind the z2folio server program. It is configured from a JSON file and exposes two simple entry points: new() to create the service and launch_server() to start a YAZ-backed Z39.50 server that speaks standard record syntaxes and element sets and can produce MARC and OPAC-style records with configurable post‑processing. Note that version 4.x switched to FOLIO’s new expiring-and-refreshing token authentication model so it requires FOLIO releases from Poppy onward, and recent updates add configurable XML element sets (via XSLT) for formats such as MODS and improved handling of holdings and item-level data. If you need a ready-made Z39.50 gateway for a FOLIO instance, this module provides a focused, production-ready solution.

TUI::Vision is a Perl Text User Interface framework intended as a native port of Borland's Turbo Vision 2.0 for modern Perl. The current release only reserves the TUI:: namespace and provides stub modules as placeholders while the existing TV:: codebase is migrated, so it does not yet include usable widgets or runtime drivers. If you need a working TUI toolkit right now this package will not meet that need, but it is the groundwork for a planned toolkit that will add driver abstraction, a unified object and event model, dialogs, validation, and standard widgets. The initial 2.0.0 release (2026-04-16) establishes the namespace, adds stub modules for all TUI::* components, and includes a toolkit placeholder, making this module relevant if you want to follow or contribute to the upcoming migration and development.

Win32::Pipe::PP is a pure-Perl implementation of Windows named pipes designed to be a drop-in replacement for the original XS-based Win32::Pipe. It exposes the familiar new, Read, Write, Connect, Disconnect and Close methods so existing code that talks to named pipes can run without rebuilding XS modules. The module uses Win32::API under the hood and integrates with Win32::IPC, even providing a raw handle accessor, so it fits into typical Windows IPC workflows. It is useful when you need pipe functionality on Windows but cannot install or build XS modules, and it is distributed under the MIT License while referencing other open source components.

Win32::Console::DotNet gives Perl programmers a familiar .NET-style System::Console interface for working with the Windows console, wrapping Win32::Console to expose high-level properties and methods for reading keyboard input, writing formatted text, controlling cursor position, colors, buffer and window size, moving screen regions, handling standard in/out/error streams, and playing beeps. It is aimed at anyone who needs precise, programmatic control of a Windows terminal or who wants to port or mimic .NET console code in Perl. The module handles encodings and code page aliases, supports locking for threads, and returns rich key info for interactive input. It requires Win32::Console and other small helpers and is MIT licensed and actively maintained with recent releases focused on encoding support and a stream of bug fixes and test improvements.

Win32API::Console gives Perl programs direct access to the native Windows Console API so you can control consoles, screen buffers, input events, text attributes, fonts, code pages and window behavior from Perl on Windows. It wraps and extends the Win32::Console XS interface and exposes both ANSI and UTF-16LE wide variants of the classic API calls as well as convenient wrappers that auto-encode Perl strings when appropriate. The module supplies structures and helpers for packing and unpacking console data, functions to allocate or attach consoles, read and write console output and input records, manipulate cursor and window size, and set code pages and control handlers. The API was modeled on the original Windows documentation so you can usually follow MSDN examples, but not every function is supported on every Windows release and there are known platform quirks around UTF-8 on older Windows versions. Use this module if you need low level, Windows-native console control from Perl, especially when Unicode handling or advanced screen buffer operations are required.

Alien::fpm is a lightweight helper for Perl modules that need the fpm packaging tool, handling discovery or installation so you can invoke fpm from Perl without managing RubyGems yourself. It exposes paths such as bin_dir and fpm_gem_home that you can add to PATH and GEM_PATH, and by default on shared installs it will fetch fpm from RubyGems. If you prefer a repository build you can set ALIEN_FPM_GIT_URL to install from git and use ALIEN_FPM_GIT_BRANCH or ALIEN_FPM_VERSION to select a branch or version. This makes it easy for other Perl code to rely on a usable fpm executable while leaving installation and version choices to simple environment variables.

Business::ISBN::Data is a small data-only companion for Business::ISBN that provides the official ISBN range assignments extracted from the ISBN Agency's RangeMessage.xml. Business::ISBN will load it automatically so most users do not need to touch it, but you can point the module at a newer or alternate RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable before loading Business::ISBN. If no external file is available it falls back to embedded data and also looks in the current working directory to help with app bundlers. You must use Business::ISBN 3.005 or later because the data structure changed to correct an ISBN-13 issue. The module includes guidance for regenerating the embedded data, is maintained on GitHub, and is distributed under the Artistic License 2.0.

Test::QuickGen is a lightweight Perl toolkit for creating random test data such as monotonic numeric ids, ASCII and UTF-8 strings, sanitized UTF-8 strings that keep only letters, numbers and whitespace, multiword strings, random integers in a range, optional (nullable) values and random picks from a list. The id generator yields a process‑local counter that increases from zero and the various generators let you control length and character sets while producing uniform randomness suitable for testing and fuzzing. The module is fast, has minimal dependencies, and exposes convenience import tags so you can pull just the helpers you need into test scripts. These generators are not cryptographically secure and are intended only for testing and data generation.

MARC::Convert::Wikidata::Object is a Perl data object that models a bibliographic work or edition extracted from a MARC record for use with Wikidata conversions. It provides a clean API to hold and retrieve common bibliographic attributes such as title, subtitle, edition info, authors, editors, translators, ISBNs and ISSNs, publishers, series, page counts, publication dates, external identifiers and digital copies, plus specialized roles like illustrators, narrators and photographers. The module is intended for library and metadata workflows where you want a structured, validated representation of a book or edition before turning it into Wikidata statements and it performs type and array checks on inputs to keep data consistent. It is part of the MARC::Convert::Wikidata ecosystem and relies on a few small CPAN utilities for validation and error handling. Note that a few fields such as language formatting and some date handling are noted as TODO in the documentation.

Business::CAMT is a Perl toolkit for working with ISO20022 CAMT cash management XML messages such as CAMT.053 used by banks and accounting systems. It reads validated CAMT XML into predictable Perl data structures, can create messages from Perl hashes, and can write messages back out as XML or emit JSON or Perl dumps for inspection. The module handles schema versions with configurable matching rules, offers options to use readable long tag names and to enable Math::BigFloat for very large amounts, and reuses a compiled schema object to avoid expensive recompilation. Not every historic schema version is included so you may need to tune the schema matching policy for some files and the author notes higher-level abstractions and converters are planned but need sponsorship. If you integrate banking cash‑management files in Perl this module gives a practical, standards-aware foundation to parse, produce and inspect CAMT messages.