CPANscan

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.

SPVM::MIME::Base64 provides Base64 encoding and decoding for SPVM programs. You call class methods to encode or decode strings, with encode_base64 accepting an optional end-of-line string that defaults to "\n" and causes output to be wrapped at 76 characters, or you can pass an empty string to disable wrapping. The module also offers efficient helpers to compute the encoded or decoded length without performing the conversion. Methods throw an exception if given an undefined argument, and decode_base64 silently ignores characters outside the Base64 alphabet and stops decoding at padding characters. This MIT licensed SPVM port of MIME::Base64 is a simple, reliable way to convert binary data to text for storage or transport.

SPVM::Math is a thin wrapper that brings the standard C math.h and complex.h routines into SPVM, giving you C-style trigonometric, exponential, logarithmic, rounding, classification and other numeric functions along with full complex-number support and common constants like PI and E. The module exposes both double and float variants of most functions plus complex constructors and operations such as cexp, csin, cadd, cmul and cabs, and it also surfaces C macros like INFINITY, NAN and the floating-point rounding mode constants. It is useful when you need direct, predictable C numeric behavior or complex arithmetic from SPVM code. Be aware that a few functions use output parameters passed by reference, for example frexp, modf and remquo, and will throw an exception if those reference arguments are not provided.

SPVM::File::Glob is a lightweight SPVM module that provides BSD-style filename globbing for SPVM programs, offering a simple class method bsd_glob that returns matching pathnames for a given pattern, for example File::Glob->bsd_glob("path/*"). It delegates to Sys::IO::Glob and the author recommends using Sys#glob when available since it provides the same functionality. A notable recent change renamed the method from glob to bsd_glob and removed the native class implementation, and the module now requires newer SPVM and SPVM::Sys releases. The project is available on GitHub and is distributed under the MIT License.

Database::BI is a Mojolicious web application that lets you explore plain flat data files as styled, sortable, reorderable HTML tables so you can inspect CSV, PSV, XML and SQLite data in a browser without building a custom pipeline. It scans a configurable data directory to present file cards, offers a filesystem browser and drag-and-drop uploads, and saves column order and sort state in localStorage for a smoother interactive experience. You can perform repeatable left joins across files, apply server-side filters, inspect column metadata via JSON APIs, import HTML tables from public URLs, and export the current logical view as RFC 4180 CSV or a single-table SQLite file either as a download or written to disk. Be aware that the app is read-only, the join engine is an in-memory O(n*m) hash join so very large files may not fit comfortably in RAM, and the underlying file-extension support is limited to csv psv sql and xml which must match filenames exactly. This is the initial CPAN release and is provided under the GPL2 license.

Music::SimpleDrumMachine is a lightweight Perl MIDI drummer that plays real‑time 16th‑note drum phrases to a MIDI output device. You construct it with a target port and optionally supply named parts and fills as code references that return simple 16‑step patterns, while configuration options let you set tempo, beats per phrase, MIDI channel or multi‑timbral mode, velocity ranges, and the known percussion mapping. It ships with a full General MIDI percussion set and several example scripts so you can list devices, add drums, and try grooves quickly. Triplets are not supported. Recent updates added a shared pattern file for grooves and a test suite to improve reliability.

Music::Drummer is a lightweight, user-friendly alias for MIDI::Drummer::Tiny that makes MIDI drum utilities easier to find and use in Perl projects. It does not add new features or change the API; you use it the same way as the underlying module to create drum patterns and drive MIDI output. The distribution is maintained to stay in sync with MIDI::Drummer::Tiny and to keep prerequisites current, so choose this package if you want a clearer, searchable name and drum-focused keywords when looking for Perl MIDI drum tools.

MIDI::Drummer::Tiny is a lightweight Perl toolkit for programmatically constructing drum parts and metronomes as MIDI files. It supplies ready-made percussion mappings and duration constants plus simple methods to add notes, rests, accents, flams, rolls, crescendo rolls, fills and metronomes in many time signatures, and it can play beat-strings or generated patterns (including Euclidean-style grooves), sync multiple voices, control tempo, swing and volume, and output a MIDI file or use a soundfont for playback. The API is built for scripting and composition rather than live performance, making it useful for composers, producers, educators and anyone who wants to generate or test drum MIDI programmatically. Recent updates added a Grooves module and made the shared groove-patterns file configurable so you can manage or swap groove libraries more easily.

Punk::ClamAV is a small plugin for the Punk web framework that scans user uploads with a running ClamAV daemon before you accept or store them. You enable it with a plugin call and point it at your clamd socket, and it provides a helper such as upload_ok that you call on an upload handle to verify the file is clean. It uses the ClamAV::Clamd client underneath, so it can take advantage of the client library features including nonblocking operation, and is a straightforward way to add virus scanning to avatar uploads and other file handlers in Punk apps. A running clamd is required and the module is free software under the Artistic License 2.0.

ClamAV::Clamd is a lightweight Perl client for talking to a clamd antivirus daemon so your app can ask a local scanner to check uploads without linking libclamav or carrying the signature database. It supports scanning raw bytes, file paths, or open file descriptors and can hand a descriptor to clamd so the scanner reads a file without needing filesystem permission to the path. The module provides both blocking convenience methods and a small non‑blocking state machine you can drive from an event loop, and every scan returns a Verdict object with four distinct outcomes: clean, infected, unscannable, or error, which helps you avoid treating failures as safe. It prefers UNIX domain sockets for descriptor passing, exposes useful controls for timeouts and size limits, reports structured error codes when things fail, and can tell you whether fd‑passing actually works on the platform. Recent fixes make live test runs opt‑in to avoid talking to someone else’s daemon and ensure commands disabled in clamd (version, stats, reload) return a proper ERR_UNAVAILABLE response rather than being misinterpreted as data.

Punk::Mailer is a small Perl library that builds RFC 5322‑compliant outbound email messages and hands them to configurable transports for delivery. You give it a plain hashref with the usual fields such as from, to, subject, text, html and attachments and it produces 7‑bit clean MIME bytes with the right multipart structure and content encodings, streaming file attachments in chunks so large files do not consume memory. It enforces safety and correctness up front by rejecting header values containing CR, LF or NUL, validating addresses, encoding non‑ASCII display names and subjects per RFC 2047, and generating required headers itself. You can configure transports (smtp, sendmail, resend, capture, log or a custom class) when creating the mailer so transport options are checked early, use send to hand a validated message to the transport and inspect a Punk::Mailer::Result for delivery status, or call build/build_to to get the raw bytes or stream them elsewhere. This is the initial 0.01 release.

Physics::Lithography is a Perl toolkit for modelling Laser Direct Imprint Lithography and related laser‑material interactions, offering compact, physics-based building blocks to characterise laser pulses and beams, run 2D heat‑transfer simulations, estimate ablation and phase‑change behavior, predict pattern-transfer limits, and evaluate Laser-Induced Forward Transfer. It presents a factory-style API that returns focused solver objects for laser, thermal, ablation, phase change, pattern and LIFT analyses so you can compute derived values such as peak intensity, temperature fields, ablation depth, melt-pool geometry and transfer thresholds, and it can generate input files for OpenFOAM or LAMMPS when you need higher-fidelity CFD or MD. The library uses SI base units, includes example scripts to get you started, and is aimed at researchers and process engineers who want fast, interpretable estimates and simple workflows for lithography experiments and process design. OpenFOAM and LAMMPS are optional and only required if you use the interface modules.

Physics::CVD is a Perl framework for simulating chemical vapor deposition processes. It lets you specify reactor conditions such as temperature and pressure, define gas-phase chemistry and reaction networks, and run kinetic Monte Carlo lattice simulations of surface growth by adding species and performing depositions. The API makes it straightforward to set up experiments, explore reaction mechanisms, and prototype deposition models in Perl, so researchers, engineers, and students can model thin film growth and test process parameters without leaving the Perl ecosystem. The module is best suited to users comfortable programming in Perl who want an extensible simulation toolkit rather than a black box commercial simulator.