CPANscan

Win32::Process is a Perl interface to the Win32 API for creating and controlling Windows processes, letting you spawn programs, open handles to existing processes, suspend and resume execution, set or read priority and processor affinity, kill processes, wait for termination, and retrieve exit codes and PIDs. It exports a set of familiar CreateProcess flags and priority constants and supports creating a process by executable path or by supplying a command line for PATH lookup, while Open lets you attach to an existing PID (note Open-created objects cannot suspend or resume). The module handles Windows quirks such as STILL_ACTIVE exit codes, provides GetCurrentProcessID that returns the Windows PID on Cygwin, and exposes affinity controls where supported by the OS. Recent updates clarified Wait()’s return semantics, fixed KillProcess on newer toolchains, and allowed Create()’s appname and cmdline arguments to be null so the command can be resolved via PATH. Use this module when you need programmatic process lifecycle and management from Perl on Windows.

Text::Template::Permute is a small Perl helper for generating multiple variants of a block of text from a simple template language using directives like {{pick: ...}}, {{pick once: ...}}, {{permute: ...}} and {{comment: ...}}; you write a template with options and the module expands those into different text permutations via its process method, which is useful for creating prompt variations, test data, localized strings, or marketing copy. It is intentionally lightweight and geared toward programmatic generation of many text variants without a heavy templating engine. The module is new and minimal, and the recent 0.002 release swapped out a dependency so single-argument permutation cases work correctly by using Permute::Unnamed instead of Set::CrossProduct.

Plack::Middleware::Statsd is a Plack middleware that collects common web metrics from a PSGI application and reports them to a statsd server, letting you monitor request counts, response times, content types, status codes, request sizes, worker PIDs and a few other useful signals without changing your app code. It requires a statsd client such as Net::Statsd::Tiny and exposes that client via the PSGI environment so other middleware or frameworks like Catalyst can emit their own metrics, and you can tweak sampling rate or supply wrapper callbacks for increment, timing and set_add calls. There is an option to catch and handle fatal errors so metrics continue to be emitted, and it integrates with tools like Plack::Middleware::SizeLimit for process metrics. Known caveats are that nonstandard HTTP status codes may not be recognized and it does not instrument the psgix.informational callback, and the module requires Perl v5.20 or later. This module is a practical choice if you want lightweight, configurable statsd reporting for a PSGI/Plack application.

Catalyst::Plugin::Statsd lets a Catalyst web application emit timing and usage metrics to a statsd server so you can monitor response times, profiling points and other Catalyst::Stats data in your existing metrics pipeline. It plugs into Plack::Middleware::Statsd, exposes a statsd_client accessor and a statsd_metric_name_filter you can override to control which metrics are sent and how names are formed, and you can turn off the human-readable stats report if you do not want it in your Catalyst log. The module is intended for developers who already use Catalyst and statsd and works with clients such as Net::Statsd::Tiny, it requires Perl 5.20 or later and warns that heavy profiling can increase database size. Note the important security change in v0.10.0: reporting of raw session ids is now disabled unless the middleware supports secure set logging to avoid leaking authentication tokens, so follow the SECURITY section when you need to count unique sessions. Source and issue tracking are available on the project GitHub.

JSON::Schema::Modern is a full-featured JSON Schema validator for Perl that evaluates Perl data structures or JSON text against JSON Schema documents up through the Draft 2020-12 specification. It returns rich Result objects and provides many knobs for real-world use, including per-schema specification version selection, several output formats, short-circuiting, recursion depth limits, optional format validation, custom format and media-type/encoding handlers, vocabulary extension, caching for large documents, and an option to collect or populate default values. You load schemas or document objects into its internal index and call evaluate or evaluate_json_string to get detailed error and annotation information, which makes it a good fit for validating API contracts such as OpenAPI. Note that it will not automatically fetch schemas from the network or disk for you, some format validators rely on optional CPAN modules, and you should use a reliable JSON decoder such as Cpanel::JSON::XS and avoid running untrusted schemas because embedded regular expressions and numeric operations can be expensive or risky. Recent notable updates include a complete refactor of media-type handling to a shared singleton with improved charset and parameter support and a small configuration rename from max_traversal_depth to max_depth.

Genealogy::Occupation normalises and translates the messy occupation strings you commonly find in genealogical data imports, turning abbreviated, malformed or archaic entries into consistent, human-readable terms and optionally translating them into French or German. You create a normaliser object and call normalise with a single string or an arrayref of occupations and an optional sex for correct gendered translations; the module filters out non-occupations, expands abbreviations, deduplicates repeated or equivalent entries, applies locale-aware English spellings via Lingua::EN::ABC and then translates when the system locale requires it. It is useful if you need to clean up inconsistent data from genealogy software before searching, reporting or exporting, and it can warn on unknown jobs if you enable warn_on_error when constructing the object. Translation support is currently focused on French and German and the author notes plans to expand the language tables in future, and this release is the initial draft.

File::Raw::JSON plugs fast JSON and JSONL (NDJSON) support into File::Raw by calling the bundled yyjson C codec, registering two plugins named "json" for single-document files and "jsonl" for record streams. Use it to slurp or spew whole JSON files with File::Raw or to stream JSONL records memory-bounded via each_line, and import the XSUBs file_json_decode and file_json_encode when you already have bytes in memory. The JSONL parser uses brace-balancing rather than naive newline splitting so pretty-printed records, records spanning lines, multiple records on one line, and braces inside strings are handled correctly, and chunked reads are reassembled across syscalls. The API accepts options for pretty printing, sorted or canonical keys, relaxed parsing, UTF-8 handling, preserving insertion order via Tie::OrderedHash, and other encoding/decoding controls, with the caveat that ordered decoding is noticeably slower so use it only when order matters. Malformed input croaks with yyjson error text and byte offset, and the module and its bundled yyjson are permissively licensed.

Hypersonic is a Perl micro HTTP server that JIT-compiles routes and the event loop into C so the hot path runs with almost no Perl overhead, delivering very high throughput for static and simple dynamic responses. You register routes in Perl, call compile() to generate and link native XS code, and then run a worker process pool; static handlers are executed once at compile time and their full HTTP responses are baked into C string constants for peak performance while dynamic routes still invoke Perl per-request with JIT-compiled request objects. The server also supports WebSockets and optional room-based broadcasting, Server-Sent Events streaming, compile-time embedded static files, optional TLS via OpenSSL, gzip compression in C, signed cookie sessions, and a JIT-compiled async thread pool and Future API for background work. Hypersonic is most relevant when you need very low latency and high request rates or want to move performance-critical logic into native code while keeping Perl for routing and business logic. Recent updates fix an epoll event-loop code generation bug, correct SSE return handling, and bump the XS::JIT dependency for more reliable compilation.

OSLV::Monitor is a compact Perl utility for collecting metrics from OS-level virtual environments and emitting them as JSON for use with LibreNMS or other monitoring tools. It auto-selects a backend for FreeBSD jails or Linux cgroups but also accepts an explicit backend option, supports include and exclude regular expressions to select which containers to report, and stores cache and output under a configurable base directory. The API is simple, you construct the object, call load to initialize the chosen backend, and call run to produce a JSON payload of container stats; the module also maps Docker names to friendlier labels, seeds zero stats for new caches to avoid start-up spikes, and supports a debug mode via the OSLV_MONITOR_DEBUG environment variable. Recent updates fixed FreeBSD include/exclude behavior and improved name handling, and the module is optimized to use JSON::XS for JSON encoding. If you manage jails or cgroups and need lightweight, per-container metrics for integration with LibreNMS this module is likely a convenient fit.

Task::WebDyne::Starman is a small CPAN task module that makes it easy to install the Perl modules you need to run the Starman PSGI web server as part of the WebDyne stack. It is a metapackage rather than runtime code, so installing it with cpan or cpanm simply pulls in Starman and its related dependencies for you. Recent work unified the module syntax and .sha generation across the Task::WebDyne suite and bumped the release to version 0.004.

Task::WebDyne::Apache is a CPAN "task" bundle that installs the collection of Perl modules commonly required to run the WebDyne application under the Apache web server, providing a convenient one-step way to pull in dependencies via cpan or cpanm so you do not have to install each prerequisite manually. It is aimed at developers and system administrators deploying WebDyne on Apache and is distributed under the same licensing terms as Perl 5.

Task::WebDyne::Plack is a CPAN task distribution that makes it simple to add Plack/PSGI support to the WebDyne web framework by installing WebDyne together with Plack and common server components such as Starman. It is a convenience bundle rather than a new runtime, so it pulls in the modules you need to run WebDyne applications on a Plack-compatible server and speeds setup for development and deployment. Installable via cpan or cpanm, it gives you a ready-to-use stack for running WebDyne apps under Plack.

Mojo::DOM::Role::AttrAccessors is a small role you can apply to Mojo::DOM nodes to read and write HTML attributes using Perl method calls instead of attr calls, so you can do $node->href to get or set a value and chain setters. It also adds a data method for data-* attributes that JSON-encodes references on write and automatically decodes JSON back into Perl references on read while leaving plain strings alone. Unrecognized method calls are autoloaded and treated as attribute accessors, making attribute access feel native. Note that attributes with hyphens like aria-label cannot be used as methods and must be accessed with attr or the data helper for data-* keys, and JSON boolean values are returned as Mojo::JSON boolean objects which behave correctly in boolean context.

Task::WebDyne::PAGI is a tiny CPAN task bundle that pulls in the Perl modules needed to use PAGI with the WebDyne project, so you can install the whole dependency set with a single cpan or cpanm command rather than tracking each module yourself. It serves as a convenience metapackage for developers building WebDyne-based applications that rely on PAGI. The distribution is maintained by Andrew Speer and had a routine version bump in May 2026.

Mojo::Collection::Role::Iterable is a small composable role that gives a Mojo::Collection simple, stateful iterator and cursor operations for walking items in sequence. It adds methods to read the current item, fetch the next or previous item, move the cursor forward or back, reset the cursor and iteration position, and an iterate method that returns the current item while advancing an internal iterator so you can loop through the collection. Increment and decrement are chainable, and the role overloads ++ and -- to move the cursor, so you can traverse without modifying the collection itself. Note that iterate behaves differently in list and scalar context, so use the safe loop form while (my ($item) = $c->iterate) to handle false values like 0 or the empty string correctly.

App::Test::Generator is a toolkit that turns simple input/output schemas into runnable Perl test suites so you can add comprehensive black‑box tests without hand writing every case. You describe a routine in YAML or a Config::Abstraction file and the generator emits Test::Most tests that combine randomized fuzzing, deterministic edge cases, optional static corpora, and property‑based checks via Test::LectroTest, with semantic generators for common data like emails, UUIDs and timestamps, plus seed and iteration controls for reproducible runs. It also includes a SchemaExtractor to infer schemas from Perl code and a mutation‑guided pipeline that produces TODO stubs or augmented YAML schemas for surviving mutants so CI can iteratively close testing gaps, and it integrates with prove and GitHub Actions to produce a coverage and mutation dashboard. The documentation warns that YAML is the best supported format and that fully automatic schema extraction is still evolving. Recent releases improve the dashboard messaging and per‑file coverage links, fix where fuzz schemas are discovered for augmentation, and tighten CI-friendly behavior.

XS::JIT is a lightweight runtime JIT compiler for Perl XS code that lets you compile dynamically generated C that uses the Perl C API and install the resulting functions directly into Perl namespaces without the overhead of Inline::C. It avoids parsing and xsubpp by generating C directly, invokes the system compiler for fast builds, supports caching of compiled modules, and maps Perl names to either wrapper-style C functions or to XS-native functions for zero-overhead calls. The module also exposes a simple C API and helper methods (inc_dir, cflags, libs, static_libs) so other XS modules and build tools can integrate with it, and it provides compatibility macros for Inline::C-style code and convenient macros for argument handling. XS::JIT is aimed at use cases where you generate C at runtime and need fast compile and load cycles; benchmarks show faster first-compile and runtime than Inline::C. Recent updates fix a builder memoization edge case and improve test behavior so tests can skip cleanly when no C compiler is available.

Config::INI::RefVars is a parser for INI-style configuration files that adds powerful variable handling so you can reference other INI values, environment variables, or Perl Config entries from inside the file using the $(...) syntax. It supports multiple assignment operators familiar from make such as =, :=, +=, .= and newer ones like ??= for defaults, lets you reference variables across sections, and provides a special tocopy section that supplies per-section defaults or can be used in a global_mode to behave like true globals. The parser accepts a filename, string or array as input and returns a hash of hashes keyed by section name with resolved variable values, and it preserves section order and offers options to control comment handling and variable name validation. It requires Perl v5.10.1 or later and recent releases have focused on packaging and test improvements with small fixes such as Makefile.PL corrections in 0.24. If you need richer, make-like variable expansion in INI files or convenient environment and Config lookups while keeping a simple INI format, this module is likely relevant.

Mojo::Collection::Role::GroupBy adds simple, flexible grouping operations to a Mojo::Collection instance so you can organize a list of records by a key or computed value. You apply it to a collection with with_roles and then group elements that are all arrayrefs, hashrefs, or objects by an index, a hash key, a method name, a coderef, or by multiple keys at once. The result is a new collection of [key, collection] pairs sorted by key and you get convenience methods to convert that into a hashref, an array of groups, or an expanded collection of key/value pairs for iteration. It is handy for clustering records by category, field, or any derived property. Note that it will raise an error if your collection mixes element types or if you call to_hash or expand on an ungrouped collection without providing a grouping argument.

CPAN::Test::Dummy::Perl5::SKAJI is a minimal placeholder Perl distribution meant for testing CPAN-related tooling and workflows. It provides a harmless module you can "use" in build, install, upload, or test scenarios to exercise packaging and continuous integration pipelines without adding real functionality. This makes it handy for developers working on CPAN clients, CI configurations, or test automation who need a predictable, no-op package to validate processes. The module is maintained by Shoichi Kaji and is licensed under the same terms as Perl, so you can freely redistribute and modify it.

BsDiPa is a Perl binding for Colin Percival's BSDiff that creates and applies compact binary difference patches between in-memory data or files. It provides simple core_diff_* and core_patch_* functions to produce and restore deltas, returns clear status codes, and can detect when inputs are identical. Patches are compressed by default with zlib and the module can be built with optional bzip2, xz, or zstd support, while a raw uncompressed mode is available for testing. You can control compression strength with a global setting or with per-patch I/O cookies to reduce memory use and tune performance. The implementation uses a 31-bit size mode and integrates libdivsufsort for speed, and a few global options and cookies are not multithread safe. Use BsDiPa when you need efficient binary diffs for distributing updates, storing deltas, or minimizing transfer sizes.

SPVM is a statically typed programming language with a Perl-like syntax that aims to give Perl developers a faster, compiled alternative while preserving familiar language features. It provides static types with type inference and static analysis, ahead-of-time and just-in-time compilation, native threads and goroutines for concurrency, and C and C++ binding so you can call native libraries. You can run scripts and one-liners with the spvm command, produce standalone executables with spvmcc, and invoke SPVM classes and methods directly from Perl using its bindings. The project includes standard modules, CPAN support, tutorials and examples on GitHub. SPVM is actively developed and has not reached a stable 1.0 release, so backward compatibility is not yet guaranteed.

Tie::OrderedHash provides an insertion-ordered hash implementation compatible with the Tie::IxHash API but implemented in XS and exposing a public C ABI. You can use it as a normal tied hash and get the same insertion-order semantics and familiar methods such as Push, Pop, Shift, Unshift, Keys, Values, Length and Clear, or construct and manipulate the underlying implementation object directly with an OO interface. The main advantage is that downstream XS code can include tie_orderedhash.h and call tie_oh_* functions to read and write the ordered hash without the overhead of Perl's tie dispatch and with support for concurrent C-level iteration. At the Perl level it is a modest speedup over Tie::IxHash, while the C API delivers the big performance win. The initial 0.01 release adds the public C header and build conveniences for Windows so other XS modules can link to its exported symbols automatically.

Business::ISBN::Data is a companion data module for Business::ISBN that bundles the ISBN range definitions used to validate and parse ISBNs, generated from the official RangeMessage.xml supplied by the ISBN Agency. It is normally loaded automatically by Business::ISBN and requires Business::ISBN version 3.005 or later because of a change to the data structure to fix an ISBN-13 issue. By default it ships with a copy of RangeMessage.xml and also falls back to built-in data if that file is missing, and you can point Business::ISBN at a different RangeMessage.xml at runtime by setting the ISBN_RANGE_MESSAGE environment variable. The actual ranges are exposed in the %Business::ISBN::country_data structure and the module includes tools and instructions for regenerating the default data from a new RangeMessage.xml, the source is on GitHub, and contributions or updates via pull requests are welcome.

lazy is a tiny convenience module that automatically installs missing Perl modules at runtime so your one-off scripts and development workflows stop breaking on first use. It leverages App::cpm to fetch and install modules either globally or into a local lib when you pass -L or set up local::lib, and you can forward any App::cpm options through the import list or via PERL5OPT for tools like prove. The goal is to reduce friction during development and ad hoc use by handling dependency installation for you, and it defaults to global installs while still supporting local installations. The author advises removing lazy before deploying code to production.

Finance::Tiller2QIF is a command line tool and Perl module that converts Tiller Money CSV exports into QIF files ready for import into personal finance programs such as GnuCash, KMyMoney, Quicken and others. It loads Tiller CSVs into a small SQLite database, optionally applies a simple, line-oriented mapping file to translate categories or assign destination accounts and to suppress duplicate card-payment credits, and then emits QIF transactions; you can run the ingest, map and emit phases individually or together. The mapping file supports Perl-compatible regexes scoped to one or more accounts, field-based matching, special actions like keeping the source category, leaving the category blank, or skipping a transaction, and you can run custom SQL before or after mapping for advanced preprocessing. The module is primarily a CLI but exposes submodules if you want to script its parts directly, it accepts U.S. and ISO date formats, and recent updates added a preview command so you can inspect what will be emitted before writing the QIF.

AtteanX::Store::LMDB is a Perl module that provides a persistent RDF quad store built on the LMDB key/value database, making it a good choice when you need durable, high‑performance storage of triples and named graphs. It implements the Attean quadstore API so you can open a store, add and remove quads, count entries, and run pattern queries that return streams of matching statements or iterators of graph names. Common operations like get_quads, get_graphs, add_quad, remove_quad, drop_graph and clear_graph are supported, and the module shares its on‑disk format with the Diomede project. If you work in Perl with RDF data and want a compact, efficient persistent backend that plugs into the Attean ecosystem, this module is directly relevant.

File::Raw::Hash is a lightweight File::Raw plugin that computes checksums and digests without altering the streamed bytes, delivering results to a caller-provided scalar, hash, or array reference via the "into" option. It supports common cryptographic hashes (sha256 default, sha512, sha1, md5), integrity checks like crc32, fast non-cryptographic xxh64 with an optional seed, and blake3, plus multi-algo runs in a single pass so you can collect several digests at once. The module offers HMAC mode for the applicable algorithms, multiple output formats (hex, HEX, base64, base64url, raw), and works across read, write, stream, and record phases so it can digest large files with bounded memory or be inserted into File::Raw plugin chains to hash either on-disk bytes or decoded payloads. All algorithms are vendored reference implementations with no external crypto dependencies. This initial 0.01 release includes verified test vectors for HMAC and blake3 and is aimed at easy, composable checksum and fingerprinting tasks rather than replacing full-featured crypto libraries.

OMOP::CSV::Validator is a Perl module and command line tool for developers and data engineers working with OMOP Common Data Model files that checks CSV files for correct data types and structure. It reads PostgreSQL DDL to auto-generate JSON schemas, maps those schemas to CSV filenames, and then validates each CSV row against the expected column types, reporting row-by-row errors to help catch issues before loading data into an OMOP database. The tool is useful for ETL and data quality workflows involving OMOP CDM datasets, and it is open source software written by Manuel Rueda and distributed under the same terms as Perl.

Params::Validate::Strict is a schema-driven validator for Perl that lets you declare precisely what arguments your code expects and then checks, coerces and sanitizes incoming data accordingly. You define a schema with types like string, integer, number, arrayref and hashref plus constraints such as min, max, regex matches, enum/memberof, optional/default, transforms and element schemas for nested structures. The module supports reusable custom types, union types, object checks, callbacks, cross-field validations and relationship rules like mutually exclusive or required groups, and it returns a new hash of validated and coerced values or raises a clear error when validation fails. It is useful for hardening input to functions or web endpoints, generating black box tests or improving API documentation, and it aims to be a powerful, explicit replacement for older validators while being provided under GPL2 and offered as-is without warranty.