CPANscan

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.

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.

Test2::Harness is the workhorse behind running and processing Perl test suites, providing a Test2-aware harness that handles parallel scheduling, resource and slot management, TAP parsing, persistent runners, and plugin integration while leaving user-facing commands to App::Yath. You normally interact with it via App::Yath, but Test2::Harness supplies features like coverage hooks, conflict and churn directives for ordering tests, replay and rerun support, and extensible plugins for notifications and profiling. Recent releases improved robustness and diagnostics by avoiding full aborts when plugins clash, adding a HARNESS-SHARES directive for shared resource slots, adding an optional --stall-report to gather debugging traces for stalled runs, and hardening TAP parsing so non-TAP output does not corrupt subtest handling. The project is actively maintained and suitable if you need a battle-tested, flexible backend to run complex or concurrent Perl test suites.

Proxy::Impersonate is a small EV-driven local forward proxy that terminates TLS on localhost and re-originates each request through Curl::Impersonate so the origin sees a chosen browser's TLS and HTTP/2 fingerprint rather than the client's. It is designed to sit in front of clients such as EV::WebKit that cannot themselves present real browser connection fingerprints, issuing a self-signed certificate for the localhost hop while still verifying the real origin upstream. The module exposes hooks to inspect, rewrite, mock or block requests and to observe or tweak response headers, and it persists its CA key to a configurable cert directory. It intentionally focuses on reproducing connection fingerprints and basic HTTP behavior, so HTTP/3, WebSockets and streaming uploads are out of scope, request bodies are buffered whole, some added headers may not match a browser's exact header ordering, and a few strict request forms such as chunked uploads are rejected. This is the initial release and provides the core impersonation plumbing, CA handling and per-request interception needed to make a WebKit-based client appear to servers as a specific browser.

Curl::Impersonate is a Perl client that wraps a patched libcurl to make HTTP requests that mimic a real browser's TLS (JA3/JA4) and HTTP/2 fingerprint, so servers see the connection shape of a chosen browser profile like chrome131. It offers simple synchronous methods for GET and general requests and a curl_multi-backed asynchronous API that supports concurrent requests, streaming response chunks with backpressure, and integration with external event loops. This is not a browser replacement so it does not run JavaScript and it currently does not support HTTP/3 or WebSockets. You can opt to apply a profile's default request headers, follow redirects, verify TLS certificates by default, and route through proxies with the caveat that only CONNECT-style tunneling preserves the impersonated fingerprint. The module depends on Alien::curlimpersonate and therefore requires a local C/C++ toolchain, cmake, ninja, go and patch to build the bundled libcurl at install time. Responses are returned as structured hashes or error objects and the API exposes a list of available impersonation targets so you can pick which browser fingerprint to present.

Alien::curlimpersonate is an Alien::Base module that builds the curl-impersonate patched libcurl (with bundled BoringSSL) from source and exposes the compiler and linker flags so a Perl XS extension can link against a libcurl that mimics a real browser's TLS and HTTP/2 fingerprint (JA3/JA4 and the Akamai SETTINGS profile). It is source-only and always compiles the pinned upstream release (v1.5.6) at install time rather than locating a system package, so expect a nontrivial build that requires git, a C/C++ toolchain, cmake and ninja, Go and patch and which can take several minutes. The module provides cflags, libs and dynamic_libs but deliberately emits no rpath, so consumers should add an appropriate -Wl,-rpath based on dynamic_libs when linking. The upstream version is intentionally pinned for reproducible impersonation results, which means upgrades require a new release of this distribution.

Alien::TDLib is an installer and discovery helper for TDLib, the Telegram client library, that locates a usable libtdjson on your system or installs TDLib into the Alien share area and then reports the compiler and linker flags XS consumers need. It probes the system with pkg-config or a compile/link test and accepts system libraries only if they report version 1.8.66 or newer, otherwise it will build TDLib from source by default or fetch a vetted prebuilt shared package when ALIEN_TDLIB_PREBUILT is set. Installs are anchored to a commit or release and verified against published digests so builds are reproducible and auditable, and ALIEN_TDLIB_VERSION lets you pin a specific release or commit. A source build requires CMake 3.10+, a C++17 compiler, gperf, and OpenSSL and zlib development headers and can be memory intensive so parallelism is throttled automatically. XS module authors use Alien::TDLib->cflags and Alien::TDLib->libs to populate INC and LIBS in Makefile.PL. Note that using prebuilt packages trades convenience for third party binaries and a statically linked OpenSSL that will not pick up system updates. This distribution is a new initial release.

AmberDB is a compact, high-performance flat-file database engine for Perl that uses DB_File to provide structured record storage, automatic primary keys, on-disk indexes and an ACID-like undo-journal transaction system. It exposes a simple CRUD API plus list, field, filtered and full-text search operations with packed 8-byte binary indexing for very fast ID handling, multi-dimensional facet indexing, tiered Active/Archived query modes, and record- or table-level locking for concurrent access. The module includes language-aware normalization for search (including Turkish-specific rules), runtime schema attribute overrides, and low-level table access for bulk read/write cases, but note that bulk batch operations bypass the transaction journal so single-record methods must be used when rollback safety is required. The recent 5.02 release is the initial public CPAN/GitHub release and highlights include the packed binary indexing pipeline, index-assisted full-text search with phonetic and locale normalization, facet bitset indexing, and a multi-granularity concurrency and transaction engine, making AmberDB a good fit when you want a fast, file-backed store without running a full RDBMS.

Util::H2O::More is a compact convenience layer on top of Util::H2O that turns ordinary Perl hashrefs and JSON-like nested data into lightweight objects with generated accessors, making code that works with configuration files, HTTP/JSON responses and command-line options much cleaner and easier to read. It supplies small, practical helpers for constructors, deep objectification and de-objectification of nested HASH/ARRAY structures, INI and YAML loading and saving, HTTP::Tiny response handling with optional JSON decoding, and helpers to bind Getopt::Long option specs to object accessors, plus simple Data::Dumper-based debugging helpers and array container virtual methods like all, get, push and pop. The design preserves the underlying HASH and ARRAY refs so existing data semantics remain familiar while removing a lot of dereferencing clutter. The most notable recent change is an opt-in -lvalue mode that makes generated accessors writable as true lvalue methods so you can write code like $obj->count = 42 or $obj->name .= " Jr." while retaining the original setter-call form and backward compatibility when -lvalue is not used. If you want a lightweight, backward-compatible way to tidy up code that manipulates nested Perl data, config files, CLI options or HTTP/JSON payloads, this module is worth a look.

PAGI is a modern specification for writing asynchronous web applications in Perl that extends the familiar PSGI idea to support long‑lived connections like WebSocket and Server‑Sent Events, making it a better fit for real time and streaming use cases. Instead of a single synchronous request/response function, a PAGI app is an async coderef that receives a scope describing the connection and two async callbacks, receive and send, that exchange messages via Futures so you can handle many incoming and outgoing events per connection. The PAGI distribution provides the stable specification and documentation, while a reference server and an application toolkit live in separate distributions, PAGI::Server and PAGI::Tools, which are currently beta, and there are migration guides and examples to help you bring existing PSGI code to PAGI. If you need to build or run async Perl web services, PAGI gives you a simple, standardized interface and an evolving ecosystem of frameworks and helpers to get started.