CPANscan

Database::Abstraction is a read-only, ORM-like layer that gives Perl programs a single, simple API for querying data stored as CSV, PSV, XML, SQLite, BerkeleyDB, DBM::Deep or any DBI-compatible database without writing SQL. You express filters as plain values, comparison hashes, pattern and set operators, logical groupings, or by adding join specs, and you can chain queries with the provided Query builder or use AUTOLOAD column shortcuts for quick lookups. Small files can be slurped into memory for very fast reads, DBI statements are prepared/cached for speed, and optional CHI-compatible caching and schema introspection are built in. It is ideal when you need to switch storage formats without changing application code or want lightweight read-only access to a variety of backend files or databases. Note that it is intentionally read-only, the default CSV separator is historically "!" so you may need to set sep_char => ',' for standard CSVs, slurp mode assumes a unique key column and simple XML structures only, and BerkeleyDB has some feature limits. The recent 0.37 release added remote file support so candidate files can be fetched over SSH/SCP into a temporary directory, added DBM::Deep (.dbm/.deep) detection and in-memory support, and tightened identifier validation and other security and stability fixes.

DBD::Pg is the mature Perl DBI driver that lets Perl programs connect to and work with PostgreSQL databases using the familiar DBI interface. It handles connection details and SSL options, supports server side prepared statements and several placeholder styles, marshals Postgres arrays and bytea values into Perl structures, and provides convenient features for transactions, savepoints, bulk COPY I O, large object handling, asynchronous queries and even asynchronous connect. It also exposes rich metadata methods such as table_info, column_info and primary_key_info, plus utilities for quoting, last_insert_id and LISTEN/NOTIFY, so it suits everything from simple scripts to data‑heavy or low‑latency applications. The module is actively maintained and widely used, and recent releases fixed async prepare and COPY TO STDOUT issues and improved SSL documentation, with a very small packaging fix for Mac compilation in the latest point release. If you write Perl that talks to PostgreSQL, DBD::Pg is the standard, full‑featured driver to use.

This Perl module is a client library for Aspose.Cells Cloud that lets Perl applications interact with Aspose's spreadsheet REST API to create, convert, edit, and manage Excel files in the cloud. It provides helper components such as ApiFactory, Configuration and Role to simplify authenticating, configuring endpoints, and constructing API clients so you can upload workbooks, manipulate worksheets, ranges, charts and formulas without dealing with raw HTTP calls. If you need to automate spreadsheet processing from Perl and prefer outsourcing the heavy lifting to a cloud service, this module gives a convenient, higher-level interface to do that.

Punk::TOTP is a small, self-contained Perl implementation of RFC 4226 (HOTP) and RFC 6238 (TOTP) that generates base32 secrets, emits otpauth:// provisioning URIs for QR-based enrolment, creates time- or counter-based one-time codes, and verifies them with built-in replay protection. It includes helpers to produce appropriately sized secrets and RFC 4648 base32 encode/decode that tolerates the spaces and hyphens common in displayed secrets, and the verifier checks a configurable time window with constant-time comparisons and requires callers to supply a stored last_counter to prevent reuse. The module needs no external crypto libraries at install time because HMAC is provided at runtime by File::Raw::Hash, and options let you pick algorithm, digits, period, skew and time for flexibility. Store the secret and the last_counter securely in your database because verification requires the secret, and note that this is the initial 0.01 release.

File::Raw::Hash is a File::Raw plugin that computes digests and HMACs while passing file bytes through unchanged, delivering the resulting checksum into a caller-supplied scalar, hash or arrayref so it works equally well for reads, writes, streaming and per-record processing without loading whole files into memory. It supports a range of algorithms (sha256, sha512, sha1, md5, crc32, xxh64, blake3), multiple output formats (hex, HEX, base64, base64url, raw), and multi-algo runs in one pass for efficiency. All algorithms are vendored reference implementations so there are no external crypto dependencies, and HMAC mode is available for the mainstream digest algorithms. The module keeps legacy and non-cryptographic options like sha1, md5, crc32 and xxh64 for interoperability and fingerprinting but warns they are not suitable for new security designs. A recent change added a C ABI header (frh_abi.h) so other XS extensions can call into its digest and HMAC runner directly.

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.