CPANscan

Amazon::Signature4::Lite is a compact Perl utility for generating AWS Signature Version 4 headers so you can sign S3 and other AWS API requests without pulling in heavyweight HTTP libraries. It is designed to work directly with the simple scalars and hashrefs used by HTTP::Tiny, accepts standard credentials including temporary session tokens, and returns ready-to-use headers like Authorization, x-amz-date, x-amz-content-sha256, host and x-amz-security-token when needed. You construct a signer with your access and secret keys plus region and optional service, call sign with method, URL, headers and payload, and merge the returned hashref into your HTTP client. The module keeps dependencies to Perl core modules, provides a helper to parse AWS endpoint hostnames to extract service and region, and recent releases added an option to include the x-amz-content-sha256 header and fixed S3 path encoding to avoid double-encoding, making it a simple, dependency-light choice for basic AWS request signing.

Chem::Structure::Parser is a fast, practical Perl module for reading macromolecular structure files (PDB and mmCIF/PDBx) and returning a single, consistent hash-of-hashes that contains everything a typical script needs: header metadata, per-chain and per-residue annotations, atom coordinates, the observed and SEQRES sequences, element and atom counts, bounding box and B-factors, and convenience views such as flat atom lists, ligand tables and human-readable summaries. It autodetects format (and accepts gzipped files), presents the same keys and numbering whether the source was PDB or mmCIF, and exposes simple entry points like structure_info, structure_sequences, structure_atoms and structure_summary while letting you tune what is returned (which model(s), whether to keep hydrogens, waters, HETATM entries, atom hashes, or header parsing) so large files can be read with controlled memory cost. The coordinate parsing is implemented in C for speed so even very large entries parse quickly, while irregular header parsing stays in Perl to be robust. The distribution also provides residue and residue-type helpers (aa3to1, aa1to3, res1, res_type), a cif_info helper for forcing mmCIF, and functions such as is_single_ion to spot chains that are just a single heterogen. The initial 0.01 release adds mmCIF support, a total_atoms statistic, per-chain element tallies, fixes for legacy PDB column quirks and improved element naming to IUPAC conventions, and includes expanded tests that compare output against independent readers for correctness. If you need a reliable, high-performance way to turn PDB or mmCIF files into queriable Perl data structures for sequence extraction, counting, filtering or downstream processing, this module is directly relevant.

Stats::LikeR brings a compact, high‑quality set of R-like statistics and data-frame tools to Perl with many routines implemented in XS for speed. It covers everything from basic reducers (mean, median, sum, rank, quantile, density) and matrix/PCA helpers to a wide range of hypothesis tests and models (t tests, Wilcoxon/Kruskal, chi-square, Fisher, ANOVA, glm, coxph, survival, ROC/AUC and more) plus data-frame reshaping and manipulation functions you expect from pandas/R such as read_table/write_table, agg/group_by/merge/concat, melt/pivot_table, assign, filter and various converters between AoH/AoA/HoA/HoH shapes. The code emphasizes numerical accuracy and practical behavior, is validated against R and SciPy in many places, and is designed to be usable on real datasets with sensible NA handling and UTF-8 support. If you care about recent fixes, the 0.301 release notably rewrote and hardened kruskal_test: it was cross-validated against R/SciPy, fixed several input and tail-pvalue bugs, reduced memory use and improved speed, and now returns stable, R-compatible results even for tricky inputs. If you write Perl that needs familiar statistical APIs, fast execution and reliable, R-consistent results, Stats::LikeR is likely relevant.

Database::Join is a lightweight read-only layer that lets you present two or more Database::Abstraction objects as a single virtual table by performing an in-memory equi-join on a single key. It exposes the familiar read-only API (selectall_arrayref, selectall_array, fetchrow_hashref, count, columns, schema, updated) and automatically routes query criteria to the backend that owns each column so callers do not need to know which database holds which field. The module supports left, inner and full-outer semantics, per-database permanent filters, join_map to handle differing local key names, remove_columns to hide fields, add_database to grow the view at runtime, logger propagation, and an AUTOLOAD column shortcut for quick lookups. Note that joins are performed entirely in memory so it is not intended for very large result sets, it only supports single-column equi-joins and no raw SQL builder, and count() materialises the full join and counts rows in Perl. This is the initial CPAN release and implements the core features described above.

Finance::MtGox is a Perl client for the MtGox Bitcoin exchange API that lets you make both unauthenticated and authenticated API requests and gives a few handy helpers for common tasks. You instantiate it with your API key and secret, call raw endpoints with call or call_auth and receive decoded Perl data structures, or use convenience methods like balances to fetch BTC and fiat balances, clearing_rate to estimate the market price needed to buy or sell a given amount by walking the visible order book, and market_price to compute a 24‑hour volume weighted USD/BTC price. The module communicates over HTTPS, supports MtGox API v1 and v2, and returns data in ready-to-use Perl form, making it useful if you need to script trading or query account and market data from MtGox.

MCE::Shared is a Perl module for sharing data between threads and processes that makes it easy to expose arrays, hashes, scalars, ordered hashes, sequences, queues, condition variables, file handles and a lightweight DB to multiple workers via a single shared-manager process. It supports deep sharing of nested structures, a tie interface and the mce_open helper for sharing filehandles, optional DBM and PDL integration, and can pass file descriptors when IO::FDPass is available. Concurrency helpers include built‑in mutex locking and atomic pipeline operations to minimize round trips to the manager, plus export and destroy methods to retrieve non-shared copies. The module is designed to work with MCE and MCE::Hobo for thread-like parallelism, runs across platforms including Windows and Android with some caveats, and requires Perl 5.10.1 or later. The changelog notes a recent 1.894 update that refreshes the module license.

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.

Teng is a lightweight DBI wrapper and simple object relational mapper for Perl that makes common database tasks easy without heavy dependencies. You define a small schema with a compact DSL and create a model class that extends Teng, then use straightforward methods to insert, fast insert, bulk insert, update, delete, search, run raw or named SQL, and fetch single rows. Row objects are created on the fly and inherit from Teng::Row so you do not need to write a class for every table unless you want custom row methods. Teng also provides transaction helpers, pluggable SQL builder support, options to control how rows are created, and a plugin loader to extend behavior. It is designed for simplicity and ease of installation and was forked from DBIx::Skinny. Teng does not include Perl-level trigger hooks so use Moose, Mouse, or method modifiers if you need that kind of interception.

Test::Time is a tiny utility for making time-dependent Perl code easy to test by overriding the core time, localtime and sleep functions so you can freeze and drive the perceived clock. You load it and optionally set an initial time with use Test::Time time => 123, after which time() and localtime() report the controlled value and sleep() returns immediately while advancing the module's internal clock, letting you write fast, deterministic tests for code that normally relies on the real system clock. Recent updates improved compatibility with older Perls, added catching of localtime, and fixed interactions with tools like Devel::Cover.

Promise::XS provides a fast, XS-implemented promise API for Perl that gives you deferred objects, pre-resolved/rejected promises, and aggregators like all and race for composing asynchronous results. It focuses on speed and compatibility with existing Perl promise code rather than mirroring JavaScript promises exactly, so all and race take a list of promises rather than an arrayref and resolve/reject calls do not automatically unwrap promise values. Promises may carry multiple return values and the module warns about ambiguous cases, and it also implements finally with the ECMAScript-style semantics where the finalizer receives no arguments and can alter the outcome only by throwing or returning a rejected promise. You can use Promise::AsyncAwait for async/await syntax and opt in to proper event-loop semantics by integrating AnyEvent, IO::Async or Mojo::IOLoop, otherwise callbacks run immediately which can be useful for recursion. The module is stable, well tested, and suitable for production, includes optional memory-leak detection, and lets you subclass promise objects for custom behavior. Known caveats include possible issues with interpreter threads and problematic interaction with fork on Windows.

FFI::Raw is a small, low‑level Perl wrapper around libffi that lets you call functions in shared libraries directly from Perl without writing any C or XS code. You create a function object by naming the library and symbol and declaring the C return and argument types, or by giving a raw function pointer, then invoke it with call or by treating the object like a code reference. The module also provides helpers for pointers, memory buffers and Perl callbacks so you can pass and receive C strings, pointers and function pointers, and offers a set of built‑in C types including optional 64‑bit integers. Because it is deliberately low level you are expected to supply correct signatures and manage memory and types yourself, making it ideal when you need direct, procedural access to native libraries rather than a high‑level binding. Recent releases fixed a memory leak in callback objects and improved building by using pkgconfig and preferring a system libffi where available.

Mojolicious::Plugin::Fondation::OpenAPI generates an OpenAPI 3.0.3 specification and client-side validators from DBIx::Class sources for Fondation applications, and at runtime loads that spec via Mojolicious::Plugin::OpenAPI to perform request validation and to expose Swagger UI in development. It discovers your DBIx::Async backend, writes share/openapi.json and public/js/validators.js with optional overrides for per-column schema details and CRUD permission annotations, and honors plugin-declared exclusions so internal tables can be hidden from the public API. You can disable client-side validation with the no_validator_js option while keeping server-side validation, and x-auth overrides are translated into route-level permission and group checks at startup. Note the module requires Fondation::Model::DBIx::Async and newer Mojolicious::Plugin::OpenAPI/JSON::Validator, and there is a known packaging hiccup on Perl 5.40 that can be worked around by installing a prebuilt Net::IDN::Encode package on some systems. Recent releases improved regex/pattern handling for validators, added the no_validator_js toggle, and the latest 0.05 release fixes a regression in permission/group override behavior.

Mojolicious::Plugin::Fondation::CSRF adds straightforward Cross-Site Request Forgery protection to Fondation-based Mojolicious apps by leveraging Mojolicious' built-in session token and validation. It offers three easy ways to protect endpoints: an explicit per-route condition, automatic protection of POST/PUT/PATCH/DELETE routes generated from OpenAPI, and an optional global "around_dispatch" guard that blocks mutating requests except for configurable exemptions. Tokens live in the session and are accepted from a hidden form field or an X-CSRF-Token header, and the plugin ships a small csrf.js that reads a meta tag and auto-injects the header for fetch and XMLHttpRequest calls. Sessions must be enabled and the plugin is configurable (auto_protect on by default, plus an exemptions list). Recent 0.02 fixes ensure the CSRF route condition properly marks requests as denied instead of rendering directly and includes test dependency fixes.

Mojolicious::Plugin::Fondation::Auth::Token adds opt‑in Bearer personal access token authentication to Fondation applications by providing the fondation.bearer route condition so API endpoints can accept Bearer tokens or fall back to cookie sessions. Tokens are random strings whose SHA-256 hashes are stored in an api_tokens table and are meant to be created via CLI or fixtures rather than through an HTTP login endpoint. Routes that require fondation.bearer accept valid Bearer tokens or valid sessions, return 403 for invalid tokens and 401 for unauthenticated requests, and will reject Bearer headers with 403 on routes that do not opt in. The plugin works alongside other Fondation conditions such as fondation.perm and fondation.group so you can combine authentication and authorization checks. The 0.03 release updates the dependency on Fondation::Model::DBIx::Async to 0.06 and fixes the bearer condition to set a fondation.denied marker instead of rendering an error directly.

Mojolicious::Plugin::Fondation::Auth is a small plugin that adds ready-made login and logout routes and session-based authentication to Mojolicious applications using a DBIx::Class user table. It plugs Mojolicious::Plugin::Authentication into the Fondation user model and provides sensible defaults for model name, username and password columns, session timeout and session key while allowing you to swap the default DBIx provider for alternatives like LDAP or other custom providers. Password handling uses Argon2id via hooks in the supplied Result class so the plugin only needs to verify credentials, and it ships a customizable login template, English and French translations, and handy helpers such as current_user and is_user_authenticated for controllers and templates. The module is intended for apps built on the Fondation stack and depends on Fondation::User and Fondation::Model::DBIx::Async, and the recent 0.04 release fixes the authenticated-condition behavior to set a fondation.denied marker instead of rendering.

Mojolicious::Plugin::Fondation is a plugin manager for Mojolicious that helps you build modular web apps by composing reusable plugins that can supply routes, controllers, templates, and static assets. It loads plugins recursively according to declared dependencies, merges configuration with a clear priority order (direct overrides then app config then plugin defaults), and automatically shares each plugin's templates and public files with the application while giving the app's own templates top priority. After all plugins are loaded it runs configurable post-load actions such as registering templates, controller namespaces, and static paths, supports custom actions, and offers a finalization hook so plugins can defer work until everything is wired up. The module also provides helpers for rendering named UI zones and a set of route conditions for permissions and authentication, plus a registry you can inspect at runtime. If you are building a Mojolicious site from many modular components and want automatic discovery, configuration cascade, and coordinated initialization, Fondation is designed to simplify that work.

ClamAV::Clamd is a lightweight Perl client that talks to a running clamd daemon to offload virus scanning instead of linking libclamav, so you get a small dependency-free interface to a signature engine held in the daemon. It can scan raw bytes, files opened by your process, or file descriptors passed over a UNIX socket, and it supports both simple blocking calls and a nonblocking, event-loop friendly start_scan/step API for use inside web servers. Every scan returns a Verdict object with four explicit outcomes—clean, infected, unscannable, or error—so your code can safely accept only truly scanned files and distinguish failures or size/format limits from clean results. The module exposes utility methods like ping, version, stats and reload, reports transport type and error codes, and falls back to streaming over TCP where descriptor passing is not available such as on Windows. It includes guidance on clamd.conf settings needed for reliable reports and offers a C ABI so other XS code can call it, and if you prefer a pure-Perl client or a binding that links libclamav the distribution notes alternatives to consider.

PAGI is the formal spec for writing asynchronous web applications in Perl that can handle long-lived protocols like WebSocket and Server-Sent Events as well as normal HTTP requests. Rather than a single synchronous request/response call, a PAGI app is an async code reference that receives a scope describing the connection and two async callbacks, receive and send, so an application can handle any number of incoming and outgoing events with explicit backpressure. PAGI is designed as a modern, async successor and superset to PSGI and is split into three distributions so you can depend on the specification alone or install the reference server (PAGI::Server) and toolkit (PAGI::Tools) to run and build apps. The specification documents UTF-8 handling, lifecycle scopes (http, websocket, sse, lifespan), middleware patterns, and interoperability notes such as a PSGI adapter, and it cautions that the server and tools are still beta while the core spec is stable. A recent spec draft clarifies how application providers are normalized at runtime and centralizes the contract for send Futures so that success means the server has accepted the event for outbound processing rather than guaranteeing client receipt. If you want to build or migrate async Perl web apps that need streaming, push, or long-lived connections PAGI is the place to start.

Physics::Lithography is a Perl simulation framework for modeling laser direct imprint lithography. It gives you an object oriented API to describe laser pulses by wavelength, pulse width, fluence and spot size and to attach thermal material models, then run transient heat transfer solves to predict temperature evolution and other thermal effects during a laser imprint step. The module is aimed at researchers and engineers who want to explore process parameters, estimate heating and cooling behavior, and prototype experiment control or optimization workflows in software rather than by trial and error on the bench. Its simple, scriptable Perl interface makes it easy to run parameter sweeps, integrate with analysis code, and prototype coupling to other physics tools.

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.

Physics::PVD is a Perl toolkit for modeling Physical Vapor Deposition workflows, letting you simulate atomistic film growth with Kinetic Monte Carlo and vapor transport with Direct Simulation Monte Carlo. You can configure experimental conditions like temperature, pressure, deposition flux, angle and lattice size, add material species with simple parameters, run growth simulations and extract practical outputs such as film thickness and surface roughness. The module also offers optional bridges to tools like OpenFOAM, LAMMPS and QuantumATK for multi-scale or more detailed physics when you need them. It is aimed at materials scientists, thin‑film engineers and researchers who want a programmable, scriptable environment for prototyping PVD process models and analyzing trends rather than a real-time control system for equipment. If you need a Perl-native way to explore deposition behavior and couple atomistic kinetics to larger‑scale solvers, Physics::PVD provides a straightforward starting point.

Physics::Electrodeposition models metal electrodeposition onto circular semiconductor wafers under constant current and gives physics-based engineering estimates of film growth, power, and chemistry. It implements Faraday's law for thickness and time, a lumped cell-voltage model for thermodynamic, activation, concentration and ohmic drops, diffusion-limited transport, and geometry-based metrics for uniformity and smoothness, and it is parameterized by default for an acid copper-sulfate damascene bath while allowing you to override metal, current density, wafer size, efficiency, anode type and other inputs. The module reports final thickness, deposition rate and process time, mass and mole balances including side reactions, cell voltage, power and energy metrics, and a formatted multi-section text report, and it can accept a GDSII mask to model through-mask plating and pattern-density effects. The uniformity, roughness, loading and additive-consumption outputs are calibrated engineering estimates rather than a full 3-D current-distribution simulation, so the module is best suited for scoping, sensitivity studies and quick process planning rather than detailed multi-physics validation.

Physics::Etch provides a compact, programmable way to model semiconductor etch processes by wrapping two simple etch models: an isotropic, Arrhenius-activated wet etch and an anisotropic plasma/RIE dry etch. You create ready-to-run process objects with the wet_etch and dry_etch factory methods, or fetch materials and recipes from the built-in database, then tweak practical parameters like film thickness, temperature, mask and feature size, overetch, or plasma settings such as power, pressure and bias to get quick estimates and printable reports. It is aimed at process exploration, teaching and prototyping rather than producing calibrated production recipes, and the bundled rates and selectivities are illustrative so you should always calibrate against your own tools and chemistry. The distribution is a new initial release (2026-08-18) and includes CPAN packaging and a small example database to get you started.

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.

Punk is an opinionated MVC web framework for Perl that gives you a simple DSL to declare routes, mounts, middleware, views and models and then compiles everything into a fast, frozen PSGI app at startup. It bundles common web building blocks so you do not need to wire them yourself, including REST verbs, OpenAPI mounting with request validation, static and markdown sites, WebSocket and Server-Sent Events routes, sessions, CSRF protection, CORS and security headers, password-based auth, a per-worker HTTP client and a plugin system. Punk ships a CLI that scaffolds a working app from a template or an OpenAPI file, plus commands for running, testing, generating controllers and managing secrets, and it provides an in-process test client that exercises sessions, CSRF, streaming and websockets. Async handlers are supported via futures and Punk integrates with an event loop for nonblocking IO while remaining usable on standard PSGI servers. If you want a modern, batteries-included Perl framework with fast dispatch and built-in API and realtime features, Punk is worth evaluating.

Params::Validate::Strict is a Perl input-validation library that checks a hash or positional argument list against a rich schema and returns a new hash or array of validated, coerced and optionally transformed values. It supports many built-in types including strings, integers, numbers, booleans, refs and objects, union types, nested schemas for hashes and arrays, per-element checks, custom reusable types, transform and callback hooks, positional argument support, cross-field validations and relationship rules like mutually exclusive or required groups. The module is useful for sanitising API inputs, generating black‑box tests, driving web application firewalls and documenting expected parameters, and it reports clear error messages or logs via a supplied logger. Recent development has focused on robustness and correctness with small bug fixes such as adding "object" to element_type checks in 0.39 and improving rule dispatch and test coverage in 0.38. Note that the module does not untaint values under Perl taint mode and it will accept caller-supplied regexes which, if maliciously constructed, can cause pathological backtracking, so callers should untaint or harden patterns when needed.

Template::Stencil is a compact, high-performance templating engine for Perl that compiles templates written with a simple "{% %}" syntax into packed bytecode and renders them with a fast C interpreter to produce a single scalar of ready-to-send output. It is designed for low-latency web use: templates compile once and are cached with optional mtime checks, rendering has virtually no per-request heap allocation or syscalls at steady state, automatic HTML escaping is on by default with a raw escape hatch, and you get familiar features like filters, loops, conditionals, includes and a layout wrapper while keeping deterministic output by default. Built-in filters cover common tasks and you can register Perl coderef filters when needed, and the module recently added a vetted fmt filter for sprintf-style formatting with a follow-up fix for long-double/quadmath Perls in the 0.09 release. Template::Stencil handles UTF-8 encoding for you, supports a pretty-print option via an optional dependency, and is safe to use in prefork and ithreads models because each interpreter gets its own engine with no locking. It also exposes a C ABI for embedding in XS code. Note the intentional limitations: templates cannot call methods on blessed references, some advanced features like dynamic includes and expression arithmetic are planned for later, and a few reserved words cannot be used as the first token in a tag.

QR::Code is a lightweight Perl module for generating QR symbols as clean, scalable SVGs with no external dependencies. It encodes byte-mode QR codes for versions 1 through 15 and all four error correction levels, and it can also return the raw module matrix or a plain PBM for testing. The module makes it easy to embed a centered logo (text, inline SVG, image file or raw bytes), tune error correction and version, and apply visual styles such as rounded or dotted modules, custom finder shapes, colors and gradients while performing contrast checks to help keep the code readable. Output is SVG by default so graphics scale crisply for web or print, and there are options for quiet zone width and forced versions when you need control over module size. The author also exposes a C ABI for other XS modules to call into the encoder. Be aware that aggressive styling, transparent backgrounds or subtle color/gradient choices can make a symbol fail to scan, and the module documents and validates the rules to minimize that risk.

PAGI::FastAPI is a FastAPI-inspired micro-framework for modern Perl (5.38+) that brings non-blocking async routing, Type::Tiny request validation, dependency injection and automatic OpenAPI 3.1 plus a hosted Swagger UI to Perl web apps. It lets you write async handlers with Future::AsyncAwait, mount sub-apps, add middleware, serve WebSocket endpoints, stream Server-Sent Events, and handle CORS, CSRF, rate limiting and cryptographic proof-of-work bot protection with built-in helpers and pluggable drivers. Authentication is left to middleware or per-route dependencies and a companion PAGI::FastAPI::Security distribution supplies common extraction schemes while letting you perform verification with your own logic. The framework compiles to a PAGI-compliant async app for servers and tests and recommends using Future::IO for loop-agnostic timers while documenting how to bridge Mojo-style loops when necessary. Notable in the 1.1.0 release is PAGI::FastAPI::Queue, an async-first message queue facade with a pluggable driver API and a built-in in-memory driver for simple topic-based push, pop and size operations.

Tie::Hash::Regex lets you tie a Perl hash so that when a lookup finds no exact key it treats the lookup key as a regular expression and returns the first stored entry whose key matches. The tied hash supports regex-aware FETCH, EXISTS and DELETE operations and you can force regex mode by passing a compiled qr// regex as the key. Deletes remove all matching keys. From version 0.06 you can declare a hash with the :Regex attribute if you have Attribute::Handlers installed. One limitation to be aware of is that tied FETCH is forced into scalar context by Perl so it normally returns only the first match unless you call tied(%h)->FETCH to retrieve all matching values.