CPANscan

JSON::Schema::Fast is a high-performance JSON Schema validator for draft 2020-12 that compiles a schema once into a compact intermediate form and then validates Perl data with a tight C interpreter, making repeated validation very fast and allocation-free on the success path. You compile a schema and then call is_valid for a quick boolean check or validate to collect structured errors that include instanceLocation, keyword, schemaLocation and a human message. The module supports a useful subset of draft 2020-12 features including core $ref within the same document, type checks, numbers, strings, arrays, objects and applicators like allOf/anyOf/oneOf, and it offers optional conveniences such as non-destructive coercion of numeric and boolean strings and applying default values into a working copy. It reports unrecognized keywords so you can detect schemas that rely on unsupported features. Remote and cross-document $ref resolution, anchors/$id-relative resolution and unevaluated* semantics are deferred to future releases, so this module is a good fit when you need a fast, local-schema validator with predictable error reporting and a focused, modern feature set.

Datafile::Hash is a lightweight, pure-Perl helper for loading and saving simple key/value files and INI-style configuration files that may include multi-level section names. It reads data into a Perl hash using flat keys, dotted keys, or true nested hashes and offers configurable delimiters, comment characters, header skipping, filtering by string or regex, and safe handling of quoted values. When writing it performs atomic updates, can make backups, insert top comments, set file permissions, and will quote values as needed so round-tripping common config formats is painless. The API returns entry counts and message arrays instead of dying on errors so it is easy to embed in scripts and tools. Recent releases added INI-mode with nested sections, search filtering, verbose diagnostics, atomic writes and improved UTF-8 and test coverage, with the latest update focused on test quality and a repository move.

JMAP::Tester is a lightweight Perl client designed to help developers test JMAP servers by sending method calls, handling uploads and downloads, and inspecting the structured responses that JMAP returns. It wraps requests into JMAP methodCalls, encodes and decodes JSON with support for JSON::Typist typed values, and organizes server output into easy-to-test units called Sentences and Paragraphs with helper methods to assert and extract expected results. The module can obtain and apply client session information for authentication, manage default arguments and capability declarations, and perform raw HTTP requests when you need low level control. It can operate synchronously or return Future objects for asynchronous workflows, and it offers options for pretty JSON output and configurable JSON codecs. The library is still in early development, so expect evolving behavior, but it provides a practical, test-focused way to exercise JMAP endpoints and validate responses.

DateTime::Format::XSD is a small Perl helper that turns DateTime objects into XML Schema xsd:dateTime strings so your timestamps match the exact YYYY-MM-DD"T"HH:MI:SS(Z|[+-]hh:mm) profile expected in XML and many web services. It builds on DateTime::Format::ISO8601 so it can parse a wide range of ISO date formats but always emits the strict XSD representation, making it a good choice when you need predictable, standards-compliant output. The module is lightweight and easy to drop into code that produces XML or interoperable timestamps. The recent 0.5 release includes a dependency update addressing a nanoseconds handling fix and adds a security policy and minor packaging improvements.

CLI::Simple is a lightweight object oriented toolkit for building Perl command line tools that parse Getopt::Long-style options, dispatch subcommands, and handle positional arguments with minimal boilerplate. It is built around the modulino pattern so a single .pm file can act both as a reusable module and as an executable script. For small scripts you subclass and define cmd_* methods, and for larger projects you declare commands and options in a YAML manifest and implement each command as a Role::Tiny role so CLI::Simple composes, dispatches, and scaffolds a role-based layout for you. It also auto-generates getter/setter accessors for options, integrates optional Log::Log4perl logging, supports aliases, default values, bash completion generation, and utilities to dump a manifest or scaffold roles to help migrate existing scripts. The design is intentionally minimal rather than a full framework which makes it a practical choice for internal tools, admin scripts, and projects that want an easy path from a simple script to a composable, testable command suite.

Command::Run is a lightweight Perl utility for running external commands or invoking Perl code references while capturing their input and output. It offers a fluent, chainable interface to set command, stdin and stdout/stderr handling and exposes captured output via a temporary file path like /dev/fd/N so you can hand results to other programs, and it uses only core modules. For Perl code references it can run them in-process (nofork) and optionally in a raw mode to avoid encoding overhead and gain large speedups for tight loops. Recent releases fixed a PerlIO layer leak that affected long-running nofork usage and made run() accept temporary parameters such as command and stderr so passing a scalar reference to run now correctly captures error output.

Amazon::Signature4::Lite is a compact, dependency-light Perl module that builds AWS Signature Version 4 authorization headers for S3 and other AWS services. You create a signer with your access key, secret key, region and optional session token, then call sign with the HTTP method, URL, any extra headers and the payload to get a hashref of ready-to-send headers such as Authorization, x-amz-date, x-amz-content-sha256, host and x-amz-security-token when applicable. The API is designed to work directly with HTTP::Tiny-style scalars and hashrefs rather than LWP or HTTP::Request objects which makes it a good fit for lightweight scripts or environments where you want minimal dependencies. It also offers a helper to extract service and region from common AWS endpoint hostnames but that parsing is tuned to S3/AWS patterns rather than being a general URL parser.

Module::CoreList is a lookup library and command line tool that tells you which modules and which versions shipped with each Perl release. It provides a simple API to answer questions like when a module first appeared in core, whether a particular module and version are bundled with a given Perl, which modules match a pattern across releases, and what changed between two Perl versions. The distribution also exposes ready-made data structures you can inspect from code, such as per-release module/version maps, release dates, deprecation and removal information, and upstream or bug tracker pointers. That makes it useful for CPAN authors, system packagers, and developers who need to know if they can rely on a module being available without installing extra dependencies. There is broad coverage of modern Perls with all stable releases since 5.6.0 and development releases since 5.9.0 included and partial coverage for very old releases. The module is maintained by the Perl 5 Porters and is installed with a command line helper named corelist for quick interactive queries.

CPAN::Perl::Releases is a tiny utility module that maps every Perl release uploaded to CPAN to the relative "authors/id/" path where its tarball lives, making it easy for scripts and tools to locate specific Perl tarballs for download or inspection. You call perl_tarballs with a Perl version and get back a hashref showing available archive formats such as tar.gz, tar.bz2 or tar.xz and their CPAN paths, and there are convenience functions to list all known perl_versions and to list perl_pumpkins, the PAUSE IDs of the authors. The data is static but maintained regularly as new Perl releases and release candidates appear, and the package is kept up to date with recent releases such as the latest 2026 updates for v5.40.5-RC1 and v5.42.3-RC1.

Mojolicious::Plugin::Fondation::Auth::Token provides simple personal access token support for Fondation-based Mojolicious applications by adding an opt-in route condition fondation.bearer that lets API routes accept Bearer tokens. Tokens are random strings whose SHA-256 hashes are stored in an api_tokens table and are meant to be created outside HTTP flows via CLI or fixtures. When a route uses fondation.bearer it will accept a valid Bearer token or a normal cookie session, return 403 for invalid tokens and 401 for unauthenticated requests, and routes that do not opt in will reject any Bearer header with 403. The plugin integrates with Fondation::Auth and the DBIx async model component and works alongside Fondation permission and group checks so you can stack authorization conditions as needed. This is the initial 0.01 release.

CPANSA::DB is a small Perl module that ships the CPAN Security Advisory dataset as a ready-to-use Perl data structure. It exposes a single db function that returns a hash reference of all advisory reports so scripts and tools can programmatically check known security advisories for CPAN distributions. The module is primarily used by CPAN::Audit but can be consumed by any code that needs the advisory data, and a JSON equivalent is also available. Releases are published on GitHub and include GPG signatures and GitHub attestations so you can verify the archive and trust the data before using it.

App::sdif is a small suite of terminal tools for making diffs easier to read and track. The sdif command prints diffs side-by-side with color, column and tab controls and works smoothly as a git pager so you can read git diff, log or show output in a friendly two-column layout. The cdif tool adds fine-grained visual effects that highlight changed words or characters and can use MeCab for better tokenization of Japanese text. The watchdiff utility repeatedly runs one or more commands and displays their output with visual emphasis on what changed so you can monitor live differences. The package is configurable via dotfiles, includes many options for color, visibility and truncation, and recent releases fixed a watchdiff regression so commands actually execute again and restored support for multiple --exec entries.

Mojolicious::Plugin::Fondation::Asset is a thin wrapper around Mojolicious::Plugin::AssetPack that gathers asset rules from all Fondation plugins, merges them into a single assets/assetpack.def file via the included "asset generate" command, and processes those bundles so they are available to your app. The generate command normalizes remote fetch directives so external URLs are treated correctly and caches downloaded files so they are not re-fetched at runtime. At startup the plugin only loads AssetPack if the merged assetpack.def exists, registers plugin public directories as stores, and calls process to expose assets to templates while emitting a warning and continuing if the def is missing. Use the "-y" option to overwrite without prompting. Recent releases require Fondation >= 0.05 to include the built-in share/assets/assetpack.def and add GitHub issue tracking in the module metadata.

Devel::LeakGuard::Object is a small utility for detecting Perl object memory leaks by counting blessed instances per class and reporting any imbalances that indicate leaked allocations. You can track a single object, wrap a block of code with leakguard to catch leaks within that scope, or enable global tracking so every bless is monitored and a summary can be shown at program exit. The leakguard call can warn, die or call a custom callback when leaks are found and offers filtering and tolerance options via only, exclude and expect so you can ignore or allow known, acceptable allocations. The module also exposes leakstate and track for programmatic inspection and a status summary facility. Be sure to load it early so it can intercept bless calls and note that overloading bless makes object creation somewhat slower, although the author reports the slowdown is small for typical programs.

Sys::Async::Virt is an asynchronous Perl client that implements the LibVirt remote protocol so you can control hypervisors remotely or locally using non blocking RPCs. It exposes an object oriented API that maps most libvirt protocol calls to methods which return Futures and can be awaited with Future::AsyncAwait, and it supports event subscriptions and callback objects for domains, networks, storage pools and node devices. The module translates C conventions into Perl friendly types by converting bitmap fields into arrays of booleans and representing typed parameters as descriptive hashes, and it ships with a large set of libvirt constants for flags and event ids. Generated against libvirt protocol v12.6.0, it works with newer servers while calls may fail on older servers that lack specific features, and the distribution is currently experimental with a few documented limitations and unimplemented entry points such as some file descriptor related calls. Choose this module when you need programmatic, asynchronous control of libvirt managed resources from Perl and can tolerate the noted gaps in protocol coverage.

Mojolicious::Sessions::Store provides server-side session storage for the Mojolicious web framework by replacing the default signed-cookie approach with a model where the browser only holds a signed cookie containing a session ID and all session data is kept in a backend of your choice. It is a drop-in change for application code because the existing session helper works the same, and it supports configurable options carried over from Mojolicious::Sessions such as cookie name, domain, path, expiration, secure and samesite. A simple file-based backend is included and custom backends can be written by implementing load, save and delete methods, so you can store sessions on disk, in Redis, in a database or elsewhere. The module is lightweight and focused on moving session data off the client; the most recent release replaced a dependency with Mojo::Util::random_bytes and updated its GitHub issue metadata.

Protocol::Sys::Virt implements the libvirt RPC protocol in Perl, providing the low-level mechanics needed to build libvirt-compatible clients and, in principle, servers. It follows libvirt's versioning so it stays aligned with libvirt API releases and is particularly useful if you need a nonblocking, asynchronous approach to talking to libvirt from Perl because the higher-level Sys::Virt interface is blocking by design and Perl threading is impractical for that use case. This module is aimed at developers who need direct protocol-level control or want to build an async libvirt client in Perl rather than those looking for a polished, high-level virtualization management library.

Web::Request is a lightweight request object for PSGI/Plack applications that converts the raw PSGI environment into a simple, consistent API for reading client IP and host, scheme, method, paths, headers, cookies, body and query parameters, uploads, URI and session data and for creating response objects. It is designed to be mostly read-only so you should not mutate returned objects, with the single supported exception of the encoding attribute which you can change to control how request body and parameters are decoded and how new responses are encoded. You can construct it from a PSGI env or an HTTP::Request and it defaults to Web::Response for responses and Web::Request::Upload for uploads with iso8859-1 as the default decoding. The API closely follows Plack::Request but is aimed at application authors who want a slightly higher-level, more user-friendly interface. The recent 0.12 release clarifies encoding behavior when creating responses and fixes decoding of undefined query parameters for compatibility with newer URI versions. If you build PSGI apps and want a convenient, well-maintained wrapper around the environment to simplify routing and parameter handling, Web::Request is likely a good fit.

Mojolicious::Plugin::Fondation::Model::DBIx::Async is a Fondation plugin that integrates DBIx::Class::Async with Mojolicious so your DBIC queries run in a background worker pool instead of blocking the event loop. It provides simple helpers like schema_class, schema and model so controllers can obtain native DBIx::Class::Async ResultSets and get Future-based results from operations such as search, create and find. You declare named backends and models in your app config, the plugin auto-discovers Result and ResultSet classes from Fondation plugins, and each backend gets its own lazy-forked worker pool that is cleanly shut down on process exit. This makes it easy to keep web requests responsive while running parallel database work, though you should remember to retain Future chains to avoid premature garbage collection. Recent updates improve many_to_many prefetch handling and upgrade integration with async many-to-many relationship support.

DBIx::Class::Relationship::ManyToMany::Async is a small helper for DBIx::Class that creates non‑blocking, Future‑returning many‑to‑many accessors so you can use pivot relationships with DBIx::Class::Async worker pools. Given an existing has_many pivot and belongs_to target relationship it generates a read accessor that returns a Future resolving to an arrayref of related rows and helper methods like add_to_x, remove_from_x and set_x that return Futures for linking and unlinking targets. It is designed for people who already use DBIx::Class::Async and need the same many_to_many conveniences without blocking, but it assumes the target table uses a primary key named id and can hit JOIN issues if your relationship name is an SQL reserved word unless you enable proper quoting. The module is experimental and the API may change, and the latest 0.02 release fixes a bug where prefetched rows could return null by using the belongs_to accessor, uses the cached ResultSet directly, and corrects an internal package variable initialization.

Module::Pluggable is a lightweight helper for Perl modules that adds simple plugin discovery and loading to your code. You add it to a package and it exports a method (by default named "plugins") that scans one or more namespaces or directories for plugin modules and returns their package names or instantiated objects. It supports flexible options for where to search, how to filter or sort results, whether to require or instantiate plugins, depth limits, and hooks for handling require or instantiate errors, so you can tailor discovery to your application. Discovery happens at call time which makes runtime extension easy but can be cached for performance if you do not need dynamic loading. The module plays nicely with tools that expose files via @INC hooks and can use Module::Runtime when available for safer require behavior. If you want an easy, configurable way to give your module a plugin architecture without pulling in a heavy framework, Module::Pluggable is a practical and well established choice.

Version::Semantic is a Perl class for representing immutable Semantic Versioning (SemVer 2.0.0) numbers as objects so you can parse, print, compare and increment real semver strings including optional "v" prefixes, pre-release tags and build metadata. You create objects with parse() or new(), inspect attributes like major, minor, patch, prefix, pre_release and build, stringify versions for output, and use the built-in comparison behavior to order versions according to SemVer precedence. It also exposes the regular expression used for parsing via semver_re() and provides an increment() method that supports major, minor, patch and an experimental "trial" strategy for TRIAL pre-releases. Note that as of v2.0.0 parse() now returns undef for unparsable strings by default and only throws an error if you request a fatal parse, so code that relied on earlier behavior should be updated. This module is a good fit when you need accurate, comparable SemVer objects in Perl scripts or release tooling.

Mojolicious::Plugin::OAuth2::Server is a plugin that makes it straightforward to add a full OAuth2 authorization server and resource-server checks to a Mojolicious app. It implements the standard RFC6749 flows you are most likely to need, including Authorization Code, Implicit, Client Credentials and Resource Owner Password Credentials, and it delegates the heavy lifting to Net::OAuth2::AuthorizationServer while exposing simple controller helpers such as $c->oauth to validate Bearer tokens and scopes and oauth2_auth_request to build authorization redirects. The plugin can optionally emit JWT tokens so you can run stateless, multi-process servers if you supply a jwt_secret, but that mode trades off automatic token revocation. Extension grants are not implemented. Recent maintenance releases have updated compatibility with newer Mojolicious and Perl versions and tightened tests to satisfy modern JWT libraries.

Scalar::ValueTags::LineageTracking lets you attach, propagate, and collect source metadata on Perl scalar values so you can build data lineage for pipelines and tools like OpenLineage. You instantiate a tracker with tag_type 'string' (the default) or 'ref', then add or set source tags when data enters your system and those tags are carried forward automatically whenever new values are derived; you can retrieve or clear tags when data leaves your system. String tags are de-duplicated by their serialized text so you should produce canonical strings, while ref tags are de-duplicated by reference identity and therefore require reusing the same Perl reference for identical tags. The module exposes add_data_sources, set_data_sources, get_data_sources and clear_data_sources (which returns prior tags for reporting). Recent changes simplified the API by pluralizing the add/set methods and making clear_data_sources return previous sources, replacing the old get_and_clear behavior.

Table::Readable provides a tiny, human-editable text format and a small Perl API for storing and manipulating simple tables of key/value rows in UTF-8. Files consist of blocks of "key: value" pairs separated by blank lines and are read into Perl as an array of hashrefs, with simple rules for keys (spaces become underscores) and multiline values delimited by lines beginning with "%%". The module can read and write these tables, append rows, sort files, and build an index hash by a chosen key while optionally returning the original order, and it preserves leading and trailing whitespace via backslash escapes. The format intentionally avoids nesting, extra syntax, or complex escaping so it stays easy to edit by hand, and recent changes (v0.06) added an append_table function and a noslash option to control backslash handling. If you need a lightweight, human-friendly way to keep machine-readable lists or translation text files, this module gives a stable minimal parser and writer with Emacs and Go support available in the project repository.

WebService::Mailgun is a lightweight Perl client for the Mailgun HTTP API that lets Perl applications send messages and manage basic Mailgun resources without dealing with raw HTTP calls. It supports sending plain and MIME messages including attachments, managing mailing lists and their members, querying events with polling and fetching stored messages, and basic template operations with partial template support. You can configure the API key, domain and region (US or EU), and choose whether API errors raise exceptions via RaiseError, while error and error_status helpers give easy access to failures. Several Mailgun endpoints are not yet implemented, for example domains, stats, tags, suppressions, routes, webhooks and full email validation, so this module is best when you need straightforward sending, list management and event access from Perl. Recent releases improved testing by reading credentials from environment variables and migrated continuous integration to GitHub Actions.

DB::x is a tiny debugging helper that lets you drop lightweight breakpoints into Perl code without changing the surrounding logic, either by inserting DB::x to unconditionally stop execution or by using DB::x 'label' so the pause only happens when $DB::x{'label'} is set true from your main script. This makes it easy to toggle breaks for code paths that run frequently because you avoid adding per-call checks, and it integrates with the debugger hooks so you can control labeled breakpoints at runtime. Recent releases added an explicit conditional-debugging form (DB::x 'Feature') and several debugger command improvements, and the module requires Perl 5.12.0 or later.

POE::Component::Server::JSONUnix is a lightweight, event-driven server that listens on a Unix domain socket and exchanges newline-delimited JSON request/response messages, making it a simple local RPC or control endpoint for daemons and command-line tools. Built on POE, it exposes a pluggable command dispatch table you can populate at startup, add to at runtime, or provide by subclassing, and handlers may reply synchronously or asynchronously using a context object that carries the request and reply methods. Messages are single-line JSON objects with an optional id for correlation and the server includes handy built-ins like ping and commands for discovery. Security is handled both by Unix socket permissions and by an optional ownership-based authentication handshake that verifies a client by the owner of a temporary file, and you can enable a per-command allow/deny policy based on users or groups. The recent 0.1.0 release adds the auth_start/auth_verify handshake, a POE-based client and a simple blocking client, and the flexible permissions layer, so if you need a compact, extensible way to expose local control APIs on Unix this module is a strong candidate.

Stats::LikeR brings a rich set of R-like data frame operations, statistical tests and modeling tools to Perl with many performance-critical routines implemented in XS so common tasks run quickly and with low memory overhead. It understands multiple table shapes (array-of-hashes, hash-of-arrays, array-of-arrays and hash-of-hashes) and supplies data I/O and wrangling helpers such as read_table, write_table, view, melt, pivot_table, assign, concat and merge alongside numerical and inferential routines including lm, glm, aov, coxph, t_test, wilcox_test, chi-squared, Fisher, ROC/AUC, ROC DeLong CIs, ANOVA/oneway tests, survival analysis and many effect-size and post-hoc utilities. The API is designed to feel familiar to users of R and pandas so you can group, aggregate, reshape, bin, interpolate or join tables and then run the usual statistical summaries and tests without leaving Perl. Recent work focused on ergonomics and speed: p_adjust now accepts whole data frames and returns corrected values in the same shape, merge was reworked for much lower memory use and faster joins, and new helpers h2aoh / aoh2h make it easy to fold and unfold plain hashes into two-column tables. Note that a small incompatible change was introduced upstream: the ad-hoc '?' / 'h' help argument that some Perl wrappers previously accepted was removed in favor of the dedicated h() printer and write_table now defaults to not emitting row names unless requested. If you write Perl and need fast, R-like data manipulation and statistical routines without switching languages, this module is likely highly relevant.

Hash::SharedMem provides a fast, file-backed key/value store that lets multiple processes on the same host share mutable data by memory-mapping files, so you get low-latency interprocess communication without blocking. Keys and values are limited to octet (Latin-1) strings, though you can store complex Perl structures if you serialize them first with something like Sereal. The API gives handle-based access with explicit read/write modes, atomic single-key operations (including get-and-set and compare-and-set), snapshot handles for consistent read-only views, and whole-hash helpers for listing keys, counting items, and estimating storage. It also offers maintenance calls to idle or tidy a handle and per-handle event counters useful for profiling. The module is designed for cases where the dataset fits in RAM or a memory-backed filesystem, so it is ideal for local caches, counters, or daemon-shared state, but performance will suffer if the data is mostly on disk. Creation is not atomic and file ownership and permissions can be awkward in multiuser scenarios, and the on-disk files are not guaranteed to survive an OS crash in a consistent state.