CPANscan

LTSV::LINQ is a Pure Perl library that gives you a fluent, LINQ-like query API for LTSV log files and in-memory arrays, letting you filter, transform, aggregate, group, join and sort records with chainable methods and lazy evaluation. It reads LTSV lines as hashrefs and supports a concise DSL for simple key=value filters or code references for complex logic, plus about 60 LINQ-style operators including distinct, union, groupby, join, orderby (string and numeric variants), and many terminal operations like ToArray, Count and Sum. The iterator-based design makes typical pipelines streaming and memory efficient so you can scan very large logs without loading them, while operations that require global knowledge such as OrderBy, GroupBy or Join do materialize data and will use memory. Be aware that query objects are single-pass iterators so you should snapshot with ToArray when you need multiple passes, and FromLTSV holds the file handle open until the iterator finishes which can matter if you open many files concurrently. The module is pure Perl with no XS dependencies, runs on Perl 5.005_03 and later, and includes examples and cheat sheets to help you adopt LINQ-style log analysis in Perl.

AWS::Lambda makes it straightforward to run Perl code on AWS Lambda by providing a custom runtime and ready-made artifacts so you can just drop in a handler.pl, zip it or build a container image and deploy. The distribution offers prebuilt Amazon Linux 2023 runtime layers, optional Paws (Perl AWS SDK) layers, downloadable zip archives and Docker images, plus helper routines to print the correct layer ARNs, so you can focus on your code rather than runtime plumbing. It supports streaming responses and AWS X‑Ray tracing, comes with a set of commonly used Perl modules preinstalled, and lets you create custom module layers for additional dependencies. Local testing is supported via Docker and the Lambda Runtime Interface Emulator, legacy Amazon Linux and AL2 layers remain available for backward compatibility but are no longer maintained, and recent releases keep the runtime current with the latest Perl releases and dependency updates including support for the 5.42.x series and key JSON and SSL library bumps.

Mouse is a lightweight, Moose-compatible object system for Perl 5 that gives you Moose-style class and role syntax, attributes, method modifiers, type constraints and the familiar meta API but with far lower startup cost and minimal runtime dependencies. It lets you declare attributes with has (including readers, writers, defaults, lazy builders, coercions and delegation), add before/after/around modifiers, consume roles, and call make_immutable for faster objects while remaining close enough to Moose that you can usually swap one for the other. Mouse ships with a pure-Perl implementation and an optional XS backend for extra speed and works well in scripts or command-line tools where startup time or dependency bloat matters. It is intentionally a subset of Moose, so if you need more advanced MooseX extensions you should move to Moose, and there are helpers like Any::Moose to smooth compatibility. The latest release fixes a corner case converting floating point numbers to strings when using quadmath-enabled Perls.

PAGI, the Perl Asynchronous Gateway Interface, is a modern async successor to PSGI that defines a standard way for async-capable Perl web servers, frameworks, and applications to interoperate. It specifies an async application signature that receives a scope plus receive and send callbacks and it supports HTTP/1.1, WebSocket, and Server-Sent Events so you can build both request/response handlers and persistent connections. The distribution ships a reference PAGI::Server, lifecycle helpers, request and protocol wrappers, routers, middleware, and example apps to help you get started. The core spec and the reference server are intended to be stable while many convenience modules remain under active development and may change between releases. PAGI requires Perl 5.18 or newer and relies on IO::Async and Future::AsyncAwait. This is beta software so for production use you should run the server behind a reverse proxy and expect non-spec helpers to evolve. If you want to write or run modern asynchronous web services in Perl and prefer an explicit async interface, PAGI is worth a look.

App::CdUtils is a small collection of command-line helpers that make directory navigation more precise and scriptable. The distribution bundles several backend utilities for common tasks such as jumping to sibling directories, moving to the previous or next sibling, navigating to a specific path part, resolving a target directory and displaying a directory tree, so you can integrate smarter cd behavior into shell wrappers or scripts. It is aimed at shell users and developers who want reliable, reusable building blocks for programmatic directory changes and completion, and it is available on CPAN with source on GitHub.

Razor2::Client::Agent is the command line front end for Vipul's Razor collaborative spam detection system and powers the razor-check, razor-report, razor-revoke, and razor-admin tools. It handles configuration and logging, parses mbox and single-message input, applies local whitelist and mailing-list checks, finds and contacts Razor servers, and performs actions such as checking messages against the Razor catalogue, reporting spam, revoking reports, and basic administrative tasks like creating the razorhome and registering identities. The module is normally used via the supplied programs rather than called directly and supports backgrounding of reports, automatic identity registration when needed, and taint-safe startup. Return codes indicate match, no match, or error so it can be integrated into mail filtering pipelines. Use this if you need a ready-made command-line client for Razor or a foundation for building Razor-aware mail tools.

Net::Jabber::Bot is a Moo-based Perl module that makes building XMPP/Jabber chat bots straightforward by hiding protocol details and enforcing sensible safety defaults so you can focus on your bot logic. You configure connection and behavior, provide a message handler and an optional background task, and the module takes care of joining rooms, parsing messages, rate limiting, message chunking, hourly caps, presence and roster management, and optional auto-accept of subscriptions. It supports TLS/GTalk style connections, per-forum aliases and trigger strings, sending group or personal messages, changing status and forum subjects, and can auto-split or block oversized messages to avoid flooding servers. Recent releases improved robustness by fixing self-message detection in multiuser chats, repairing silent-reconnect behavior, and correcting message chunking edge cases, along with broader test coverage and stability fixes. Note that a JoinForum call currently lacks explicit join-failure reporting, so you may want to handle that edge case in your code.

Module::Metadata extracts useful information from Perl module files (.pm) so tools and authors can inspect packages without fully loading them. It uses mostly static analysis but will evaluate $VERSION assignments to report accurate versions. You can build an object from a filename, filehandle, or module name and optionally collect and decode POD sections. The module can find modules in @INC, list packages inside a file, check if a package is PAUSE indexable, and produce CPAN META "provides" data or a directory-to-package version map for packaging and release workflows. It also handles common byte order marks and encoding declarations making it practical for use in build systems, CPAN tooling, and other automation that needs reliable module metadata.

Data::HashMap::Shared implements file-backed, type-specialized hash maps in shared memory to enable fast, efficient multiprocess data sharing on Linux. It uses a futex-based read-write lock with a lock-free fast read path and provides lock-free atomic counters for increments and compare-and-swap on integer variants. Multiple typed variants cover integer and string keys and values, and features include optional LRU eviction, per-key TTLs, sharding across multiple files, an arena allocator for string storage, and both keyword and method APIs with batch operations and independent cursors. It also supplies atomic remove-and-return primitives useful for work queues, diagnostic stats, pre-reserve and unlink operations. Requirements and caveats are that it is Linux-only and requires 64-bit Perl, stale-lock recovery depends on a shared PID namespace so cross-container use is not supported, and data may need to be cleared after recovering from a writer crash for safety-critical applications. Overall it is a strong choice when you need a high-performance mmap-backed shared hash for cross-process caching, counters, or work queues on a single Linux host.

File::Raw is a Perl module that speeds up common file tasks by calling the operating system directly rather than using PerlIO, making reads, writes and metadata operations much faster. It gives simple, familiar helpers such as slurp, spew, append and atomic_spew, as well as line-oriented tools like each_line, lines_iter, head and tail, memory-mapped access for zero-copy reading, and fast copy/move/unlink and directory utilities. The module also provides a cached stat facility to cut down on repeated syscalls, predicate-based line filtering, hooks for transforming data on read or write, and platform-tuned optimizations such as sendfile and copyfile for native performance. If you work with large files, do a lot of file metadata checks, need memory-efficient line processing, or want atomic writes, File::Raw is a practical way to get noticeably better IO performance in Perl.

EV::Websockets integrates the fast C library libwebsockets with Perl's EV event loop to give you high-performance WebSocket clients and servers from Perl code. You create a Context tied to an EV loop and then connect to remote WebSocket servers, listen for incoming upgrades, or adopt existing sockets, and handle lifecycle events with simple callbacks for connect, message, close, error, pong and drain. It supports TLS, proxy settings, custom headers, flow control, ping/pong and both text and binary payloads, and exposes connection controls like pause/resume, send queue size and clean shutdown. Benchmarks bundled with the distribution show throughput and latency comparable to other native implementations. Note one operational caveat from the author: a Context with no active listeners or connections can keep an internal idle watcher running and interfere with other EV watchers, so create a listener or connection before calling EV::run or destroy the context when it is not in use.

Text::Stencil is a compact, C-accelerated Perl renderer for turning uniform lists or rows of data into formatted text using a single precompiled row template. You write templates with simple placeholders like {0} or {name} plus a rich set of type and transform specifiers for escaping, formatting, truncation, defaults, date and number formats, pluralization and more, and you can chain transforms with pipes for predictable, fast output. It accepts arrayref or hashref rows, supports negative indices and a row counter, can load templates from files or be cloned with small changes, and offers streaming and callback-based rendering as well as sorting and direct-to-filehandle output for large jobs. The implementation is UTF-8 aware, optimized for high throughput and generally several times faster than general-purpose template engines for table and list rendering, but the object is not safe for concurrent renders from multiple threads so create separate instances per thread or serialize access.

String::Redactable is a small Perl utility for wrapping sensitive text so it will not be accidentally exposed when printed, logged, or serialized. You create an object with String::Redactable->new($secret) and ordinary string operations yield a placeholder such as "<redacted string>", while calling to_str_unsafe returns the original value. The module stores an XOR-obfuscated UTF-8 copy of the value using an object-specific key that is not kept with the object, and it uses overloading plus serializer hooks like TO_JSON and STORABLE_freeze to keep the real contents out of common outputs. This is not intended as a bulletproof security layer against determined attackers, but it is a practical way to avoid accidental leaks of passwords and other secrets in logs and dumps. The source is on GitHub and the module is distributed under the Artistic License 2.0.

Legba provides lightweight, globally shared named state slots that let different packages read and write the same values by name and optionally react to changes with watcher callbacks. You can import per-slot accessor functions into a package or use a functional API to get and set slots, and the module can optimize calls made with literal slot names at compile time for very high performance. Watchers are lazy so they add no overhead unless you register them, and there are numeric indices available for the fastest repeated access when names are dynamic. You also get simple access control with reversible locks and permanent freezes, plus advanced hooks for introspection and custom integrations. For thread safety you can store threads::shared variables in slots and after fork children inherit copy-on-write snapshots of slot values. Note that name-based calls using runtime variables and slots added at runtime do not receive the compile-time optimizations.

Crypt::OpenSSL::AES is a Perl wrapper that lets you use your system OpenSSL library to perform AES encryption and decryption with 128, 192, or 256 bit keys across modes such as ECB, CBC, CFB, CTR and OFB. It provides padding and IV support so you can handle arbitrary-length data in safe modes like CBC or CTR, and it integrates with Crypt::CBC for compatibility while leveraging OpenSSL optimizations and FIPS-capable implementations when requested. The module is intended for developers who want a thin, well-tested interface to OpenSSL rather than a pure-Perl AES implementation, and its documentation warns to always use strong random keys and 16-byte IVs and to avoid ECB for real data. Recent releases improved robustness by adding zero-length data handling, stricter IV and key checks, safer EVP usage and thread-cloning protections, and the maintainers plan to deprecate very old OpenSSL releases soon.

NetBox::Client is a lightweight Perl interface for talking to a NetBox server that wraps the official REST and optional GraphQL APIs into simple methods for retrieving, creating, updating, replacing and deleting NetBox objects. You create a client with a base URL and token and then call retrieve, create, update, replace or delete to work with endpoints such as dcim/cables, with support for field filtering, pagination, timeouts and SSL verification options. GraphQL mode is supported for faster reads but has limitations such as being read-only by design, requiring NetBox’s GraphQL feature to be enabled and offering limited custom field handling. The module requires Perl 5.10 or newer because it uses subroutine signatures. Recent fixes in v0.1.7 improve update behavior by correcting how content and boolean values are passed in update requests.

Object::Proto::Sugar provides a Moo-like declarative syntax layer on top of Object::Proto so you can declare attributes with has, set up inheritance with extends, consume roles with with, declare required methods inside roles, and add before, after and around method modifiers using concise declarative forms. It exports type constants such as Str and ArrayRef and supports familiar attribute features like defaults and builders, lazy evaluation, coercion, triggers, predicates, clearers, named readers and writers, function-style accessors, init_arg aliases and weak references. The syntax compiles down to Object::Proto's XS-backed core for zero runtime overhead and benchmarks in the documentation show it is notably faster than Moo and Mouse while offering optional function-style accessors for maximum performance. Choose this module when you want the ergonomic, declarative API of Moo but need the speed and low overhead of Object::Proto. This is the initial public release.

Data::Hash::Diff::Smart is a Perl module for producing stable, structured differences between complex Perl data structures. It recursively compares nested hashes, arrays, scalars and objects and emits a clear list of change operations such as add, remove or change that can be rendered as readable text or serialized to JSON, YAML or Test2 diagnostics. The engine is configurable with path ignore rules, path-specific comparator callbacks, and several array diffing strategies including index, longest common subsequence or unordered matching with an optional identity key for hash elements. It is designed for use in testing, migrations, synchronization and other tasks that need predictable, customizable diffs. The distribution is provided as-is without warranty and uses an unusual licence arrangement that permits GPL2 for single-user personal use while other users must contact the author for licensing.

Search::Xapian is a Perl XS binding that brings the full-text search power of the Xapian C++ library into Perl, letting you create and open Xapian databases, index documents, build complex queries with the QueryParser, apply stemming and stopword processing, and tune weighting, sorting and value‑range filters in a familiar Perl style. It exposes most Xapian classes and constants so you can run relevance-ranked searches, phrase and proximity queries, wildcard and boolean queries, use match spies and multi-value sorters, and serialize numeric keys for stable sorting. The module maps Xapian C++ exceptions to Perl exception classes and includes measures for safe use with Perl threads, and the documentation points you at the Xapian C++ API for any wrapper gaps. Recent releases improved exception handling and extended compatibility with newer xapian-core versions by generating exception glue at build time so the bindings work cleanly across Xapian 1.4.x and older supported releases.

Net::Ident is a small Perl module that performs RFC1413 ident lookups to ask a remote host which user or identifier is associated with a particular TCP connection. It works synchronously via convenience functions or as a method on FileHandle or Apache connection objects when you opt in, and it also offers an asynchronous object interface for non-blocking or multi-lookup workflows with methods like new, query, ready, and username. Lookups require an ident daemon running on the remote side so results are not guaranteed, and calls support timeouts and return either a simple username or a trio of username, reported OS, and an error message depending on context. The module is useful for logging, access control, or diagnostics when ident information is available, and it intentionally only augments other classes when explicitly requested. Recent maintenance modernized the test suite, improved portability and error handling across platforms, added comprehensive tests for timeout and lookup behaviors, and removed legacy Apache/mod_perl infrastructure for a leaner, more robust release.

IO::Stty is a Perl wrapper around the POSIX stty utility that lets your scripts query and change terminal line settings for a given filehandle. You call IO::Stty::stty on a handle to toggle modes like echo, raw versus cooked input, parity and character size, flow control, special control characters, and baud rates, or to print settings in human or machine-restorable form. It works with standard filehandles and IO::File objects and is handy for tasks such as turning off echo for password prompts, configuring serial ports, or temporarily changing canonical input behavior. The module aims to follow POSIX behavior but is not optimized for speed and will return undef if the handle is not a terminal.

PDF::Sign is a Perl utility for adding standards-compliant digital signatures and RFC3161 timestamps to PDF files so you can produce PAdES-ready signed documents. It provides a small, high-level API to configure credentials, prepare and apply CMS/CAdES signatures and DocTimeStamp timestamps, and to verify signatures found in a PDF, while relying on PDF::API2 or PDF::Builder for PDF manipulation. Cryptographic operations require an external openssl binary and TSA requests use curl if available with a fallback to LWP::UserAgent, and the module uses common Perl components like File::Slurp and MIME::Base64. The initial CPAN release implements CMS/CAdES and RFC3161 support, OpenSSL 1.x and 3.x compatibility, signature verification, process-safe temporary files, and a PDF32000-2008 compliant ByteRange implementation, making it a practical choice if you need programmatic PDF signing and timestamping from Perl and can provide an openssl-capable environment.

Devel::NYTProf is a fast, production‑quality profiler for Perl that gives very detailed, actionable performance data by recording per-line, per-subroutine, per-opcode and per-block timings with sub-microsecond resolution and producing richly annotated, cross-linked HTML reports via the bundled nytprofhtml tool. It is written mainly in C for speed, handles forked processes without extra overhead, can profile compile-time or END-phase activity, captures string eval source so reports remain self-contained, and lets you control profiling at runtime with environment options or DB::enable_profile and DB::disable_profile. The profiler also attributes subroutine times to the specific calling location, supports slow-op and opcode profiling, can emit call event streams for flame graphs and callgrind/KCachegrind, and includes utilities to merge multiple profile files. Known limitations are that it is not thread or multiplicity safe and the subroutine profiler gets confused by Coro so you should disable subs in that case, and older Perl releases expose some accuracy limits. The recent 6.15 release focused on maintenance and infrastructure improvements including an updated flame graph link and CI/test fixes, so users can expect stable behavior and up-to-date tooling. If you need precise, low-overhead profiling to locate hotspots or understand call-site behavior in Perl applications, NYTProf is one of the most capable options available.

Crypt::RIPEMD160 is a simple Perl extension that implements the RIPEMD-160 message digest so you can produce 20-byte binary digests or human readable hex strings from scalars or filehandles. It exposes an easy object-oriented API with new, reset, add, addfile, digest and hexdigest, plus convenience class methods hash and hexhash for one-shot hashing, and a clone method to snapshot mid-computation state when you need to compute multiple digests that share a common prefix. The module is based on the reference C implementation by Antoon Bosselaers and is distributed under the same free license as Perl, making it a good fit for checksums, legacy protocols, or any Perl code that specifically requires the RIPEMD-160 hash. Recent maintenance strengthened portability and safety by fixing 64-bit issues, improving file read error handling, adding the clone method, and zeroing sensitive state on reset and destroy.

Task::Kensho::All is a meta-package that installs every sub-task of Task::Kensho, letting you pull in the full collection of Perl modules recommended by the Enlightened Perl Organisation with a single command such as cpanm Task::Kensho::All. It is useful when you want to provision a development environment or system with the complete Kensho recommendations rather than picking modules one by one. Expect a large set of dependencies and a heavier install than typical individual modules, so only use it if you really want everything. The distribution follows the upstream Task::Kensho releases and was updated to track Task::Kensho 0.41 in 2021.

Pod::Usage extracts a script's embedded POD documentation and prints a standard usage or manpage-style help message from it. Its main entry pod2usage can be called simply or with options to control verbosity: level 0 prints only the SYNOPSIS, level 1 prints SYNOPSIS plus OPTIONS and ARGUMENTS, and level 2 prints the full manual page and will invoke perldoc unless you request the built-in Pod::Text formatter. You can prepend a custom message, choose the output handle or file, set the exit status or request no exit, and select particular sections to show. Sensible defaults for exit status and routing to STDOUT or STDERR follow common Unix conventions so most scripts need only minimal code, and advanced features include custom formatters, supplying the input POD path or a search path, and a small pod2usage command line wrapper. Be aware that on some systems $0 may not reliably point to the script file and calling pod2usage after changing directories can fail unless you provide an explicit input path or use FindBin.

Module::CoreList is a reference library that tells you which modules and which module versions were bundled with each release of Perl, making it easy to check if a feature or library is part of core for a given Perl. You can use the included corelist command line tool or call the API from Perl to ask when a module first appeared, when it was deprecated or removed, whether a specific module version is core, or to search core modules with a regex and compare differences between two releases. The distribution also exposes hashes such as %Module::CoreList::version, ::delta, ::released, ::families, ::deprecated, ::upstream and ::bug_tracker so tools and packagers can inspect versions, release dates, deprecation notes and where to send patches or bug reports. Coverage includes all stable Perl releases since 5.6.0 and development releases since 5.9.0 with earlier legacy data, and the module is maintained by the Perl 5 Porters and distributed under the same license as Perl.

HTTP::Tiny::Mech is a small adapter that makes a WWW::Mechanize instance behave like an HTTP::Tiny user agent so you can plug a mechanize-based backend into code that expects HTTP::Tiny. It is mainly useful when you want mechanize features such as form handling or persistent caching via WWW::Mechanize::Cached while preserving an HTTP::Tiny API, and you can provide a custom mechanize object via the mechua attribute. The module currently implements only get and request and delegates other calls to a native HTTP::Tiny, so it is concise and practical for basic GET/request use cases. It was written as an experimental, lightly documented hack to speed MetaCPAN::API access and works for that purpose, but you should be aware of its limited surface and experimental status.

WWW::Mechanize is a Perl module that gives you a programmable, stateful web browser for automating interactions with websites. It builds on LWP::UserAgent to fetch pages and exposes high level helpers to follow links, fill and submit forms, manage cookies, handle redirects, SSL, proxies and HTTP authentication, and it keeps a navigable history which makes it handy for testing and scraping workflows. The API includes convenience methods like follow_link and submit_form plus options such as autocheck and strict_forms, and it is easy to extend or subclass for custom behavior, but it does not execute JavaScript so pages that rely on client side scripting will need additional tools.

WWW::Mechanize::Cached is a thin wrapper around WWW::Mechanize that transparently caches HTTP responses so you can repeat browselike requests without hammering remote servers. It creates a disk cache by default using the old Cache::Cache family with a one day expiry but lets you supply any cache object that implements get and set, and using CHI is recommended. The module preserves the same Mech API so you call new and get just as usual and then can check is_cached to tell whether a response came from cache, call invalidate_last_request to remove the last entry, and tweak caching policy with options that control whether error responses are cached, whether the Referer is part of the cache key, and how to treat missing, zero or mismatched Content-Length headers. Note that since v1.36 caching is positive by default rather than caching errors, and recent releases added invalidate_last_request and bumped LWP::UserAgent requirements; the author also encourages providing your own CHI cache object for better long term compatibility.