CPANscan

EV::Websockets is a Perl binding that provides high-performance WebSocket client and server support by embedding the libwebsockets C library into the EV event loop. It is aimed at applications that already use EV and runs non-blocking so idle connections do not stall other watchers. You create a Context to manage integration and can open outbound connections, listen for incoming upgrades, or adopt existing sockets. Connections are represented by Connection objects with simple send and send_binary APIs, support for fragmented streaming writes, ping/pong, pause and resume of receives, backpressure hooks via send_queue_size and on_drain, and a per-connection stash for metadata. The module supports TLS, proxies, custom headers and subprotocols and provides lifecycle callbacks such as on_connect, on_message, on_close and on_error. The distribution includes examples, Feersum PSGI integration and benchmarks comparing latency and throughput. Recent 0.08 fixes addressed idle connections stalling the EV loop and crashes when recycling TLS contexts.

Data::Graph::Shared provides a fast, concurrent directed weighted graph stored in POSIX shared memory so multiple Linux processes can read and mutate the same graph structure without copying data between processes. It exposes a compact API to add and remove nodes and edges, read node payloads and neighbor lists, and query counts and degrees while protecting mutations with mutexes and a PID-based stale-lock recovery mechanism. The module supports file-backed, anonymous, and memfd-backed maps and integrates with event loops via an eventfd you can notify when the graph changes, making it useful for IPC-heavy tasks such as shared caches, routing tables, or multi-process graph algorithms. Be aware that remove_node is intentionally O(1) and only clears outgoing edges leaving incoming edge slots dangling until reused, and remove_node_full is available when you need to splice incoming edges at O(N+E) cost. It requires 64-bit Perl and Linux and the mmap is writable by any process that opens it so do not share backing files with untrusted parties. Recent releases tightened safety checks to reject max_nodes and max_edges values larger than 2^32 to avoid silent truncation and also improved atomic operations and eventfd behavior for more robust lifecycle handling.

Data::BitSet::Shared provides a fixed-size bitset stored in shared memory on 64-bit Linux, letting multiple processes read and update individual bits with lock-free atomic operations. It supports file-backed, anonymous (fork-inherited), and memfd-backed regions so you can attach by path or file descriptor, and offers per-bit set, clear, test and toggle plus queries like count, first_set, any/none and stringification for easy inspection. The implementation uses CAS on 64-bit words for high throughput, making it well suited for shared flags, membership maps, bloom-filter backends and resource-allocation bitmaps, but note that bulk word writes such as fill or zero can race with concurrent per-bit CAS operations. The mmap region is writable by any process that opens it so do not share backing files with untrusted parties. Recent maintenance fixed a potential memory leak in to_string when an out-of-memory error occurs.

Weather::Meteo is a lightweight Perl client for the Open‑Meteo archive API that fetches historical hourly and daily weather data dating back to 1940. You instantiate a Weather::Meteo object and call weather with latitude, longitude and a date supplied as an ISO string or a DateTime‑like object, and you get back a hashref containing at minimum an "hourly" key or undef on error. The module supports Geo::Location::Point for location input, automatic time‑zone resolution using TimeZoneDB when available with a fallback to Europe/London, configurable HTTP via a pluggable LWP::UserAgent, in‑memory or user supplied CHI caching to avoid duplicate requests, and an optional min_interval setting to enforce simple rate limiting. It croaks on missing or malformed coordinates, carps and returns undef for invalid dates, and silently returns undef for dates before 1940. Recent 0.14 changes hardened error handling around the user agent and JSON parsing, fixed logging calls, and expanded tests and formal API documentation, making the client more robust for scripts and data analysis that need reliable historical weather lookups.

ExtUtils::Builder::Compiler is a lightweight abstraction layer that wraps different C and C++ compilers so Perl module build tools can add include directories, preprocessor defines, and compile source files without having to handle vendor‑specific command lines. It is usually consumed by higher level portability layers such as ExtUtils::Builder::Autodetect::C and is aimed at authors building XS or other native extensions who need a consistent way to invoke compilers across platforms. The public surface is small and focused — methods to add include dirs and defines and to compile a source into a target — while the implementation takes care of platform quirks for MSVC, GCC and others. The project is actively maintained with ongoing portability and C++ improvements and the most recent release normalizes the MSVC nologo argument to lowercase to align with MSVC expectations.

Backblaze::B2V2Client is a Perl client library for Backblaze B2 Cloud Storage V2 that lets Perl programs create and manage buckets and upload, download, list and delete files using the native B2 API. It supports uploading from disk or from an in-memory scalar, has a large-file upload path for files over 100MB, can fetch file metadata or contents by name or file ID, and offers paged listing of bucket contents with prefix and delimiter support. The module stores API responses and error details on the client object and returns simple 'OK' or 'Error' statuses so you can handle outcomes easily, and it installs a convenient b2_client command line utility for quick uploads and downloads. By default it creates buckets with Backblaze-managed server-side encryption and recent updates improved file listing options and made method return values consistent. If you need Backblaze-native B2 integration from Perl this module is a practical, well-documented choice and it includes notes on required dependencies and how to test your credentials during install.

Backblaze::B2V4 is a straightforward Perl client for Backblaze B2's V4 API that makes it easy to authenticate with your application key and then upload, download and manage files and buckets. You can upload from disk or from an in-memory scalar, download by file name or by Backblaze file ID, upload large files with a specialized routine, list and inspect files, create or delete buckets and remove file versions, and it also exposes a general send_request method for calls not wrapped by the module. The distribution includes a convenient b2_client command line tool for simple get and put operations and by default sets new buckets to use server side encryption unless you disable it. If you want Backblaze native API access from Perl without learning the HTTP details this module will be relevant, note that it tests credentials during install if you provide environment vars, and this is the initial 0.01 release.

Google::ISBNNumbers is a tiny, easy-to-use Perl wrapper around the Google Books API that returns basic book metadata when you give it an ISBN. Instantiate it with a Google API key and call lookup_isbn with an ISBN (dashes or spaces are allowed) to receive a hashref containing keys like title, author_name, description, publication_date and cover_link. It is ideal for quick catalog lookups, enriching product pages, or any script that needs reliable ISBN-to-book information without dealing with the Google API directly. You do need a Google API key from the Cloud Console to use it. The recent 1.01 release cleaned up documentation and removed an unneeded object for a simpler, leaner implementation.

Linux::Event provides a Linux-native, readiness-driven event loop for Perl that uses kernel primitives like epoll, timerfd, signalfd, eventfd and pidfd to offer efficient low-level event notifications. The distribution purposely stays at the loop-and-primitives layer, exposing a core loop, watcher handles and backend contract while leaving higher-level socket, stream and process helpers to companion modules. You create a loop with Linux::Event->new, use the built-in epoll backend or supply a custom backend, register timers, signals or wakeups and then run the loop to handle asynchronous events. This module is a good fit for Perl developers who need tight, performance-oriented integration with Linux kernel readiness primitives and prefer composing their own higher-level abstractions rather than using a cross-platform or fully featured async framework.

DBIx::Class::Async is a non-blocking wrapper for DBIx::Class that offloads blocking DBI work to a pool of background worker processes so your event loop stays responsive and queries can run in parallel. It presents a familiar DBIx::Class-like API but returns Futures for ResultSet and Row operations, integrates with IO::Async (and can be bridged into Mojolicious), and supports transactional and batch workflows such as txn_do, run_parallel and await_all. The module has been tested with SQLite, PostgreSQL, MySQL and Oracle and preserves common DBIC features like relationships, InflateColumn::DateTime handling, deterministic SQL generation for caching, optional CHI caching, SQL debugging hooks and optional metrics. The distribution is described as experimental, but recent v1.0.4 releases fixed critical teardown crashes and improved clone semantics so clones share worker pools by default, and added safer automatic disconnect behaviour. Choose this module when you need true parallel, event-loop friendly DBIx::Class access in Perl applications.

DateTime::Format::Duration is a Perl utility for converting DateTime::Duration objects or simple delta hashes to and from human readable strings using a strftime-like pattern language. You instantiate it with a pattern and then use format_duration or format_duration_from_deltas to render durations and parse_duration or parse_duration_as_deltas to turn formatted text back into duration objects or hash deltas. It exposes tokens for years, months, days, hours, minutes, seconds and nanoseconds with configurable padding and precision, and it can "normalise" durations either against a provided base DateTime or using standard or ISO rules to carry values across units. Normalisation is aware of tricky calendar issues such as mixed positive and negative components, varying month lengths, daylight saving changes and leap seconds so results may depend on the chosen base or ISO mode. This module is useful whenever you need reliable, customizable formatting and parsing of durations in Perl programs.

Concierge is a service-layer orchestrator that bundles password authentication, session lifecycle, and user record storage into a single, easy to use API so applications never talk to the individual components directly. It coordinates an Argon2-based Auth component, pluggable Sessions backends (SQLite, file, memory) and configurable Users backends (SQLite, YAML, CSV/TSV), and exposes simple lifecycle methods for visitors, guests, and logged-in users with a one-session-per-user policy and a persistent user_key token you can store in a cookie. Methods return consistent hashrefs with success and message fields and, when relevant, Concierge::Desk::User objects so you can add users, log in, restore sessions, convert guests, list or update user records, and manage passwords without wiring together separate systems. The architecture is explicitly extensible so you can swap in alternate Auth, Sessions, or Users implementations or add new record-store components that follow the same interface. Recent releases reorganized helper classes under the Concierge::Desk:: namespace and made small release and packaging fixes to keep versions consistent.

Protocol::Tus is a Perl implementation of the Tus resumable upload protocol that handles the protocol-level details of creating, patching, querying and deleting uploads while leaving storage to a pluggable model you provide or instantiate, for example Protocol::Tus::LocalDir. It exposes a framework-agnostic HTTP_request entry point that honors X-HTTP-Method-Override and convenience methods for HEAD, OPTIONS, PATCH, POST and DELETE, and it always returns a Protocol::Tus::Response object so you can wire it into web frameworks such as Mojolicious. You can supply callbacks to generate Location headers or react to upload creation and completion, making it easy to integrate application-specific behavior, and the module requires Perl 5.24 or newer.

Tickit is a high-level Perl toolkit for building full-screen terminal user interfaces using a tree of widget objects to describe layout and behavior. It provides rich rendering attributes like bold, underline, italic and 256 colors, mouse support including wheel and high-column position reporting, and advanced key handling via libtermkey, though those features depend on terminal support. Tickit includes a built-in event loop with non-blocking IO watches, timers, deferred callbacks, signal and child-process watches, and convenient key binding utilities with Ctrl-C bound to stop by default. You set a root widget, call run to enter the UI loop and stop to exit, and the library also exposes terminal size queries, UTF-8 locale handling and an option to avoid using the alternate screen. If you need to build interactive, asynchronous terminal apps in Perl with a widget-based API, Tickit gives a modern, feature-rich foundation.

Net::FullAuto is a Perl module that lets you script and automate operations across many machines by keeping persistent SSH and SFTP sessions open and exposing each remote host as a handle you can call cmd, put, get and cwd on just like a local object, so you can drive multi‑host workflows, file transfers, builds and deployments from a single script. It is agentless and works with standard ssh/sftp (and older telnet/ftp modes if needed), supports proxy‑chaining through intermediate hosts, returns stdout/stderr/exit codes for robust error handling, and includes features for locking, packaged "Instruction Sets" for common tasks and an optional Term::Menus text UI. Net::FullAuto is aimed at administrators and DevOps engineers who need interactive, real‑time control of many systems without installing agents, but be aware installs can update many CPAN dependencies and the docs warn against supplying cleartext passwords instead prefer identity files or key‑based login. The project is actively maintained and the latest release adds improved logout pattern matching and other stability tweaks.

Perl500503Syntax::OrDie is a lightweight guard you can drop into the top of a script to detect syntax and runtime uses that did not exist in Perl 5.005_03, so you can catch incompatibilities before deploying to legacy systems. When used it locates and scans the calling file, flags a long list of post‑5.005_03 language constructs and regex features, and installs CORE::GLOBAL overrides to prevent unsupported open and mkdir call patterns at runtime. You can also call the API directly with check_source or check_file to get a list of violations or die on error, and the scanner intentionally ignores literal string and regex contents so runtime data does not trigger false alarms. The module strives to run on every Perl from 5.005_03 onward and the latest 0.03 release cleaned up documentation and cheatsheets, fixed many masker false positives, and added regression tests to improve accuracy. Note that the masker is not a full Perl lexer so very odd quoting can still confuse it, dynamically generated code is not statically checked, and the CORE::GLOBAL overrides affect the whole interpreter so this is best used as a development or predeploy tool rather than in production.

Dist::Zilla::Plugin::UsefulReadme is a Dist::Zilla plugin that builds a focused README from your main module POD so you can choose which top level sections to include instead of dumping the entire documentation. It understands Pod::Weaver conventions and Pod::Readme style regions, can generate fallback content for common items like recent changes, requirements and installation instructions, and can emit README files in plain text, POD, Markdown or GitHub flavored Markdown or a custom format. You control the source module, output filename and location, which sections or regexes to include, how to handle readme-only regions and whether to add developer prereqs, and there are options for encoding and for appending or prepending extra content to generated sections. This is a practical successor to Pod::Readme for Dist::Zilla users who want concise, configurable readmes that play nicely with Pod::Weaver, and it requires Perl 5.20 or later. Recent maintenance updates refreshed metadata and packaging details and stopped signing distributions with Module::Signature.

Dist::Zilla::Plugin::AutomationPolicy is a Dist::Zilla plugin that creates a CPAN-META/automation-policy.json file for your distribution, letting you declare how automation is used and what automated contributions you accept. You configure it in dist.ini with options like template (for common presets such as no_automation, human_supervised, data_driven_updates, and full_automation), models, code_generation, automated_contributions, automated_actions, description, and an optional document name for a human-readable AI_POLICY.md that you must supply yourself. The plugin relies on Dist::AutomationPolicy and requires Perl 5.24 or later. The recent 0.1.1 release specifies the minimum Dist::AutomationPolicy version, added the metadata link, and includes the generated automation-policy.json in the distribution. Use this plugin when you want to ship a clear, machine-readable statement of your project’s automation practices alongside your CPAN release.

Mo::utils::Hash is a tiny utility module that provides three simple validators for Perl hash data: check_hash confirms a value is a hash reference, check_hash_keys verifies that a given nested set of keys exists, and check_hash_optional_keys ensures a hash contains only an allowed set of keys. Each function is called with your object or parameter hash and a key name and reports problems through Error::Pure while returning undef on success. The module is lightweight and handy for Mo-based classes or any code that needs concise, consistent runtime checks of hash parameters to catch bad or missing input early.

CPAN::MetaCurator is a toolkit for collecting, curating and publishing CPAN metadata in a small SQLite database and for turning Perl.Wiki content into navigable web trees. It reads Perl.Wiki exports (tiddlers.json) and 02packages data, populates a cpan.metacurator.sqlite database with modules and topics, and can produce HTML/jsTree output so you can browse topics and modules on a website. The distribution also includes utilities and scripts for checking module names, exporting module tables, adding clickable nodes and hover text, and optionally reading the CPAN::MetaPackager database to supplement its data. It is actively maintained and geared toward authors and site maintainers who want an offline, curated view of CPAN documentation and a simple pipeline to generate site content from Perl.Wiki. Recent work reworks the jsTree generation and fixes edge cases around “See Also” entries to make the generated tree cleaner and more reliable.

Sah::SchemaBundle::KDEActivity is a tiny collection of Sah schemas for working with KDE "activity" data in Perl, providing ready-made validators for activity GUIDs and activity names. It is useful if your Perl app needs to validate, document, or transform KDE activity identifiers and labels using the Data::Sah/Sah ecosystem. The bundle is deliberately small and focused, easy to drop into projects that already use Sah, and the source and documentation are available on MetaCPAN and GitHub if you want to inspect or contribute.

WWW::YaCyBlacklist is a small Perl utility for reading, parsing and applying YaCy-format blacklist patterns so you can test or filter URLs the same way a YaCy node would. It accepts patterns from files or arrays, optionally treats host parts as regular expressions, and provides convenient methods to check a single URL, return matching or non-matching lists, remove patterns, sort the list and write it back to a .black file. Note that check_url treats any non-http/ftp protocol as a match and the module does not enforce YaCy’s limitation on multiple wildcard stars in host patterns, which the author calls a YaCy quirk rather than a module bug. The 1.00 release improves regexp performance and adds parser error reporting, making URL checks both faster and more robust.

PAUSE::Users is a lightweight Perl module for reading PAUSE's 00whois.xml and presenting PAUSE account records as simple, iterable user objects. It automatically fetches and caches the central 00whois.xml file so your code only hits PAUSE at most once per default day, and you can tune caching with max_age expressed in Time::Duration::Parse notation or point the module at a local file or cache_path. The module exposes an iterator that yields PAUSE::Users::User objects with convenient accessors such as id, fullname, asciiname, email (or CENSORED), has_cpandir, homepage and introduced, and recent versions also include nologin, deleted and type slots. Mailing-list entries in the source file are ignored and the parser uses a pragmatic line-based approach for speed against the stable, machine-generated XML. Use PAUSE::Users when you need to script or display author metadata from PAUSE without manually downloading or parsing 00whois.xml.

Hypersonic is a performance-first micro HTTP server for Perl that JIT-compiles a native C event loop and request handling via XS::JIT so the hot path runs in C rather than Perl. You register routes in Perl, call compile to generate and load C code that bakes static responses and headers into the binary, and then run a lightweight server that supports TLS, streaming and SSE, WebSockets with optional rooms, gzip compression, sessions, async thread pools and static files preloaded into C for minimal runtime overhead. Dynamic routes still invoke Perl per request and you can inject custom C helpers or write route handlers that emit XS code for the absolute lowest latency. The module is aimed at people who need very high throughput APIs and real-time features and who are comfortable with a buildable C toolchain and optional libs like zlib and OpenSSL. Recent updates improved test robustness for slow debugging Perls by extending compile timeouts and made compile diagnostics quieter during JIT builds.

OpenAPI::Modern is a Perl tool for checking that HTTP requests and responses match an OpenAPI specification (v3.0, v3.1 or v3.2). You give it your OpenAPI document when you create the object and then pass HTTP messages to validate_request and validate_response; it converts many common request/response types to Mojolicious messages, deserializes parameters and bodies, applies JSON Schema validation and returns a detailed JSON::Schema::Modern::Result with errors, absolute locations and the deserialized data. The distribution bundles up-to-date OpenAPI metaschemas, supports schema dialects, type coercion and common media-type matching rules, and includes helpers like recursive_get and find_path_item for locating operations in the spec. It also offers caching guidance for large documents and options to populate defaults into deserialized data. There are some current gaps to be aware of such as multipart bodies, application/x-www-form-urlencoded encoding and automatic checking of Authorization headers as security schemes, but recent releases have expanded support for OpenAPI 3.2 and added correct handling of $ref targets inside media-type objects and the new itemSchema keyword.

JSON::Schema::Modern is a Perl evaluator and validator for JSON Schema that implements drafts 4, 6, 7, 2019-09 and the current 2020-12 specification. You give it either Perl data structures or JSON strings plus a schema or schema URI and it returns a Result object describing validation success, errors, annotations and defaults. The module is highly configurable with options such as specification version, output format, short-circuiting, format validation, stringy number handling and default collection, and it supports adding schemas or document objects to an internal cache, custom format validators, vocabularies, media type decoders and encodings. It also exposes helpers to traverse schemas and to validate schemas against their metaschemas. Limitations to be aware of are that it will not automatically load schema documents from disk or the network and some format checks require optional CPAN modules, and you should avoid running untrusted schemas because embedded regular expressions and numeric operations can be expensive or unsafe.

exact is a compact Perl pseudo-pragma that replaces a common pile of boilerplate with a single use statement, enabling strict and warnings, turning on modern feature bundles, handling UTF-8 for source and standard filehandles, setting C3 method resolution order, enabling filehandle methods, importing useful Carp helpers, providing try/catch/finally support, bringing in PerlX::Maybe helpers and autocleaning your namespace by default. It is highly configurable so you can opt out of any piece with simple flags, request specific feature bundles or Perl versions, load extensions under exact::* for context-specific behavior, and even declare parents or export methods via helper APIs like monkey_patch, add_isa, export and exportable. The module also exposes small utilities such as deat to clean up error messages and deattry to run a block and re-throw simplified errors. Recent updates added support for a defer block on older Perls and improved error and Carp helper handling, making exact a convenient choice for developers who want consistent, sensible defaults and easy extension without fighting repetitive header code.

Weenect::API is a lightweight Perl client for the Weenect GPS-tracking service that lets you log in to a Weenect account, retrieve the list of trackers, manage account preferences, and list animals associated with a tracker, all using simple method calls that return user, tracker, preferences, and animal objects for easy inspection and iteration. It is aimed at developers who want to automate account management, integrate Weenect devices into backend scripts or monitoring tools, or build custom reporting around tracker data. The initial release adds support for an enhanced live mode (super_live) and the new get_animals and get_preferences/set_preferences methods, so you can both read and update account settings and access animal associations directly from Perl.

Net::RCON::Minecraft is a lightweight Perl client for Minecraft's RCON remote console that lets you script server administration by sending commands and receiving their text responses. It manages TCP connection and authentication, handles fragmented replies, and returns a Response object with methods to get the raw text, a version with Minecraft color codes removed, or an ANSI-converted form for terminals. The API is simple: you can let it auto-connect on first command or explicitly connect and disconnect, set read timeouts, and handle errors via eval. Be aware that RCON grants operator-level access so you should use a strong password and firewall rules, and avoid RCON on unpatched vanilla servers older than 1.14.3 because of a known crash bug. As of version 0.04 the project now uses GitHub for issue tracking.

Spreadsheet::Edit is a Perl toolkit for loading, inspecting and transforming tabular data from CSV files or spreadsheet formats and for building sheets in memory. It makes columns easy to address by title, letter or automatic aliases and can tie package variables to columns so that inside an apply block you can read and write cells as ordinary scalars while rows behave as either arrays or hashes for flexible random or sequential access. You can insert, delete, move, split and join columns, sort or transpose rows, perform row-wise processing with handy magic variables, and write results back to CSV or create new spreadsheet files. The module auto-detects title rows, CSV encodings and separators and recent releases improved CSV import and spreadsheet conversion to preserve text, dates and leading-zero values when round-tripping to spreadsheet formats. It does not preserve cell formatting and reading spreadsheet files can fail if LibreOffice/OpenOffice is running, and thread safety is unknown.