CPANscan

Task::WebDyne::PAGI is a meta package that installs the Perl modules required to use PAGI with the WebDyne framework. It does not provide runtime functionality itself but acts as a convenience installer that gathers and installs the needed dependencies so you can quickly set up an environment for combining PAGI and WebDyne. Install it with cpan or cpanm to automatically pull in the required modules.

WWW::Noss is the internal backend for noss, the command-line RSS and Atom feed reader and aggregator, and implements the full set of commands used by the frontends such as updating and reloading feeds, listing and reading posts, opening URLs, marking read/unread, managing feeds and groups, discovering feed URLs, and importing/exporting OPML files. It is a private module that parses command-line options, drives feed fetching and storage, and provides the functionality behind the noss UI tools so you should consult the noss manual for user-facing documentation rather than using this module directly. The project supports modern feed features including Atom, MRSS, compressed feeds, configurable and colored output, and concurrent access by multiple noss instances. Recent releases improve performance and remove the Parallel::ForkManager dependency by handling forking internally while adding convenience and UI tweaks such as per-feed open commands and improved nossui temporary file handling.

BarefootJS::Backend::Xslate is a lightweight rendering backend that lets the BarefootJS runtime render Kolon-style Text::Xslate templates. It either accepts a ready Text::Xslate instance or will build one from a list of template directories and options, and it runs with or without a web framework so it works under PSGI/Plack or in standalone scripts. The module is designed to be paired with the @barefootjs/xslate compile-time adapter which emits .tx templates that call the runtime as a bf object, and templates are rendered with HTML auto-escaping enabled while helpers can return mark_raw to emit safe markup. Common runtime hooks are provided, including encode_json, mark_raw, materialize, and render_named which binds the runtime into the template and renders name.tx with supplied variables. If you use BarefootJS and prefer Kolon/Text::Xslate templates this backend provides a simple, framework-agnostic bridge.

Config::MVP is a small Perl framework for assembling structured, package-oriented configuration into a sequence of named sections, where each section records a package name and a hashref of settings to drive plugin-style initialization. It does not read files or databases itself but is the helper that readers use to build up configuration step by step via an Assembler state machine, expanding section names into package names, collecting settings into a payload, and handling multi-value parameters by pushing them into arrayrefs. Packages can opt in to friendly behavior by providing mvp_aliases to rename settings and mvp_multivalue_args to declare which keys should always be multi-valued. The resulting Config::MVP::Sequence of Config::MVP::Section objects makes it trivial for applications to instantiate plugins or configure subsystems by calling each section's package->new with the payload, and the Assembler, Sequence, and Section classes are intentionally simple and easy to subclass for customization.

WWW::Spotify is a lightweight Perl client for the Spotify Web API that exposes catalog and user endpoints as simple methods so you can fetch albums, artists, tracks, shows and audiobooks and manage playlists and the authenticated user’s library without hand‑writing HTTP calls. Calls return JSON structures by default and can be auto‑decoded to Perl data, and a handy get method powered by JSON::Path lets you extract values from the last response. The module supports the OAuth authorization‑code flow via authorize_url, get_access_token and refresh_access_token and automatically attaches bearer tokens to requests. You can supply your own LWP::UserAgent for custom networking or debugging and install a custom_request_handler to inspect HTTP::Response objects, while helpers like response_status, response_content_type, die_on_response_error and last_error simplify error handling. The 1.000 release contains breaking changes to match Spotify API removals and security fixes, notably removing several deleted endpoints, making bearer tokens mandatory for every request, treating ua as a plain LWP::UserAgent, changing the custom request callback to receive an HTTP::Response, and storing last_result as UTF‑8 bytes, so review the changelog before upgrading. If you need a practical Perl interface to query Spotify catalog data, automate playlists, or perform OAuth‑protected user actions, this module is a good fit.

Perl::Tags generates ctags-style tag files for Perl projects so editors and IDEs can jump to subroutines, variables and module definitions quickly, and it is useful whether you want a simple command-line tool or integration with editors such as Vim. It ships with several taggers including Perl::Tags::Naive, a fast line-oriented scanner that is pragmatic and lightweight, Perl::Tags::PPI which uses PPI for more accurate parsing, and Perl::Tags::Hybrid which can combine both approaches, and it supports recursive, incremental tagging following use and require up to a configurable depth and even recognizes test module patterns like use_ok. You can run it from the perl-tags script or drive it from Perl code, extend it by supplying your own get_tags_for_file implementation, and output Exuberant ctags-compatible files that editors expect. The project was reorganized in the 0.30 series to split components out and add the Hybrid tagger, improved editor integration with a fatpacked script and better command-line options were added in later 0.31 and 0.32 bugfix releases. If you need reliable, extensible tag generation for navigating Perl code across modules and scripts, Perl::Tags provides both quick heuristics and deeper parsing options to fit different workflows.

InternetData is the official Perl client for the InternetData API. It lets Perl programs list and download the service's licensed IP and network databases and read the API catalog, per-database metadata, checksums, and your organization's recent download attempts. You construct a client with an API key that carries the db.download scope, or omit the key to make anonymous queries for public endpoints. The API calls are exposed under $client->database and each has both a blocking form and a nonblocking _p variant that returns a Mojo::Promise so it integrates cleanly with Mojolicious. Downloads use a Mojo::UserAgent you can supply for proxy or TLS needs and the client intentionally does not follow the HTTP redirect for downloads to avoid loading multi‑gigabyte files into memory. Errors are reported as InternetData::Error and the module supports configurable retries and timeouts. The client is MIT licensed.

OpenMP is a tiny metapackage that makes it straightforward to use OpenMP from Perl by pulling together the needed pieces and removing boilerplate. Installing it brings in OpenMP::Simple for C macros and runtime helpers, OpenMP::Environment for managing OMP_* variables, Inline::C for embedding C code, and Alien::OpenMP to provide the OpenMP runtime. It exposes a minimal API with a constructor and an env accessor so you can set or validate the OpenMP environment from Perl and then call parallelized C functions via Inline::C while using macros like PerlOMP_GETENV_BASIC in your C. The module is mainly a bootstrap convenience for Perl+OpenMP development and documentation and has been tested with GCC's GOMP implementation.

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.

Dist::Zilla is a build system for Perl authors that automates creating CPAN-ready distributions, focusing strictly on packaging rather than installation of downloaded modules. It is designed to run on a repository checkout and uses a rich plugin architecture to gather files, infer or set the distribution name and version, generate META files and licenses, record authors and prerequisites, and control release status and other metadata. You configure a dist with attributes such as name, main_module, license, files, and prereqs and then let Dist::Zilla and its plugins produce the finished archive, which makes repetitive packaging tasks much easier and more consistent. The tool favors power and flexibility and therefore expects a recent Perl and an author-side workflow, and it carries no formal stability guarantee across major releases. If you write or maintain CPAN distributions and want a highly extensible, community-driven system to automate packaging, Dist::Zilla is likely relevant, and learning resources are available at dzil.org and the #distzilla channel on irc.perl.org.

perlomp is a documentation-focused distribution that explains how to use OpenMP from Perl and ties together the small ecosystem that makes it practical. It describes OpenMP::Environment for managing and validating OpenMP-related environment variables, OpenMP::Simple for configuring Inline::C builds and supplying C helper macros, and the OpenMP metapackage that installs and exposes these pieces for convenient use. The modules do not implement OpenMP themselves but make it straightforward to launch existing OpenMP executables or embed OpenMP C code inside Perl with Inline::C while handling toolchain discovery, environment setup, and runtime updates. The docs emphasize important caveats such as the need to set some controls before a runtime initializes, portability requirements across compilers and runtimes, and the safety pattern of moving Perl data into native C storage before parallel work. This initial 0.01 release provides a perl-style manual page, quick start examples, and detailed guidance on initialization, validation, and portability to help you get started.

Sub::Exporter is a modern replacement for Perl's Exporter that makes it easy for a module to provide customized, per-user functions instead of just handing out copies of its own subs. Instead of only exporting exactly what is defined in the package, Sub::Exporter lets you define generators that build new coderefs on demand so importers can request preconfigured variants, rename imports, or apply prefixes and suffixes for groups of symbols. It also supports named groups and group generators for building multiple related routines that share lexical state, and collectors that gather shared import-time settings so callers can supply defaults without relying on global variables. You set it up with a simple configuration that installs an import routine into your package and then use familiar syntax like -as, -prefix, and -suffix when importing. Sub::Exporter only exports subroutines by design, so it does not handle non-code symbols, and it aims to work on a wide range of Perl versions. Use it when you want fine grained, per-import customization of exported functions and to avoid package-level configuration collisions.

Data::OptList is a tiny utility that normalizes and validates name/value option pairs so you can write and consume compact option lists without worrying about lots of undef placeholders or subtle map bugs. Its main routine mkopt accepts undef, a hashref, or an arrayref and returns a canonical array of [name, value] pairs where a defined non-reference is treated as a name and an immediately following reference becomes its value. You can ask mkopt to enforce unique names, constrain value types via a must_be spec, or provide a custom name_test coderef for special name rules. For callers that need a hash form, mkopt_hash converts valid input to a plain hash and will throw if a name appears more than once. The module is lightweight, Perl-version friendly and intended for use wherever you want simple, predictable option parsing. Recent releases updated internal type checking to use Params::SomeUtil and the distribution now requires Perl v5.12.0 or newer.

Device::SerialPort is a pure-Perl, POSIX-based implementation of the Win32::SerialPort API that lets you open, configure, and talk to serial ports on Unix-like systems with a familiar object interface. It handles common serial parameters such as baud rate, parity, data and stop bits, and flow control, and it provides read/write operations, status queries, modem line control, timed pulses for RTS/DTR/BREAK, and tied FileHandle support so you can print and read from ports like ordinary filehandles. The module also includes convenience wrappers for common stty settings, an Expect-like lookfor mechanism for pattern-driven reads, and support for saving and starting from configuration files to simplify scripts. A few features from the original Win32 API are intentionally not ported and some POSIX-specific behaviors are still experimental, for example lockfiles, certain ioctl-dependent functions, and read timing which can split large reads into 255-byte segments or hit platform limits; in those cases methods will return undef when not supported. If you need cross-platform code or are porting Win32::SerialPort scripts to Linux, BSD, or Solaris, this module gives you a practical, Perl-native way to manage serial communications while allowing you to tweak or extend behavior in pure Perl.

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.

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.