CPANscan

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.

OpenTelemetry is the Perl implementation of the OpenTelemetry standard and serves as the lightweight API entry point for instrumenting applications, managing global tracer, logger and propagator components, and handling errors. It exposes global providers you can read or replace, and offers both object methods and optional otel_ prefixed functions for working with contexts and spans, reading configuration, and propagating trace state. Out of the box the providers are no-op or nonrecording so you can safely add the module without sending telemetry until you attach an SDK such as OpenTelemetry::SDK to collect and export data. This module is a good fit if you want standardized tracing and context propagation in your Perl app while keeping backend choice separate, and it includes a configurable global error handler and convenience helpers for common tracing tasks.

IO::ReStoreFH is a lightweight helper for safely redirecting and later restoring Perl filehandles and low-level file descriptors. You give it Perl handles or integer descriptors or call store as you go, and it duplicates their current state so they can be restored either explicitly with restore or automatically when the IO::ReStoreFH object goes out of scope. It uses Perl open-based duplication for Perl filehandles and POSIX dup/dup2 for raw descriptors, so it works for STDOUT, STDERR and custom handles and avoids the silent errors that come from forgetting to undo temporary redirections. This is handy for testing, temporary logging or output capture in scripts and modules. Recent updates fixed a bug that could generate an illegal open mode when duplicating filehandles and corrected repository metadata.

Physics::Etch is a compact Perl toolkit for modeling basic semiconductor etch processes that wraps two simple models for isotropic wet etch and anisotropic plasma or RIE dry etch. You call factory methods like wet_etch and dry_etch to build a process object from the included recipe and material database, then tweak parameters such as thickness, temperature, feature size, mask thickness, power or bias to explore effects and produce a human readable report. It is aimed at education, quick prototyping and conceptual process studies rather than production-grade simulation, and it makes it easy to inspect the bundled recipes and materials or supply your own values. The module ships illustrative rate and activation energy numbers so you should always calibrate results against your own tools and chemistries.

Math::Float128 gives Perl access to C's quadmath __float128 type so you can create objects that hold 128-bit floating point values and do high precision arithmetic from Perl. It provides constructors and converters from Perl integers, floats and strings, overloads common arithmetic and comparison operators, and wraps a wide range of quadmath library functions such as trig, exp, log and special functions. You can stringify values with configurable decimal precision, inspect or clear flags for non-numeric inputs and mixed numeric/string cases, and test for NaN, infinity and signed zero. Converting back to a Perl NV can lose precision and behavior can depend on your Perl build so values created from numeric scalars are not always identical to those created from their string forms. The module also includes workarounds for known bugs in older mingw-w64 compilers. Use Math::Float128 when you need greater floating point precision than Perl's native numeric type for scientific, financial or other numerical computing.

EV::Telegram::TDLib is a Perl binding that gives you an asynchronous Telegram client by wrapping TDLib's tdjson C API and integrating it with the EV event loop. It runs a reader thread and decodes TDLib JSON into events while driving the authorization state machine and keeping user and chat caches up to date, so your code sees clean decoded updates and can call nonblocking methods like send and execute with callbacks that receive ($result, $err). The module supplies convenience wrappers for common tasks such as sending and editing messages, uploading and downloading files, polls, reactions, chat membership and profile management, and bot features like inline queries, callback queries, custom keyboards and command setup, while still letting you call any raw TDLib method through the escape hatch. It requires a 64 bit Perl and ships with a pinned TDLib via Alien::TDLib, is tied to the default EV loop and is not fork safe, so you must close clients explicitly and protect the local session database and encryption key. The binding deliberately does not retry on rate limit errors and leaves backoff policy to callers. If you need a full asynchronous, event-driven Telegram client that works directly with TDLib and exposes both high-level helpers and raw API access, this module is a strong fit, with the caveats that it does not implement the HTTP Bot API, voice or video calls and is mainly tested on Linux.

Test::Future::IO is a lightweight test helper for Perl code that uses Future::IO, letting you unit test asynchronous socket and filehandle operations by declaring expected IO calls up front and controlling how those mocked calls complete. You get a controller object that records expectations for methods like sysread, syswrite, accept, connect and sleep and then lets you decide whether each expected call succeeds, fails, remains pending or even injects data into a read buffer for less brittle event-driven tests. Expectations return objects with methods such as will_done, will_fail, will_write_sysread_buffer and will_write_sysread_buffer_later so you can simulate returns or side effects, and check_and_clear asserts that all expected calls occurred and resets the controller. The module integrates with the usual Perl test tools and is especially useful when you need deterministic tests for code that works with futures and nonblocking IO. Recent updates added expectations for send, recv and recvfrom and refreshed the codebase to modern Perl style.

Net::Clacks is a fast client/server system for interprocess messaging that also provides an in-memory cache intended as a memcached replacement. It scales by running servers in master/slave trees (interclacks mode) so you can handle large numbers of clients, and it supports both near-real-time message delivery and cache-style storage via a memcached-compatible client interface (Net::Clacks::ClacksCache). The distribution includes a server implementation, a client library, a write-only PostgreSQL helper for emitting messages from triggers, and example code and a DEBUG mode that can mirror traffic to a monitoring client. It requires Perl 5.36 or newer and recent development has focused on stability and more reliable handling of client disconnects, so consult Net::Clacks::UpgradeGuide before upgrading.

Devel::Hide is a small testing utility that makes specified Perl modules appear absent so require and use will fail, letting you exercise fallback code paths or force an alternative dependency. You can list modules to hide when loading the module with use or via the DEVEL_HIDE_PM environment variable, and it can be invoked on the command line with perl -MDevel::Hide=... or injected into child processes with -from:children. On modern Perls it also supports lexical hiding so the effect can be limited to a scope, and it prints clear "Can't locate ... (hidden)" errors when a hidden module is requested. Be aware that hiding only affects subsequent loads so modules already loaded will not be affected and adding directories to @INC after Devel::Hide is loaded can let a hidden module be found; also global hiding may be phased out and the -from:children and -lexically options do not interact well. Overall it is a simple and practical tool for testing how your code behaves when particular modules are not available.

DBD::Mock is a DBI-compatible mock database driver for unit testing that records prepared SQL, bound parameters and execution history so you can verify what your code tried to do without touching a real database. You can seed fake result sets, associate them with specific SQL or regex patterns, supply dynamic callbacks, simulate connection or statement failures, and track last_insert_id behavior and per-statement execution history. It also provides higher-level helpers such as session-driven scenarios and an optional Pool mode to emulate Apache::DBI pooling. Use it when you want fast, deterministic tests that assert SQL generation and binding rather than exercising an actual DBMS. Recent releases require Perl v5.12 and add support for passing arrayref bound parameters for PostgreSQL, along with several enhancements to result-set callbacks and attribute handling.

SPVM::Unicode is a small utility library for SPVM that provides low-level Unicode support such as iterating over UTF-8 strings and extracting code points, validating Unicode scalar values, converting a single code point to a UTF-8 character, and converting entire strings between UTF-8, UTF-16 and UTF-32. Its uchar method parses a UTF-8 string by reference to an offset and advances that offset so you can walk a string, and the API uses simple return codes to signal conditions: uchar returns -1 when the offset is beyond the string and a constant ERROR_INVALID_UTF8 (-2) for malformed sequences while uchar_to_utf8 returns undef for invalid code points. The module is focused on encoding and validation tasks rather than high-level text processing so it is handy when you need reliable, low-level Unicode handling inside SPVM. Recent releases switched to using raw utf8proc, added support for MSVC, and require newer SPVM and SPVM::Resource::Utf8proc versions; note that uchar now throws an exception if the offset reference is not provided.

SPVM::Unicode::Normalize is a compact SPVM port of Perl's Unicode::Normalize that normalizes UTF-8 strings using the utf8proc library. It offers the standard NFC, NFD, NFKC and NFKD methods so you can perform canonical or compatibility decomposition and composition for reliable comparisons, searching, indexing and storage of Unicode text. The methods call the native utf8proc implementation and will throw an exception if you pass an undefined string or if the underlying utf8proc_map call fails. This module is ideal when you need fast, standards-compliant normalization in SPVM programs and recent releases added MSVC build support and updated SPVM and utf8proc resource requirements.

SNMP::Info is an object oriented Perl library that gives a unified, vendor-agnostic way to query and manage network devices via SNMP. It wraps the Net-SNMP Perl API and exposes common methods for device metadata, interface tables, traffic counters, IP routing and link-layer topology protocols such as LLDP and CDP, while handling vendor and MIB differences through a large set of device and MIB subclasses. The module caches results, supports bulk table fetches, SNMP v1 v2 and v3 authentication, and can perform SNMP set operations when given writable credentials. You must have the Net-SNMP Perl module installed from the net-snmp distribution and the appropriate MIB files available for full functionality, do not install the SNMP module from CPAN, and certain older Net-SNMP versions are not supported. SNMP::Info is extensible by adding small subclasses that map MIB leaves to methods, making it a practical choice for network inventory, monitoring and automation across many vendors.

Algorithm::AhoCorasick is a compact Perl implementation of the classic Aho‑Corasick algorithm for fast multi-keyword search, letting you locate any of a set of fixed strings inside a larger text much more efficiently than running separate searches for each keyword. It offers two simple functions, find_all to return all matches (with their positions and matching keywords) and find_first to check for or return the first match, and it also provides a SearchMachine class for more flexible or streaming searches. The module builds a single state machine from your keyword list and then scans the input in one pass, which makes it well suited to large inputs or many keywords. Recent updates addressed a memory leak by using weak references and now sort matches to produce deterministic results.

SPVM::Regex provides fast, safe regular expression support built on Google RE2 for pattern matching, replacements and splitting of strings, with a simple object interface for compiling patterns and reusing them. You create a Regex with new, run match to get a Regex::Match object with captured groups and offset updates, use replace or replace_g to perform single or global substitutions with either replacement strings or callback methods that receive the match, and use split to break strings on a regex separator while including captured separators. The API supports mutable string buffers and offset/length parameters so you can operate on slices without copying, handles UTF-8, and offers a Re helper class if you prefer more Perl-like match and substitution functions. Recent releases improved Windows/MSVC build support and updated SPVM and RE2 requirements to keep the module current and reliable.