CPANscan

HTML::D3 is a small Perl helper for quickly producing D3.js charts by emitting the HTML and JavaScript needed to display bar charts, line charts, multi-series line charts and variants with tooltips, animated tooltips, legends and interactive legends. You create an object with optional width, height and title, pass simple arrayref data structures, and the module returns ready-to-use HTML/JS snippets for embedding in a web page or template, with a convenience method that returns an embeddable fragment (svg_id and html) for use in Mojolicious or similar layouts where you want to manage the page wrapper yourself. It is aimed at Perl developers who want to generate visualizations without hand-crafting D3 code and expects you to include the D3 library in your page when using fragments. Recent updates in v0.08 added Params::Get, Object::Configure support, a test dashboard and the render_line_chart_snippet helper, plus a tidy-related bug fix for tooltip escaping. The module is provided as-is under GPL2 and is useful when you need simple, programmatic D3 charts from Perl without deep front-end work.

JSON::Validator::Schema::Troglodyne adds Troglodyne LLC's custom type extensions to the JSON::Validator::Schema::OpenAPIv3 validator so you can declare and validate a couple of useful types in your OpenAPI schemas. It supplies an email type that uses Data::Validate::Email::is_email to check addresses and a callback type that documents a string as the fully qualified name of a Perl subroutine. The module exists because the upstream validator lacks a formal hook for injecting custom formats, so it relies on the validator's dynamic _validate_type_* dispatch mechanism and may break if that internal behavior changes. If you build or consume OpenAPI schemas in Perl and need straightforward email or Perl callback validation, this module provides a lightweight, ready-made option and issues can be reported on the project GitHub.

CGI::Lingua is a Perl utility for adding language and locale awareness to web applications by negotiating the best language and regional variant to present to a user. You provide the list of supported RFC-1766 language tags and the module uses Accept-Language, optional user-agent cues, and IP-based geolocation backends to return human-friendly language names, two-letter language and country codes, sublanguage names, text direction, CLDR-style plural categories, a best-match translation file path, and best-guess locale and timezone information. It integrates with CHI for caching and accepts logger and CGI::Info-like objects so you can plug it into existing apps. The author notes some important caveats such as embedded plural rules that truncate fractional values and do not replace Locale::CLDR, country lookups that fall back to slow WHOIS queries unless a local geo module is installed and caching is enabled, is_rtl covering only primary-script RTL languages, and the logger parameter must be a blessed object with warn/info/error methods. If you need a practical, configurable way to detect and adapt to visitors language and regional preferences in CGI apps, CGI::Lingua is a solid choice.

File::ContentStore is a small utility for deduplicating files by content using hard links, storing one copy of each unique file under a name derived from its content digest and hard-linking duplicates to that copy. It can link individual files or recursively process directories, lets you pick the digest algorithm and verify for hash collisions, and can make stored files read-only so accidental edits do not alter all aliases. The module provides maintenance helpers such as fsck to find orphaned or corrupted entries and now includes stats() and stats_summary() to quantify how many files are linked and how much space the store saves. It will skip files on a different filesystem rather than failing, and you should be aware that hard-linked files share the same inode so changes or permission updates affect all linked copies.

Mojolicious::Plugin::BarefootJS makes it easy to use the BarefootJS server runtime inside a Mojolicious app by registering a "bf" helper that lazily creates a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo. It lets you render BarefootJS-compiled templates as native Mojolicious templates so controllers and views can use BarefootJS features with minimal setup. If you need the same runtime outside Mojolicious, BarefootJS::Backend::Xslate provides a Text::Xslate-driven option. Install the plugin to add the helper and supporting hooks and streamline using BarefootJS templates in your Mojolicious application.

BarefootJS::Backend::Xslate is a small adapter that lets the BarefootJS runtime render Kolon-style Text::Xslate templates, so you can use BarefootJS templates in any PSGI/Plack app or even a standalone script without tying into a web framework. You give it template directories or a ready-made Text::Xslate instance and it provides the runtime-facing operations the engine expects, such as render_named, encode_json, mark_raw and materialize, while building Xslate with HTML auto-escaping and support for helpers that emit raw markup. It is designed to work with the @barefootjs/xslate compile-time adapter which emits ".tx" templates that call the runtime as a bf object, and it lets you override Xslate options or the JSON encoder if you need custom behavior. The module is actively maintained and available under the MIT License.

BarefootJS is a lightweight server-side runtime for marked templates generated from JSX/TSX that lets compiled templates call back into Perl at render time. It is framework- and template-engine-agnostic, delegating tasks that depend on the rendering environment such as JSON marshalling, raw-string marking, JSX children materialization, and named-template invocation to a pluggable backend so the same runtime can drive different hosts. Shipable backends connect it to common Perl stacks like Text::Xslate for PSGI/Plack or Mojolicious via a plugin, and the core itself only depends on Perl core modules so no template engine or web framework is loaded unless a backend requires one. If you compile your front-end templates to marked templates plus client JS and need a consistent, minimal Perl runtime to render them server-side, BarefootJS provides the bridge you need and is released under the MIT License.

Getopt::Long::Bash provides getoptlong.sh, a lightweight Bash library that brings Getopt::Long style option parsing to shell scripts so you can declare all options in one associative array and let the library do parsing, validation and help text generation. Define long and short names once and you get bundled short options like -vvv, GNU-style flexible ordering, automatic usage output, callbacks, passthrough mode for wrapper scripts, arrays for repeated options and hashes for key=value pairs, plus built-in validations for integers, floats and regexes. It also supports subcommand-style parsing and collecting options to forward to an underlying command, which makes it ideal for wrappers and git-style command structures. Install from CPAN or fetch the script directly, and note it requires Bash 4.4 or later; the recent 1.0.0 release makes that requirement explicit and will report an older Bash version at runtime.

Archive::Libarchive provides modern, object-oriented Perl bindings to the libarchive C library so you can list, read, write and extract archives and compressed streams across a wide range of formats and filters including tar, zip, ISO images, gzip, bzip2 and many more. It exposes high-level classes for reading and writing archives, disk-based read/write helpers, an Entry object for file metadata, and simpler interfaces such as Peek, Extract and Unwrap for common tasks, plus the full set of libarchive constants and version helpers. The module uses your system libarchive when available and works with Alien::Libarchive3 if you need a newer bundled copy, and it will enable optional methods only when the underlying libarchive supports them. If you need to handle custom data sources or fine-grained control over headers and data blocks the API gives access to callbacks and lower-level read and write operations, while the convenience helpers cover most extraction and listing needs. This distribution is actively maintained and the recent 0.10 release added support for libarchive 3.8.9 so it stays current with upstream improvements.

Crypt::OpenSSL3 is a modern Perl wrapper that exposes OpenSSL functionality so Perl programs can perform TLS/SSL connections, asymmetric and symmetric cryptography, message digests, MACs, key derivation, and X.509 certificate handling. The distribution breaks OpenSSL into focused modules such as Crypt::OpenSSL3::SSL for connections, Crypt::OpenSSL3::PKey for public/private keys, Crypt::OpenSSL3::Cipher for symmetric ciphers, Crypt::OpenSSL3::MD and ::MAC for digests and message authentication, Crypt::OpenSSL3::KDF for key derivation, and Crypt::OpenSSL3::X509 for certificates, while the top-level Crypt::OpenSSL3 module provides error handling and build/version introspection. If you need direct, up-to-date access to OpenSSL primitives from Perl for building TLS clients/servers, key management, certificate parsing or low level crypto tasks this module is a good fit, otherwise higher level HTTP or TLS libraries may be easier. Recent releases add PKey encoder/decoder support, SKey and BasicConstraints handling, improved ASN.1 UTF8 decoding and other bug fixes, and the project has been updated to work with newer OpenSSL versions including OpenSSL 4.0.

Cavil::Matcher is the next-generation pattern matcher used by the Cavil project to find licenses and other keyword patterns in source trees. It compiles curated tokenized patterns into immutable, memory-mapped segments so many index workers on a host can share one physical copy and adding or removing a pattern does not force a full rebuild of the cache. The matching core is a frozen C++ tokenizer and hash that is bit-for-bit compatible with the previous engine, while the segment lifecycle and tooling are pure Perl, and the module also provides helpers to parse pattern tokens, normalize text into tokens, compute streaming content hashes, and build a tf-idf “bag of patterns” for closest-match queries. Note that the text tokenizers treat input with C-string semantics and stop at embedded NULs, while file-reading routines tolerate NULs and guard against pathological single-line inputs. Version 1.01 delivers a major practical improvement by no longer re-checksumming a segment payload on every load, which drastically speeds index jobs for large corpora, and it adds on-demand verify methods so you can run a full CRC check when needed. If you are building license scanners or other large-scale code-text matching tools and need fast, incremental, and memory-efficient pattern matching, Cavil::Matcher is directly relevant.

EV::WebKit is a Perl library for driving a real WebKitGTK 6.0 (GTK4) web view from the EV event loop, letting you automate browsing tasks such as navigation, DOM queries and manipulation, JavaScript execution, screenshots and PDF export, cookie and download management, and basic network control. It is asynchronous and single-threaded, so you run EV::run yourself and use trailing callbacks for operations that touch the page while a handful of simple accessors are synchronous. The module is implemented in pure Perl on top of GObject Introspection and EV::Glib, shows a native GTK window or runs headless under xvfb, and optionally compiles a small web-process extension and can pair with an in-process Proxy::Impersonate to offer device fingerprinting that covers both the JS surface and the network TLS/HTTP2 layer. Important constraints are Linux only, a usable X display or xvfb, and a few optional features that require extra toolchain or modules; container sandboxing may need special caps or disabling WebKit sandboxing. The initial 0.01 release provides the core async automation surface including element lookup (CSS, JS, XPath), frame addressing, downloads and uploads, request and response hooks, user scripts and styles, cookie/session persistence, a control protocol for remote driving, and the fingerprint impersonation features described above.

Punk::Observe is a single-node OpenTelemetry backend for receiving, storing, querying and visualising traces, metrics and logs in one place rather than a client library. It accepts OTLP over HTTP (protobuf or JSON), authenticates ingest with hashed keys, appends incoming data to a write‑ahead log and stores each signal in formats tuned to its shape so a single query language can span metrics, traces and logs without manual trace id copying. The distribution includes a PSGI ingest app, a storage engine with immutable segments, compression and rollups, a resumable query executor that refuses overly expensive or unsupported scans with actionable messages, a live tail over server‑sent events, and a C-backed UI that renders waterfalls, flamegraphs and charts (Plotly is vendored) while alert evaluation is intended to be driven by the host scheduler. Important operational choices are explicit: timestamps use 64‑bit nanoseconds and cross-perl string handling, retention deletes whole two‑hour blocks rather than single records, cardinality is capped and excess series are folded into an overflow series, and durability has configurable fsync policies. The module deliberately does not support gRPC ingest, clustering, backend tail sampling, PromQL compatibility, or percentiles over downsampled ranges, and it expects to be mounted into a host Punk application with a required admin guard. This is the initial 0.01 release providing the engine, receiver and plugin for self-hosted observability.

Punk::OpenTelemetry is an OpenTelemetry SDK that plugs into the Punk web framework to give your app distributed traces, metrics and correlated logs delivered over OTLP. Install the plugin or set a few OTEL_ environment variables and every incoming request becomes a well named server span, outbound HTTP calls are tracked as child spans with trace context injected, and database queries are recorded without leaking bound data. The exporter batches work off the request path so a down collector does not block or slow requests and protobuf-over-HTTP is used by default for compact payloads while JSON and gRPC are available when you need them. There is an example app and collector to show the full pipeline locally. Note that the SDK will not send telemetry unless you configure an OTLP endpoint and you can fully disable the SDK with OTEL_SDK_DISABLED=true. Recent updates make outbound calls join existing traces and improve log integration, and the distribution now installs the OTLP proto header and registers as an ExtUtils::Depends provider.

Stats::LikeR is a high-performance Perl toolkit that brings many of R's familiar data-frame operations, statistical tests and modeling tools into Perl, implemented in XS for speed and numerically validated against R and SciPy where possible. It understands four common table shapes (array-of-arrays, array-of-hashes, hash-of-arrays and hash-of-hashes) and gives you fast, memory-conscious primitives for reshaping and joining data (concat/rbind, merge, melt, pivot_table, aoh2hoa, hoa2aoh, aoh2hoh), grouped aggregation (agg, group_by), row filtering and column assignment (filter, assign, map_cell), binning and ranking (qcut, rank, quantile), missing-value handling and interpolation (dropna, fillna, ffill, bfill, interpolate), I/O for delimited files and .xlsx and LaTeX output (read_table, write_table), plus a large suite of statistics from basic summaries to advanced inference and models (mean/median/sd/skew/kurtosis, t_test, wilcox_test, chisq_test, fisher_test, anova/aov, oneway_test, kruskal_test, glm, lm, coxph, survfit, logrank_test), diagnostic and effect-size tools (auc/roc/bedroc, cramers_v, cohen_d, smd, vif, eta_squared), distribution and utility functions (pnorm/qnorm, pt/qt, pchisq/qchisq, pbinom, density, hist, sample, runif/rnorm/rbinom) and helpers for table housekeeping (vals, colnames, rownames, nrow/ncol, view). It includes an interactive help function h() and aims to match R behavior closely while being tuned for performance, so it is a good fit if you want R-like analytics inside Perl scripts or pipelines. Note that some routines follow R conventions exactly so ANOVA here is sequential (type I) and term order matters, aov assumes normality, and predict has limits around automatic factor re-expansion, all of which are documented in the module.

OpenMP::Environment is a small Perl utility for managing OpenMP and GNU libgomp environment variables by reading and modifying %ENV, making it easy to prepare the runtime settings you need before launching OpenMP programs or to coordinate with in-process OpenMP code via OpenMP::Simple. It exposes getter, setter, and unsetter methods for the canonical OMP_* and GOMP_* names recognized by GCC libgomp, validates simple and stable syntaxes while passing through complex grammars unchanged, and offers convenience features like assert_omp_environment and human-readable summaries. The module is particularly handy for benchmark drivers, parameter sweeps, HPC launchers, test harnesses, and any workflow that needs to change thread counts, affinity, allocators, or related settings for child processes or for code loaded into the current Perl process. Version 1.3.0 adds support for OMP_ALLOCATOR, OMP_AFFINITY_FORMAT, OMP_DISPLAY_AFFINITY, and comma-separated OMP_NUM_THREADS for nested levels, and it is deliberately conservative about validation so it stays compatible with libgomp’s more complex option grammars.

CallBackery is a Mojolicious-based framework for building appliance-style web frontends in Perl that wires your application logic into the Mojolicious request cycle and exposes RPC services, GUI plugins and table/form driven UIs with built‑in database and config support. It centralizes runtime state via attributes such as config (default etc/callbackery.cfg, overridable with CALLBACKERY_CONF), a pluggable database handle, securityHeaders for safe responses, RPC service namespace and controller, and a docIndex for online documentation, and it relies on Mojolicious calling its startup method to mount routes and initialize components. If you are building a self-contained admin or appliance web UI in Perl and want a ready integration of config, auth, RPC and frontend widgets this module is directly relevant. Recent releases improved exports and tooling including a new Excel export option that can add generated columns such as QR code images to XLSX output and a fix for an asset loading bug.

Dispatch::Fu is a small, opinionated helper for Perl that separates decision logic from action dispatch by letting you compute a static key from any input and then map that key to a handler like a hash-based dispatch table. You write a classification block that examines the input and returns a case name, then list on case => sub handlers that receive the original input and return whatever your application needs. It is handy when routing or behavior depends on ranges, multiple values, request metadata, or normalization and you want to avoid long if/elsif chains. The module also gives simple helpers for introspection and fallbacks via cases and xdefault, and a convenience xshift_and_deref for unpacking referenced inputs. There is a built-in default handler that warns if you do not supply one, and the API is deliberately tiny with no noncore dependencies, so it is a good fit for small apps, simple CGI routing, or any place where you need a compact, computed dispatch layer without adopting a full routing framework.

SPVM::Sys is a comprehensive system layer for the SPVM language that exposes POSIX style operations for file and directory I/O, sockets, time, processes, signals and user and group management in a familiar, Perl-like API. It wraps common primitives such as open, read, write, stat and dir operations, provides high level helpers like popen, exec and system, mirrors Perl file test operators like -r and -M, and supplies full socket support including socket, bind, listen, accept, send, recv, select and portable setsockopt/getsockopt utilities. The module also includes process control and IPC functions such as fork, wait, pipe, kill, alarm and priority control, time helpers like localtime and gmtime, environment and user database access, and convenience features such as a cross platform set_tcp_keepalive implementation and automatic Windows UTF-16/UTF-8 filename conversion. If you are building system utilities, network servers or scripts that need low level OS interaction from SPVM on Linux, macOS or Windows, SPVM::Sys provides the OS bindings and portability helpers you need.

SPVM::Thread provides a thin, straightforward binding to C++ std::thread that lets SPVM programs run native OS threads from Perl-like code. You create a Thread by calling new with a callback to execute on the new thread, then use join to wait for completion and get_id to retrieve the thread identifier, making it suitable for simple concurrent tasks where native threading is required. The module focuses on a minimal, easy API rather than complex thread management and recent releases added full stack traces for thread exceptions and improved Windows/MSVC support, while requiring a recent SPVM runtime (0.990196 or later).

SPVM::Time::Local is a small utility for SPVM programs that performs the reverse of localtime and gmtime by turning a Sys::Time::Tm object back into Unix epoch seconds. It exposes two class methods, timelocal for local time and timegm for UTC, each returning the epoch as a long and raising an exception if you pass an undefined argument. Use it when you need to convert the structured time object produced by Sys->localtime or Sys->gmtime back into a numeric timestamp. The module is lightweight and focused, and recent releases have improved portability and Windows (MSVC) support while moving to a C99 codebase and requiring newer SPVM runtimes.

SPVM::Time::Piece is a Time::Piece-style date and time class for SPVM that makes it easy to create, inspect, format and manipulate timestamps in either local time or UTC. You can build objects from epoch seconds or from other Time::Piece objects, parse strings with strptime (backed by C++ std::get_time), and read individual components like year, month, day, hour, minute and second as well as weekday, yearday and DST. It offers convenient formatting helpers such as hms, ymd, mdy, datetime (ISO 8601), cdate and full strftime support, plus utilities for timezone offset, Julian and modified Julian dates, ISO week numbers and leap year checks. For date math it supports adding or subtracting seconds, adding months or years, truncating to units like year or day, comparing and cloning instances. The module is practical for developers who want a familiar, lightweight date/time API in SPVM and is available under the MIT license on GitHub.

API::Docker is a pure-Perl client for the Docker Engine HTTP API that gives Perl programs a clean object-oriented way to manage containers, images, networks, volumes and exec/system operations without shelling out to the docker binary. It talks to a daemon over a Unix socket or plain TCP, automatically negotiates the highest API version supported by the server, and works with any engine that implements the Docker API such as Podman. The interface exposes resource-specific classes and convenience methods for common tasks like listing, creating, starting and removing containers, pulling and pushing images, and streaming build or events output. Note that TLS is not implemented and asking for it will croak, so you should terminate TLS outside the client if you need encryption. The recent 0.003 release cleaned up streaming behavior and error reporting so failed builds, pulls and pushes surface as exceptions with preserved event streams, and log/exec output is now demultiplexed into stdout/stderr frames, making programmatic use of progress and logs much more reliable.

App::FfmpegUtils is a small collection of Perl helpers that wrap the ffmpeg command line to make common video and audio chores easier, such as cutting or censoring time ranges, extracting clips, splitting long videos into parts, joining audio files, and re-encoding video with libx264 to reduce size or change resolution. The utilities accept flexible time formats including human, ISO 8601 and percentage-based durations, handle multiple files and automatic output naming, offer a dry-run mode so you can preview commands, and return results in an enveloped array that includes an HTTP-like status, a reason string, payload and optional metadata. Re-encoding defaults aim for good compression with minimal quality loss and audio tracks are copied by default, and there is an option to use stream copy for faster but less precise trimming. Because these are thin wrappers around ffmpeg you need ffmpeg installed, and the module is best suited for users who want a scripted, repeatable way to run common ffmpeg workflows without writing ffmpeg command lines from scratch.

DBD::Pg is the PostgreSQL driver for Perl's DBI that lets Perl programs connect to and talk with PostgreSQL databases using the native libpq client libraries. It provides the usual DBI interface for connecting, preparing and executing statements, transactions and savepoints, and it also exposes many PostgreSQL specific features such as server side prepared statements, multiple placeholder styles, explicit Postgres type handling, UTF8 support, array and large object handling, fast COPY bulk import and export, asynchronous queries and connects, and a rich set of attributes and helper methods for inspecting server and result metadata. The module integrates closely with PostgreSQL connection options including SSL and service files and is suitable for most Perl applications that need robust Postgres access, but users should explicitly set AutoCommit and be aware of prepared statement behavior when using connection poolers such as PgBouncer.

Physics::Electrodeposition models constant-current metal electrodeposition onto a circular wafer, with defaults tuned to an acid copper-sulfate damascene bath but fully configurable for other metals, baths, tools and recipes. It combines Faraday's law with a lumped cell-voltage model that includes thermodynamic, activation, concentration and ohmic terms, models diffusion-limited transport, and provides engineering estimates of wafer uniformity, seed-terminal effects and surface roughness. The module exposes convenient accessors for applied and feature-level current density, deposition rate, process time, film thickness, mass balance, limiting current, cell voltage, power and energy, and it can import GDSII mask openings or accept a prebuilt Pattern object to run through-mask plating studies. The built-in GDSII reader is dependency-free and flattens references to extract opening areas and simple pattern metrics like open fraction, loading, isolated-to-dense height ratio and radial nonuniformity. A formatted report method summarizes numeric results and gives qualitative verdicts on smoothness and fill risk. The author notes that uniformity, roughness and additive-consumption outputs are calibrated engineering estimates for scoping and sensitivity studies rather than a full 3-D current-distribution field solve.

Test2::Tools::HTTP is a testing helper for Perl that makes it easy to exercise websites and PSGI applications from your test scripts without needing a separate server process. You can register PSGI apps under a URL so requests are routed in-memory, let unregistered URLs hit the real network, or use the provided user agent to drive apps directly. It integrates with the Test2 comparison framework and supplies http_request/http_response checks and a transaction object for asserting status codes, headers, content, redirects and common response classes like success or client error. You can set a base URL, add or temporarily override apps with psgi_app_add and psgi_app_guard, choose between long and short import names, and plug in alternative user agents via a wrapper layer instead of being tied to LWP::UserAgent. The most recent release added shortcut helpers for removing apps and creating guards and bumped the minimum Perl requirement to 5.14.

Inline::CLIPS is a lightweight Perl wrapper that makes it easy to run CLIPS rule programs from Perl by writing a temporary .clp file and invoking an external CLIPS interpreter, then returning stdout, stderr, and the exit status as a simple hashref. It provides a small API with new to locate the CLIPS binary or library, run_program to execute inline CLIPS text plus commands, and run_file to run existing .clp files, and it discovers the CLIPS executable from a constructor argument, the INLINE_CLIPS_EXECUTABLE environment variable, your PATH, or via Alien::CLIPS. The module does not embed a CLIPS engine so you must have a working CLIPS executable or install Alien::CLIPS to provide one. Inline::CLIPS is ideal when you want to automate or integrate CLIPS-based rule checks and projects from Perl without writing a lot of glue code.

MIME::Body is an abstract helper class used by the MIME::Tools toolkit to represent the content of a MIME message part without forcing you to know how that content is stored. It defines a small, consistent API for opening a body for reading or writing, streaming or slurping its data, getting or setting an external path, duplicating the handle, and purging any on-disk storage, while concrete subclasses provide implementations that store data in files, scalars, or arrays. Use this module when you need to handle attachments or message parts of varying size and lifetime and want your code to work the same whether the data lives in memory or on disk. The toolkit is mature and actively maintained and recent releases include improvements to header parameter and boundary parsing that make handling encoded or oddly-formed MIME parameters more robust.