CPANscan

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.

Perl::Tidy is the programmable interface to the perltidy formatter that parses and cleans up Perl source so it is consistent and easier to read. You call Perl::Tidy::perltidy from your code and supply files, string or array references, or objects for input, output and error streams, or let it use the usual command line arguments and a .perltidyrc file. It can return parsed configuration into hashes, accept an argv string, run prefilter and postfilter callbacks, or hand you tokenized lines through a formatter object for custom analysis or transformation. The function returns a simple exit flag to indicate success, parameter errors, or warning conditions and it sends diagnostics to configurable stderr, errorfile and logfile streams. It also includes controls for handling UTF‑8 output strings so you can choose whether Perl::Tidy encodes or leaves decoded strings alone. Recent updates in the 2026 series fixed heredoc extra spacing and added additional checks to help catch missing semicolons. The module is actively maintained and documented as Perl::Tidy version 20260826 with sources on GitHub.

Net::IDN::PP is a small, pure-Perl utility for converting internationalized domain names between their Unicode form and ASCII Punycode labels (the "xn--" names) so you can encode a Unicode hostname into an A-label or decode an A-label back to readable characters. Because it is written entirely in Perl it does not require external C libraries, which makes it easy to install on systems where libidn or ICU are not available. It implements the Punycode algorithm from RFC 3492 only, so it does not perform Nameprep or the full IDNA2008 processing required for registry or registrar provisioning. If you need strict IDNA2008 compliance use a library such as Net::LibIDN2, otherwise Net::IDN::PP is a convenient lightweight choice for simple encode/decode tasks.

Crypt::Image is a Perl module for basic steganography that hides short text messages inside a PNG image using a separate key image. You construct it with a key PNG, call encrypt to produce a new PNG with the message scattered across pixels and padded with randomized noise so repeated encryptions look different, and call decrypt with the same key image to recover the text. The module encodes UTF character codes across the R, G and B channels and adjusts pixel values to blend data into the image, so it is best suited for short secret messages rather than large payloads. It currently supports only PNG files and the maximum message length depends on the image dimensions.

Math::Histo::PDL connects the Perl Data Language (PDL) to the Math::Histo histogram libraries so you can build, fill and export high-performance 1D and 2D histograms directly from PDL piddles. It offers zero-copy ingestion for double-precision, contiguous piddles by passing their underlying C buffers into Math::Histo's C core for maximum throughput, and it transparently coerces or materializes non-double or non-contiguous views when needed. You get convenient functional builders like hist1d and hist2d, support for weighted fills and coordinate matrices, and methods attached to Math::Histo objects that export counts, edges, centers and errors back to PDL matrices or vectors. The module is ideal when you need fast, memory-efficient histogramming of large numeric arrays, just be sure to use double, physical piddles for peak performance since sliced or other non-contiguous views will be copied under the hood.

Math::Histo is a high-performance Perl XS wrapper around the libhisto C library that gives you fast, memory-safe 1D and 2D histogramming, streaming quantile sketches (DDSketch), online Welford moments, and non-linear curve fitting via Levenberg-Marquardt. It supports uniform and variable-width bins, weighted fills with optional sum-of-weights-squared bookkeeping, and very fast batch ingestion from Perl arrays or zero-copy packed 64-bit float buffers to exploit SIMD acceleration. The module exposes a rich set of statistical tools and convenience features including mean, variance, median and quantiles, mode and peak properties, skewness and kurtosis, rebinning and arithmetic operators, two-sample distances and hypothesis tests, and model fitting, plus compact binary and JSON serialization for storage or transport. If you need production-grade histogramming or summary statistics in Perl with C-level throughput and interoperability with native numeric buffers, Math::Histo is a solid choice.

SPVM::Errno exposes the native C errno values and messages to SPVM programs so you can read and set the process errno, map numeric error codes to human messages with strerror, and fetch numeric constants for over a hundred POSIX and Windows (Winsock) error codes. Each error name is provided as a static accessor that returns the platform’s native integer, and if a particular constant is not defined on the host the accessor raises an Error::NotSupported exception. The module is useful whenever your code interfaces with native C or OS calls and needs reliable, platform-correct error codes. Recent releases improved portability and robustness by adding MSVC/Windows support and a strict cross‑platform test suite that validates all Errno and WSA constants against native OS values, and the module now requires a recent SPVM runtime.

SPVM::Compress::Raw::Zlib is a low level SPVM binding to the zlib compression library that gives SPVM programs direct access to zlib functionality. It exposes Deflate and Inflate classes plus compression constants, and includes convenient gzip and gunzip methods that compress or decompress buffers while automatically handling options like window bits and output appending. Choose this module when you need efficient, low overhead control over compression streams or want to integrate standard zlib compression into SPVM code. The project is on GitHub and is distributed under the MIT license.

SPVM::Digest::SHA is a lightweight SPVM port of Perl's Digest::SHA that gives you standard SHA hashing and HMACs for use in SPVM programs. It exposes convenient functional calls like sha1/sha256/sha512 and their _hex and _base64 variants, plus an object API for incremental hashing with new, add, digest, hexdigest, b64digest and clone. The module covers SHA-1, SHA-224, SHA-256, SHA-384, SHA-512 and the SHA-512/224 and /256 variants and provides HMAC versions of each, so it is useful for integrity checks, signatures and authentication in SPVM code. Recent releases improved portability and native-type usage, added MSVC support, and bumped the required SPVM version to ensure modern toolchain compatibility.

SPVM::Digest::MD5 is a straightforward SPVM port of Perl's Digest::MD5 that lets you compute MD5 message digests either with simple class methods or via an object-oriented interface. You can call md5 to get the raw 16-byte binary digest or md5_hex to get a 32-character lowercase hexadecimal string, or create a Digest::MD5 object with new, feed data with add, and retrieve the result with digest or hexdigest. The methods expect defined input and will raise exceptions on invalid arguments, and note that older convenience methods that returned base64 (md5_base64 / b64digest) were removed so use a base64 encoder if you need that form. Recent updates modernize build/config handling, raise the minimum SPVM requirement, and add MSVC support.

Punk is a batteries-included MVC web framework for Perl that provides a compact DSL to declare routes, controllers, static mounts, websockets, server-sent events and OpenAPI-mounted APIs, together with built-in support for sessions, CSRF, CORS, headers, caching, auth, named routes and testing. The application is compiled and frozen at to_app time so routing, guard chains and handlers run very cheaply and many configuration errors are caught at boot, and the supplied CLI can scaffold a working app, mount OpenAPI specs, run a dev server and exercise the app with an in-process test client. It also offers async-friendly primitives so handlers can return futures without pinning workers on compatible servers, a simple key/value cache with compute-if-miss, a cross-worker publish/subscribe bus for ephemeral notifications, and a C ABI for low-level observers. Punk intentionally delegates compression and some transport details to the PSGI server and validates options aggressively at boot to fail early. Be aware that the pub/sub bus is at-most-once and not durable, max_body enforces a request-length policy rather than providing memory isolation, and static file stat caching uses a short TTL that can delay noticing rapid edits. If you need an opinionated, production-ready Perl framework that favors fast, predictable dispatch and rich built-in features for web apps and APIs, Punk is a strong candidate.

Hyperman is a production-focused PSGI web server for Perl that combines a prefork supervisor with a per-worker XS event loop to serve synchronous and asynchronous apps with low overhead. Handlers can return Hyperman::Future objects so you can await timers or IO without blocking the worker, and the server exposes timers, readiness watchers, and a C ABI so other XS modules can integrate directly. It includes built-in features you expect from a modern server: fast C-side access logging, optional gzip compression with tunable level and thresholds, TLS with SNI and client certs plus kernel TLS when available, HTTP/2 support, multiple listeners and redirect helpers, and a safe spill-to-temp-file strategy for large request bodies. For pool-wide coordination it provides a shared memory pub/sub message bus and a fork-shared denylist and fixed-window rate limiter so limits and blocks are consistent across workers. The implementation is intentionally XS-heavy for performance and exposes hooks for per-worker startup and in-place TLS reloads. If you need a high-throughput PSGI server with async-friendly primitives, per-worker isolation, and low-latency inter-worker messaging, Hyperman is highly relevant; note that some backends such as io_uring have platform tradeoffs and compression costs CPU so they are opt-in or conservative by default.

SPVM is a statically typed programming language that uses a Perl-like syntax and is aimed at developers who want high performance with easy interop to C, C++ and Perl. You can run quick one‑liners or full scripts with the spvm tool, compile programs ahead‑of‑time or to executables with spvmcc, and call SPVM methods directly from Perl via exchange APIs, so existing CPAN modules and Perl code can be reused. The system also supports native and precompiled classes, threads and lightweight goroutine‑style concurrency, static analysis and type inference, and a builder toolchain that helps generate and package native extensions. SPVM is still evolving and has not reached a 1.0 stability promise, so backward compatibility is not guaranteed; a recent noteworthy change is the native config file extension transition from “.config” to “.build” (the old name is being deprecated), so projects that use native classes should plan for that update. If you need a fast, statically typed language with Perl-friendly syntax and tight C/Perl integration, SPVM is worth exploring, keeping in mind its pre‑1.0 compatibility caveats.