CPANscan

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.

MCE (Many-Core Engine) is a Perl toolkit for running work in parallel across multiple CPU cores by maintaining a pool of workers that pull chunks of input rather than forking per item, which makes it efficient for processing large files, long sequences, or other data-parallel tasks. It offers higher-level "models" such as Flow, Loop, Map, Grep, Step and Stream so you can express common parallel patterns with minimal boilerplate, and it includes supporting components for interprocess/thread communication, queuing, mutexes, ordered output, and a child-like async API so you can pick the right level of control for your problem. MCE is cross-platform with many Windows and Cygwin fixes, works with threads or forked processes, and supports Perl 5.8 and later, making it useful for speeding up I/O-heavy and CPU-bound Perl scripts while preserving familiar idioms like map and grep. Recent maintenance work added support for Iterator classes and introduced a dedicated MCE::Core package to improve the core API and future development, plus smaller fixes to model import behavior.

WWW::Garden::Design is a Perl toolkit for creating, publishing and searching a flower database and garden layouts. It ingests CSV files to bootstrap an SQLite-backed flower database, provides import and export scripts to generate a clickable HTML catalog and individual flower pages with names, aliases, images and notes, and produces SVG garden-layout files. A Mojolicious-based search engine with included command scripts lets you run a web UI and serve it with hypnotoad. The distribution bundles command-line tools to regenerate CSVs and thumbnails and is installable via cpanm or the usual Makefile.PL process. The project is open source on GitHub and recent updates removed uses of warnings.FATAL and moved tile generation into the database component so tiles are available online.

SPVM is a statically typed programming language that uses Perl-like syntax and is designed for high performance and native interoperability. You can run SPVM scripts with the spvm command or produce standalone executables with spvmcc, and the runtime supports AOT and JIT compilation, native threads and lightweight goroutine-style concurrency, plus bindings for C and C++ so you can reuse existing native libraries. SPVM also offers a Perl binding so Perl programs can call SPVM methods and aims to leverage familiar Perl standard functions and modules while adding static typing, type inference and static analysis for safer code. The project is still pre-1.0 and does not guarantee backward compatibility, but it includes documentation, tutorials and examples and targets cross-platform toolchains such as LLVM and MSVC.

Poker::Eval is a Perl rules engine for dealing, scoring, and evaluating poker hands. It powers a family of Poker::Game::* modules for popular variants such as Hold'em, Omaha, draw, stud and Badugi, and it also lets you compose your own evaluator by pairing the engine with a Poker::Score implementation to define high or low ranking systems. The module exposes a Dealer-backed deck with optional joker support, utilities to compute the best hand for given hole and community cards, and a Monte Carlo equity calculator that estimates expected win rates across players with configurable simulation counts. Recent releases added a rich named-game API covering many variants and improved equity handling so ties split fairly and simulations use the residual deck, and a follow-up update restored version metadata for CPAN indexing. Pick Poker::Eval when you need to simulate outcomes, compute hand rankings, or build game-specific poker logic in Perl.

Hyperman is a high-performance PSGI server for running Perl web apps that pairs a prefork supervisor with a per-worker, XS/C event loop to deliver low-latency, high-throughput serving and native async support. It runs any Plack app, lets handlers return Hyperman::Future objects to await asynchronous work without blocking, and exposes timers and io-ready primitives for in-app scheduling. Production features include graceful worker respawn and zero-downtime reloads, multiple listeners (plain and TLS) with SNI and optional client-cert verification, HTTP/2 support, a fast C implemented access log, and a shared forked arena for denylists and fixed-window rate limiting enforced at accept. The module also offers a C ABI so other XS extensions can use its loop and futures directly, and an explicit detach facility for handing live HTTP/1 sockets to an application for protocol upgrades. Recent releases notably added tls_reload to swap certificates per worker and, in the latest update, an attempt to build and serve on native Windows with a WSAPoll backend while keeping existing platform behavior unchanged.

GraphQL::Houtou is an XS-first GraphQL parser and runtime for Perl that compiles schemas and queries into a native VM to deliver very high throughput. It lets you build executable schemas from SDL or Perl type objects, serve GraphQL over PSGI, return UTF-8 JSON bytes directly from the native lane to avoid constructing Perl response trees, and use persisted compiled bundles or cached programs for minimal per-request overhead. The toolkit includes a bundled DataLoader and an on_stall-driven batching model to collapse N+1 SQL patterns, supports Promise::XS-based async execution when declared, and keeps resolvers as normal Perl coderefs while offering faster resolver ABIs and zero-argument accessors to reduce call overhead. Note that subscription streaming and some web transport features are not supported in the initial profile, only Promise::XS promises are recognized, native bundles cannot accept GraphQL variables, and Perl ithreads are not supported. The recent 0.06 release adds declarative DataLoader field support with native executor integration and an executor-owned batch plan to optimize cacheless loader paths.