CPANscan

DBIx::Class::Async is an experimental adaptor that lets you use DBIx::Class in event-driven Perl programs without freezing your process by moving blocking DBI work into a pool of background worker processes and returning Future objects to your code. It gives you true parallelism for heavy queries, non-blocking CRUD and ResultSet operations, transaction support via txn_do, optional query caching with CHI, and optional metrics reporting, while remaining loop-agnostic so you can plug it into IO::Async, Mojo or other reactors. The module has been tested with SQLite, PostgreSQL, MySQL and Oracle and provides a familiar DBIC-style API via a virtual schema returned from connect or create_async_db so most existing DBIC code can be adapted to async workflows without a full rewrite. It also includes utilities for debugging generated SQL and for running batches or parallel tasks across the worker pool, and exposes clean shutdown via disconnect to avoid worker leaks. Recent releases fix stability issues on shutdown and change clone behavior so clones share the parent worker pool by default to avoid segfaults during global destruction, and the latest patch level cleans up test coverage. If you are building a web server or other evented application and need responsive, concurrent database access while keeping DBIx::Class semantics, this module is worth trying, but note it is still labeled experimental and feedback is encouraged.

Mojolicious::Plugin::BarefootJS plugs the BarefootJS server runtime into a Mojolicious app and exposes a per-request "bf" helper that gives you a BarefootJS runtime backed by BarefootJS::Backend::Mojo, so you can server-render BarefootJS templates directly from your Mojolicious controllers and templates. It also understands compiled marked templates and integrates with the usual Mojolicious rendering flow, making it a drop-in choice if you want server-side rendering of a BarefootJS front end inside a Perl web app. If you do not use Mojolicious there is a sibling backend using Text::Xslate. A recent improvement switched the build manifest to be loaded lazily and cached by mtime and size so booting before the first build finishes no longer leaves the server with stale SSR defaults and manifest changes are picked up without restarting.

BarefootJS is a lightweight server-side runtime that lets Perl apps render templates compiled from JSX/TSX into marked templates plus client JavaScript. It intentionally avoids tying you to any particular template engine or web framework by delegating framework-specific work such as JSON marshalling, raw-string marking, JSX-children materialization, and named-template rendering to pluggable backends. Compiled templates call the runtime as a bf object to produce scoped attributes, JSON output, and spread attributes at render time. Shipping backends include BarefootJS::Backend::Xslate for Text::Xslate and a Mojolicious plugin, and the core module only uses Perl core modules unless a chosen backend requires other libraries. The project is actively maintained and distributed under the MIT license, making it a practical choice if you want to integrate JSX/TSX-style templates into PSGI, Mojolicious, or other Perl web stacks.

AmberDB is a high-performance flat-file NoSQL engine for Perl that sits on top of Berkeley DB (DB_File) and gives you schema-driven records, precomputed inverted indexes, columnar facet indexes, and full ACID transactions with undo journaling and strict two-phase locking for safe multi-table updates. You can use it like a document store with nested repeating blocks or in a lightweight simple mode as an ultra-fast schemaless key-value store that supports RAM-disk caching, full-text search with multilingual normalization, slug maps, and a rich set of helpers for inserts, updates, deletes, reads, filtering and pagination. Schemas live on disk or can be changed at runtime, indexes are built automatically from schema definitions, and the API exposes both high-level operations (field_fetch, search_table, read_all) and low-level DB_File access for bulk or recovery tasks. Recent releases hardened ID validation and simple-mode key sanitization, standardized slug handling and .slg files, and strengthened concurrency and cross-platform flocking; note that a previous release introduced an important migration: your schema directory must be named schema/ rather than scheme/.

WebDyne is the core runtime and rendering engine for the WebDyne framework that lets you build and serve ".psp" pages either inside a web runtime such as Apache/mod_perl, PSGI, or PAGI, or as a standalone tool for offline or scripted HTML generation via the exported html() and html_sr() helpers. It supports embedding Perl inside HTML, compile-time parsing and caching of pages, chained handler modules, filters and templates, and convenient CGI-style parameter access so you can write dynamic pages and APIs without wiring low-level request plumbing. In server deployments you call handler() to run the full request lifecycle while standalone scripts can render templates to strings, scalar refs, or filehandles with options for filename, custom handler class, parameters, and a prebuilt request object. The project includes comprehensive docs and examples on GitHub and recent releases have focused on robustness and modern runtimes, notably fixing PAGI multipart upload handling for reliable binary uploads and improving cache behavior on virtual filesystems with zero mtime files. If you need a lightweight, scriptable PSP renderer integrated with PSGI/PAGI or a modular handler for production web servers, WebDyne provides a full-featured, actively maintained solution.

App::SlimPacker is a small toolkit, used by the slimpack CLI, for producing compact standalone Perl scripts by minifying source and bundling dependencies. It offers a PPI-based minifier that strips comments and POD, collapses whitespace, and can shorten lexical my variable names while being careful around string interpolation, regexes, heredocs and other contexts that must not be changed, and it intentionally leaves local and our declarations untouched. Beyond minification it provides bundling helpers to discover static dependencies from use and require lines, inline Module::Pluggable plugin lists so they do not need to load at runtime, and assemble small programs from perl-style -m/-M/-e/-E switch arguments. Unlike fatpack, which copies modules verbatim, slimpack runs each bundled module through the minifier to produce much smaller single-file executables. The main entry points include process to minify code, module_deps to extract dependency names, inline_plugins to replace pluggable lookups with concrete lists, and perl_switches to build switch-based programs, and renaming of variables is enabled by default but can be turned off when you need to preserve original identifiers.

Linux::Event is a Linux-only asynchronous I/O toolkit built around a native epoll-based event loop that gives Perl programs efficient nonblocking access to filehandles, sockets, timers, signals, and process lifecycle events. The public API is organized into two categories, IO and Kernel, with concrete leaf classes for pipes, terminals, stream sockets and listeners, datagram sockets, timers, signalfd-backed signal objects, eventfd notifications, and pidfd-based process handling. Applications normally subclass the appropriate leaf or attach objects to a Linux::Event::Loop to receive callback-driven I/O, while a raw loop->watch API remains available for low-level descriptor readiness. The distribution also provides declarative framing for byte streams, optional OpenSSL-based TLS support, structured error and address helpers, and facilities for spawning and supervising child processes, so you can implement framed protocols, secure streams, and async process I/O without managing epoll yourself. It requires a modern Linux runtime and recent OpenSSL headers. The recent 0.111 release completes a public-surface audit that finalizes the IO/Kernel taxonomy, stabilizes loop introspection type labels, and tightens benchmarks and documentation to make the API clearer and more robust.

StreamFinder is a Perl library that takes a radio, podcast, or video webpage URL and finds the real, playable stream URLs plus basic metadata like title, description, artist, and cover art so you can play content in your own media player instead of a browser. It is a module meant to be used by other Perl programs rather than a standalone application and it organizes site-specific logic into submodules for many popular services such as YouTube, Vimeo, Apple Podcasts, TuneIn, iHeart, Rumble and others, with a generic Anystream fallback for unsupported pages. Common methods let you fetch one or all stream URLs, request an extended m3u playlist, download icon or banner image data, count found streams, and query site-specific IDs or descriptions. The module supports per-site and global configuration files, offers options for debugging and secure-only streams, and logs results if desired. For some sites you should install yt-dlp because StreamFinder delegates extraction to it when needed. Note that a few sites are no longer supported or have become harder to parse due to JavaScript, cookie or tracker requirements and the SoundCloud helper is marked as deprecated for casual searching.

kateb is a small command line utility for installing and updating free Persian (Farsi) fonts, aimed at making it easy to add or refresh a set of popular Farsi fonts on a workstation or server. It lets you list available fonts, install, reinstall or update one or all fonts, show font info, and self-upgrade the tool itself, installing fonts into a per-user directory (~/.local/share/fonts/farsifreefonts) or a system directory (/usr/share/fonts/farsifreefonts) when run with sudo. It supports many well known Persian fonts such as Vazirmatn, Shabnam, Mikhak and Behdad, refreshes the font cache after changes, and is simple to install via cpanm. Recent updates added macOS support and improved command behavior including automatic fc-cache refresh after installs or updates.

Browser::OIDC is a small Perl module that helps command line programs obtain an OpenID Connect token by opening the user's web browser for interactive login and running a short-lived local HTTP server to capture the provider's redirect and token response. You create it with a provider base URL and call get_token with options such as client_id and optional client_secret, enable PKCE, request scopes, and supply a completion message and content type to show in the browser. The module focuses on the common CLI pattern of launching a browser and receiving the callback rather than implementing the entire OIDC/OAuth2 specification, so it is a good fit for simple interactive authentication workflows but not for full-featured OIDC deployments. This is the initial 0.001 release.

Test2::Harness is the backend engine for running and processing Perl test suites with tight Test2 integration. It executes tests, parses their TAP and Test2 event output, schedules and parallelizes jobs, manages resources and persistent runners, and exposes plugin hooks for coverage, reporting and other extensions. Most users interact with it through the App::Yath command line UI, but integrators and plugin authors can use it directly to build custom harness behavior or embed advanced test orchestration into their tools. The project is mature and actively maintained; recent releases dramatically sped up the test suite by removing fixed waits, moved slow tests behind AUTHOR_TESTING, improved wait loops to avoid busy spinning, and made it more robust when a runaway run ignores TERM. If you run complex or concurrent Perl test workflows, need fine grained control over scheduling, resources or coverage, or want a pluggable harness foundation, Test2::Harness is worth looking at.

RT::Extension::RepeatTicket is an add‑on for Best Practical's Request Tracker that automates creation of recurring tickets from a template ticket so you can schedule regular work without manual ticket entry. Once enabled you get a Recurrence tab where you define a schedule, optional lead time, subject formatting and other defaults, and a daily helper script (bin/rt-repeat-ticket) creates the new tickets for the scheduled dates. The extension supports two modes: Simple Mode where tickets are created on each recurrence date and Concurrent Tickets Mode where new tickets are limited by a configurable number of active concurrent instances and start relative to a lead time. You can customize defaults such as lead time, the subject format, how many preview recurrences to show, and which custom fields to skip being copied, and each recurrence stores a link back to the original ticket so you can manage or cancel the series. Be aware that running the creation script multiple times for the same date can generate duplicate tickets unless you use Concurrent Mode with an appropriate concurrency limit. Recent updates added full RT 6.0 support and improved copying of multiple links of the same type when repeating tickets.

Archive::HAR::Writer is a small utility for turning a series of HTTP transactions into a HAR 1.2 document and writing it out as JSON, making it easy to export request and response data for debugging, performance analysis, or importing into other tools. You create a writer, feed it transactions either as Mojolicious Mojo::Transaction::HTTP objects or as simple arrayrefs of HTTP::Request and HTTP::Response, and then write the resulting archive to a file, a file handle, or a string reference. The module exposes a simple add_http_transaction method and a write/write_file API and includes an "api" property to manage future compatibility. This is the initial 0.01 release, so it is focused on the core conversion and output capabilities rather than broad protocol dialect handling.

Data::Identifier provides a format independent object for representing and manipulating identifiers such as UUIDs, OIDs, URIs and many well known tag types. It stores an identifier together with its type and offers flexible constructors for parsing or creating identifiers, a secure random generator, and methods to obtain canonical forms such as uuid(), oid(), uri() or an ISE. The module can normalize and perform best effort deduplication of identifiers and lets you register frequently used items for better performance, and it can convert identifiers into other Perl objects via as() for integration with URI, tag, file and numeric libraries. It also supports comparison and equality checks, per-identifier user data, and user friendly outputs like displayname, displaycolour, icontext and permanent tagnames. Validation is performed when possible but is intentionally conservative so you should not rely on it to reject every invalid value, and deduplication is optimized for speed rather than absolute guarantees. Recent updates improved color handling and character name tagnames, added support for Convert::Color and big number conversions, and fixed generation edge cases around displaynames and registered identifiers to make generation and conversion more robust.

Music::Dataset::ChordProgressions is a lightweight dataset module that gives you hundreds of chord progressions organized by genre—blues, country, jazz, pop and rock—with entries written for C major and C minor. You can retrieve the data as a filepath with as_file, as an array with as_list or as a hash with as_hash, and you can transpose any hyphen-separated progression from C into another key and scale with transpose. The chord names are chosen to match Music::Chord::Note and the collection is intended for tasks like prototyping, music education, algorithmic composition or testing rather than for production scoring. The author notes some odd or poorly documented entries and the original source is unknown, but the module is practical and easy to use. A recent update fixed the shared-data handling so external configuration of the share location works properly.

RT-Extension-AWS-Assets is a Request Tracker (RT) plugin that synchronizes AWS compute resources with RT Asset records so you can track EC2 and RDS instances and their reserved instances inside RT. It fetches instance and reservation data from AWS using IAM keys, maps important AWS fields into RT custom fields, creates assets in configurable catalogs, and provides a web UI to link running resources to purchased reservations by matching service, instance type, and region. It works with RT 6 and installs like a normal RT plugin with a Makefile and a line in RT_SiteConfig, and you must define the asset catalogs and the custom fields to use for AWS IDs and other attributes. Recent updates improved RDS reserved instance syncing and paging and added the ability to purchase reservations from RT searches and set the region when reservations are bought through the UI. If you run RT and want a straightforward way to import, view, reconcile, and link AWS EC2/RDS resources and reservations into your asset inventory, this extension is likely relevant.

LWP::MediaTypes is a small utility for mapping file names or URIs to MIME content types and encodings so you can set sensible Content-Type headers when serving or uploading files. It looks up mappings from a media.types file (with ~/.media.types and ~/.mime.types as fallbacks), accepts filenames or objects that provide path or filename, and will fall back to Perl's -T test to choose text/plain or application/octet-stream when the type cannot be deduced. The module can also report encoding suffixes, let you add custom type or encoding mappings, and populate HTTP header objects with the appropriate Content-Type and Content-Encoding values. Recent maintenance updated packaging and removed a test dependency to preserve compatibility with older Perl versions.

Alien::ImageMagick automates fetching, building and installing the ImageMagick C library and its PerlMagick interface so they install cleanly under cpanm and perlbrew. Instead of depending on Image::Magick directly you declare a dependency on Alien::ImageMagick and it will download and compile either a specific release you pin or the freshest available build without clashing with a system installation. You can pin a version using the PERL_ALIEN_IMAGEMAGICK_VERSION environment variable or let it resolve the latest release automatically. Recent updates make the module resolve and download the latest ImageMagick from GitHub releases when the upstream archive became unreliable and improve CI and build options so ImageMagick is built with its modules enabled. This module is especially useful for perlbrew users and anyone who needs a newer or isolated ImageMagick than what their OS provides.

Shell::Config::Generate is a small Perl library for creating portable shell startup files and snippets for many shells including Bourne-style shells, csh/tcsh, fish, Windows cmd.exe/command.com and PowerShell by using Shell::Guess to pick the right syntax, so you can write one configuration in Perl and emit shell-specific scripts instead of handcrafting each format. It gives simple methods to set, append, prepend or unset environment variables, manage path-style variables with the correct separator for the target shell, define aliases or small PowerShell functions, add comments or shebangs, and either write files or print shell code for eval, and it includes helpers to escape or convert Windows paths. The module does not change the running Perl process environment, it only generates text for importing into a shell, and the recent 0.35 release added an unset method and improved set_alias to accept array references so embedded spaces are preserved when quoting words.

DBIx::Lite is a lightweight, chainable ORM for Perl that lets you build SQL with minimal setup and little boilerplate, so you can compose selects, joins and updates using fluent method calls without having to declare a full schema or even be connected to a database. It works with a supplied DBI handle or can manage connections via DBIx::Connector, provides automatic accessors and result/resultset subclassing, supports relationships, transactions and pagination, and can still produce raw SQL for inspection or offline use. Advanced behaviors such as defining primary keys, related-object helpers and SQL::Abstract::More options live in an optional schema object when you need them. Recent releases have added modern conveniences such as UPSERT support and, in version 0.39, support for using CTEs with INSERT, UPDATE and DELETE, making DBIx::Lite a pragmatic, minimal alternative to heavier ORMs like DBIx::Class.

This is a tiny placeholder module created so the distribution is discoverable on CPAN. It has no functional purpose at runtime and is not normally installed on users systems. Unless you are publishing or maintaining the distribution you can safely ignore it.

Number::Phone is a Perl base class and dispatcher for country-specific phone number handling that builds Number::Phone::XX objects by detecting a number's country code or by accepting an explicit country and phone string. It provides a common API for validating numbers and checking their type with methods like is_valid, is_mobile and is_tollfree, and for exposing metadata such as country_code, areacode, areaname, operator, timezones and approximate geographic location. The module can format numbers into E.123 or via custom formatters, compute how to dial from one number to another, and map numbers to canonical targets when numbering plans overlap. If a full country module is not available it will fall back to libphonenumber-derived stub classes unless you disable that behaviour with 'nostubs', and you can force libphonenumber data by using Number::Phone::Lib. Subclasses are expected to accept both international and local forms, implement validation and formatting, and return undef for invalid numbers. The module requires 64 bit integers and generally Perl 5.14 or newer, and the author notes that alphabetic characters and underscores in phone numbers will soon be treated as errors. The project imports data from Google's libphonenumber, is updated regularly, and is maintained on GitHub with an issues tracker and mailing list for support.

VPNDetection is a Perl client for the vpndetection.io API that lets you classify IP addresses as VPNs, residential or datacenter proxies, mobile proxies, Tor nodes, hosting providers, CDNs or privacy relays. It talks to the remote service and returns VPNDetection::Result objects, while raising VPNDetection::Error on failure, and it supports single lookups, batched lookups with deduplication, per-client caching with configurable size and TTL, retries, concurrency limits, timeouts and a custom Mojo::UserAgent for proxy or TLS needs. The module recognizes that which fields are returned depends on your API plan and warns that an absent field means “not in your plan” rather than false. There is a free tier with basic fields and a 1000 requests/day source limit, a database API for licensed dataset downloads, and nonblocking promise-based methods (lookup_p, lookup_batch_p and database_p) for use inside event loops.

SPVM::UV is a libuv binding for SPVM that brings a fast, cross-platform event loop and non-blocking I/O primitives into SPVM programs. It exposes the loop plus handle and request classes such as timers, pipes, async handles, streams and poll handles, together with callback helpers so you can schedule timers, perform async writes, watch file descriptors and integrate low-latency I/O into your application. A strerror helper returns human readable libuv error messages. This module is a good fit if you need event-driven networking or timer-based tasks in SPVM and is provided under the MIT license by Yuki Kimoto.

Alien::Xmake::Project is a Perl builder that lets you generate and control xmake build scripts from Perl instead of editing Lua by hand. It offers a fluent API to declare project identity, global options, targets, options, rules, toolchains, packages and xpack installers and then writes a xmake.lua file you can save and reuse. The module returns an Alien::Xmake handle so you can run configure, build, run, install, pack and query actions directly from Perl and inspect rich target metadata. It covers the full range of xmake features from compile and link flags to language standards, platform and architecture constraints, conditional when blocks, raw Lua hooks and package definitions while rendering correct Lua tables and booleans. Use it when you want programmatic, reproducible xmake projects or need to drive xmake from Perl-based tooling and automation.

Crypt::NaCl::Sodium is a Perl wrapper around libsodium that brings modern, easy to use cryptography to Perl applications. It exposes high level primitives for secret key and public key encryption, authenticated encryption with additional data, signatures, generic and short-input hashing, password hashing, stream ciphers and Diffie-Hellman, plus utilities for secure random bytes, constant time comparisons and hex conversion. The module emphasizes security and performance and includes guarded data storage via Data::BytesLocker so keys and secrets can be held and wiped safely. If you need a portable, well maintained way to build encryption, signing or password hashing into a Perl project this provides a comprehensive, production-ready API backed by the libsodium library.

URI is the standard Perl toolkit for creating, parsing and manipulating Uniform Resource Identifiers and URLs. It turns URI strings into objects you can inspect and modify with simple accessors for the scheme, authority, host, port, path, query and fragment, and provides higher level operations like canonicalization, equality testing, resolving relative URIs against a base and producing IRIs. The module also includes helpers for working with query forms and parameters and offers scheme-specific behavior for many common schemes such as http, https, file, mailto, ftp, ws/wss and others. Use it when you need reliable construction, normalization, comparison or component-level editing of web and network resource identifiers in scripts or applications. Recent updates improve IDNA handling by applying Unicode NFC normalization so host encoding matches other clients and avoid non-round-tripping A-labels, and they preserve leading and trailing whitespace in file:// paths.

Wasm lets you build Perl extensions with WebAssembly so Perl subs and Wasm functions can call each other almost transparently. It makes it easy to export and import functions, tie WebAssembly globals to Perl scalars, access linear memory and traps, and either inline WebAssembly Text or load .wat/.wasm files alongside your .pm files. The module integrates with Perl Exporter so exported Wasm functions can appear as normal Perl subs and it uses Wasm::Wasmtime under the hood, so the interface is still evolving and may change. Note that Wasmtime’s default memory strategy allocates large PROT_NONE pages which can conflict with strict virtual memory limits on some systems, but you can tune behavior via PERL_WASM_WASMTIME_MEMORY and the provided testing plugin helps detect problematic environments. If you want to mix Perl with code compiled from Rust C Go or other languages into a lightweight, callable WebAssembly component this module provides a practical bridge.

CPANSA::DB is a small, focused module that packages the CPAN Security Advisory reports as a ready-to-use Perl data structure so tools can consult a local copy of known CPAN security issues. It exposes a single subroutine, db, which returns a hash reference containing the advisory records, and it is primarily consumed by CPAN::Audit but can be used by any script that needs offline access to CPAN vulnerability data. Each release is published on GitHub and distributed with a GPG signature and GitHub attestation so you can verify the archive you download, and a JSON export of the same data is also provided for non-Perl consumers. The data is updated regularly with new reports and CVE mappings, making the module a convenient way to embed an authoritative, versioned snapshot of CPAN security advisories into audit or monitoring workflows.

Data::URIID is a utility for pulling structured identifiers and display metadata out of URLs, QR codes, barcodes and related objects so your app can present, link and normalise referenced items. You create an extractor, call lookup on a URI or QR text and get back a Data::URIID::Result that exposes canonical IDs, display names, thumbnails and other attributes; the module supports both offline and optional online lookups and is configurable with user agent, language preferences and per‑service online settings. It integrates with Data::Identifier and recognises many common schemes and host patterns (including geo and digest/ni URIs, tag:/acct: forms, image and barcode sources), accepts various input object types and will die on unrecoverable lookups. The project is actively maintained and recent changes added Convert::Color conversion and improved handling of unknown types, making it a good fit for applications that need to extract, normalise or enrich identity information from URIs.