CPANscan

Zabbix7::API is a lightweight Moo-based Perl client for talking to a Zabbix 7.x server over its JSON-RPC API. It provides easy methods for login, logout, raw queries and for fetching Zabbix objects as Perl objects via fetch and fetch_single while delegating class-specific behavior to Zabbix7::API::* wrappers. HTTP requests are made with LWP::UserAgent and logging goes through Log::Any, and SSL is supported when LWP::Protocol::https is installed. The module favors explicit create, update and exists operations and can optionally re-pull server-generated values after writes via pull_after_push_mode to simplify provisioning workflows. Not every Zabbix class is wrapped and the author notes the primary focus has been on reading hosts rather than creating objects, but recent releases added support for Event and Problems.

Log::Fmt::XS is a lightweight performance-focused companion to Log::Fmt that swaps in XS (C) components to speed up emitting logfmt-formatted logs; it acts as a subclass of Log::Fmt so you can expect the same API and behavior while gaining lower overhead and higher throughput for structured logging. If you already use Log::Fmt and are looking to reduce logging latency or CPU cost in high-volume applications, this module is relevant. The distribution carries no fixed promise about future Perl version requirements and this 0.001 release is the initial published version by Rob Mueller.

Log::Dispatchouli is a lightweight convenience wrapper around Log::Dispatch that makes adding logging to a Perl program easy and configurable without deep knowledge of syslog facilities or log categories. It can send messages to syslog, stdout, stderr, a rotating file, or an in-memory array for testing, and it uses String::Flogger so you can log plain strings, sprintf-style arrayrefs, data structures, or lazily evaluated coderefs. The API centers on simple methods like log, log_debug and log_fatal plus log_event for structured, logfmt-style key=value output, and it supports global and per-message prefixes, proxy loggers for localized context, and test-friendly loggers that capture events. You can toggle debug and muted modes at runtime, control whether logging failures are fatal, and pull the underlying Log::Dispatch object if needed. A few features are noted as experimental or deprecated, and the structured-event expansion is convenient but not meant to be a full serialization system. If you want straightforward, flexible logging with minimal ceremony and good support for structured messages and testing, this module is a practical choice.

Geo::Coder::OpenCage is a simple Perl client for the OpenCage Geocoding API that makes it easy to turn place names and addresses into latitude and longitude and to perform reverse lookups from coordinates. It requires an OpenCage API key and provides geocode and reverse_geocode methods that return parsed Perl data structures and accept common options like language, result limit, and country hint. The module uses HTTP::Tiny by default but lets you supply your own user agent while always setting a Geo::Coder::OpenCage versioned User-Agent header. Responses are returned as Perl data and not JSONP, so you only need to check the API status code to handle errors and rate limits. This is a practical choice for Perl projects that need reliable geocoding without dealing directly with raw HTTP or JSON parsing.

MCE is a Perl framework that makes it easy to run code in parallel across all available CPU cores by spawning a reusable pool of worker processes or threads and feeding them chunks of input in a bank teller style. It provides a low level core API for full control and a set of higher level models such as Loop, Flow, Map, Grep, Step and Stream that wrap common parallel patterns so you can parallelize file processing, numeric loops, maps and filters with minimal changes to your code. The distribution also includes utilities for mutexes, signaling, inter-worker channels and queues plus lightweight sugar in MCE::Candy and a child-style API for older Perls, so you can choose synchronization and communication models that suit your task. MCE is particularly useful for processing very large logs or compute-bound workloads, though the author notes file-based performance can degrade on Windows past a few workers. It requires Perl 5.8 or newer and the source and examples are available on GitHub.

App::Chit is a lightweight command line chat client for AI services that gives you a quick conversational interface from your shell. It builds on AI::Chat and keeps conversation context tied to your current working directory so you can maintain separate chats in different folders. You can initialize sessions, send messages, adjust the model temperature to change how creative responses are, set an assistant role to shape replies, and query which chat location is active. The initial release documents environment variable usage and fixes packaging by adding a missing utf8::all dependency. It is aimed at interactive use and simple scripting from the terminal and issues can be reported on the project's GitHub.

Sidef is a modern scripting language engine you can embed in Perl to parse, compile, optimize and execute Sidef code from your Perl programs, or to compile Sidef into Perl for inspection or high-performance execution. It blends object oriented and functional idioms, offers native arbitrary precision integers, rationals, floats and complex numbers, supports multiple dispatch, pattern matching, lazy evaluation and a full class system, and gives direct access to CPAN modules so you can reuse Perl libraries without glue code. The Sidef module exposes a simple API for running one‑liners, REPL sessions, AST parsing and optimization, and for caching compiled output with an optional DBM-backed cache to speed repeated runs. To build and use it you need the GMP/MPFR/MPC C libraries for numeric support and optionally DB_File or GDBM_File for caching, and you should note the bundled cache is not thread safe and Unicode behavior follows Perl's implementation. If you want a Ruby/Raku-like language that runs on the Perl ecosystem and can be embedded, instrumented and compiled back to Perl, Sidef provides a polished, developer friendly toolset to do that.

DBD::Unify is a DBI driver that lets Perl programs talk to Unify DataServer databases using the familiar DBI prepare/execute/fetch API, so you can run queries, do transactional work, and fetch results into arrays or hashes from Perl. It handles Unify native types sensibly by returning integers as integers and numeric and date types as strings with numeric context preserved where appropriate. Connection options are passed in the DSN and the driver provides useful knobs such as uni_unicode to auto-decode UTF-8, uni_scanlevel to set transaction scan level, and uni_verbose or dbd_verbose for driver-level tracing. For schema discovery it offers a high-level db_dict function that returns a cached, detailed dictionary of accessible schemas, tables, columns and links so introspection and tooling are straightforward. There are some practical limitations to be aware of such as incomplete AutoCommit support, commit and rollback closing open cursors, and known issues with opening multiple different Unify database instances concurrently, but the module is actively maintained and the recent 0.96 release notes show testing with modern Perls and Unify DataServer 9.1. If you need to integrate Perl with Unify databases and want DBI compatibility plus schema introspection and Unicode options, DBD::Unify is the driver to use.

ClarID::Tools implements the ClarID specification, a convention for creating compact, human-readable identifiers intended to make biomedical metadata integration simpler and more consistent. The distribution includes a command-line tool (clarid-tools) and online documentation and examples so you can generate, parse and validate ClarID identifiers as part of metadata workflows. The module was written by Manuel Rueda and the authors request that users cite the submitted 2025 ClarID paper when publishing work that uses these tools. See the bundled LICENSE and project documentation for full usage details.

YAML::Syck is a fast, lightweight Perl binding to the libsyck library that converts Perl data structures to and from YAML using simple Load and Dump functions, plus file and encoding-aware variants for byte or UTF-8 input and output. It exposes a set of flags to control behavior such as implicit typing, Unicode and binary handling, whether to evaluate or emit Perl code, and how to treat blessed objects, so you can tune interoperability with other Syck/YAML implementations like Ruby’s. Error handling can differ from some other YAML modules so you may want to wrap calls in eval, and there are known limits such as a maximum dump depth, incomplete support for dumping Glob/IO values, and possible issues dumping into tied or magic variables. The module implements YAML 1.0, bundles its own libsyck sources, and has been only semi-actively maintained since 2007, but it remains useful when you need Syck-style compatibility or encounter YAML edge cases that other parsers do not handle; if you need full YAML 1.1 compliance or more active maintenance consider YAML::XS or another format.

Array::Objectify is a small utility that makes array elements easier to work with by "objectifying" structured data so hashrefs inside an array can be accessed with arrow notation rather than explicit key lookups. You can create an object via Array::Objectify->new or tie a real @array with Array::Objectify::Tie and then push, pop and inspect the array as usual while nested hashrefs and nested arrays behave like lightweight objects for convenient property-style access. The module is useful when you want cleaner, more readable access to nested data without writing full classes and it is deliberately minimal and easy to drop into existing code. Recent development increased test coverage to 100 percent, improving confidence in its behavior.

Shannon::Entropy::XS is a small Perl module that quickly computes the Shannon entropy of a string, returning a numeric measure of its information content or randomness via a simple entropy($string) call. It is a drop-in, high-performance alternative to the pure-Perl Shannon::Entropy module and uses an XS (C) backend to achieve much faster throughput, making it useful when you need to assess password strength, estimate compressibility, or scan large datasets for low- or high-entropy values. The API is minimal and easy to use and the module is available on CPAN under the Artistic License 2.0.

Daje::Plugin::Users is a lightweight Mojolicious plugin that provides a ready-made layer for user-related functionality in web applications, bundling route definitions, helper routines and database migration support by delegating to Daje::Plugin::Users::Routes, Daje::Plugin::Users::Helpers and Daje::Database::Migrator. You enable it with a single call, plugin 'Users' in Mojolicious::Lite or $self->plugin('Users') in a full Mojolicious app, and it requires Perl v5.42 and Mojo::Base. The module is intended to simplify adding common user management features to Daje-based projects and this listing represents the original 0.01 release.

Shannon::Entropy is a tiny Perl module that computes the Shannon entropy of an input string and returns a numeric value in bits that quantifies its information content or randomness. It exports a single entropy function you call with a string and receive a floating point score, for example entropy('1223334444') or entropy('0123456789abcdef') which yields 4 for 16 unique symbols. That makes it handy for quick checks of password strength, estimating compressibility, or simple script-level analysis of symbol distributions. The module is minimal and easy to drop into existing Perl code, is maintained by Robert Acock, and is distributed under the Artistic License 2.0 with bug reports handled through CPAN.

Number::Iterator is a small, easy-to-use object that represents a numeric stepper so you can advance or retreat a value by a configurable interval. You create an iterator with an interval and then move it with overloaded increment and decrement operators or with iterate and deiterate methods, and you can read its current value and interval. If you need custom behavior you can supply iterate and deiterate callbacks to implement additive, multiplicative, or any other update logic. This module is handy when you want a reusable, encapsulated way to walk through numeric sequences or maintain a stateful counter in your code.

Test2::Harness::UI provides a browser-based interface for viewing and inspecting yath test logs, letting you explore test results and details without digging through raw output. The easiest way to try it is with the command "yath ui path/to/logfile", which creates a temporary PostgreSQL database, loads your log, and starts a local web server with starman so you can interactively browse the data. The project is still in early development and may have bugs or missing features. Source is available on GitHub and the module is maintained by Chad Granum.

Atomic::Pipe gives you a reliable way to send whole messages through a POSIX pipe from multiple writers without their output getting mangled together, by breaking messages into atomic-sized chunks and reassembling them on the reader so the reader always sees complete messages. It is aimed at POSIX systems and supports creating pipe pairs, connecting to FIFOs or existing filehandles, non-blocking writers, and helpers for tuning pipe size on platforms that support it. There is a special mixed-data mode that lets you intermix ordinary stdout/stderr output with tagged atomic messages so the reader can extract bursts or complete messages from noisy output. Message order across different processes or threads is not guaranteed, but ordering is preserved per writer, and recent maintenance continues to improve robustness across platforms including a 2026 fix for test lockups on systems with 16k pipe buffers such as Omnios.

Cookie is a Perl object for creating and manipulating HTTP cookies in an RFC6265-compliant way, suitable for both simple session cookies and fully featured Set-Cookie headers. It provides easy setters and getters for name, value, domain, path, expires or max-age, secure, httpOnly and SameSite, integrates with DateTime for expiry handling, and stringifies to a proper header so you can print or send it directly. The module supports signing and encryption of cookie values for integrity and confidentiality, offers options for algorithm, key and IV, and exposes decrypt and is_valid helpers; these features rely on CryptX/Crypt::Cipher and related modules for performance. Cookie objects can be compared, converted to hash form for JSON, and managed alongside Cookie::Jar for server-side workflows. Methods return undef and set an error rather than dying on failure, and there are options to enforce strict name rules though SameSite values are not validated by the module. This module is useful for web developers who need robust, standards-aware cookie handling with optional cryptographic protection.

Mail::SPF is an object‑oriented Perl library that implements the Sender Policy Framework so you can check whether a given IP address is authorized to send mail for a particular sender domain. It provides Server, Request and Result objects to build and run SPF checks, perform the necessary DNS lookups, and produce standard results and Received‑SPF headers with human and authority explanations. The module aims to fully follow the SPF specification (RFC 7208) and is suitable as a production component or as a reference implementation; it supports macro expansion, configurable lookup behavior and limits to avoid abusive DNS lookups, handles IPv4 and IPv6 cases, and includes caching and other robustness fixes. Recent maintenance through 2026 added DNS edge case fixes, caching and IPv6 handling improvements and a tweak to avoid checking multiple CNAMEs when an include uses a macro, and it defaults to querying TXT records for practical compatibility.

Task::Map::Tube::Bundle is a lightweight installer package that gathers all Map::Tube::* city map modules so you can add the entire collection to your Perl environment with a single command rather than installing each map individually. It complements the Map::Tube family by declaring and installing every supported map module, making it useful for developers or hobbyists who want ready access to multiple transit or city map datasets without managing many separate dependencies. Install it via your CPAN client, for example cpanm Task::Map::Tube::Bundle. The recent v1.0.7 release added the Sydney map and switched to dotted-decimal versioning.

Map::Tube::CLI is a simple command‑line front end for the Map::Tube family that makes it easy to query metro maps from your terminal, find shortest or preferred routes between stations, list lines and generate line or full‑map PNG images. The distribution supplies the map-tube script and accepts intuitive options like --map, --start, --end, --line, --preferred, --generate_map, --list_lines and others so you can print text routes, produce line mappings and notes, or dump a graphical map for many world cities. Map names are case insensitive by default and maps are provided separately (Task::Map::Tube::Bundle is a convenient installer). The project is actively maintained and the latest 0.84 release added several new city maps and tightened file writing to the current directory to reduce accidental output.

Ascii::Text::Chandra is a small Perl utility that lets you display and interactively render ASCII text inside a Chandra webview. It exposes a simple run method that opens a Chandra window with a minimal form for entering and previewing ASCII output, so it is handy for quickly demoing or embedding ASCII-rendered text in Chandra-based interfaces. The module is intentionally lightweight and focused on interactive presentation rather than complex text transformation. This is the initial 0.01 release.

Shared::Simple is a lightweight Perl module that gives multiple processes a simple named key-value store using POSIX shared memory. It lets you create or attach to a shared segment and store short string values under string keys with simple put and get operations. Access is serialized with a process-shared POSIX mutex so concurrent readers and writers stay consistent and on Linux the mutex is configured as robust to recover from a dead owner. The API exposes easy ways to count entries and take a snapshot of all pairs for local use. This is ideal for sharing small bits of state such as flags, counters, or tiny messages between a parent and worker processes or between cooperating programs. There are a few important constraints to be aware of: values are limited to 32 bytes, keys and values must be defined non-empty strings, the EXCLUSIVE creation mode unlinks and recreates the segment so it must be used only once at startup and never concurrently, and the shared memory persists until explicitly unlinked outside Perl. If you need a compact, POSIX-backed mechanism for tiny cross-process data, Shared::Simple is a straightforward choice.

Ascii::Text generates stylized ASCII art text in a variety of fonts and colors and makes it easy to print banners and headings to a terminal or file. You create an Ascii::Text object with options like font, alignment, left padding and max width which by default uses Term::Size::ReadKey to fit your terminal, then call render to print or pass an array reference to capture the output lines, or use stringify to get the ASCII block as a string. The module also supports coloring via ANSI codes, custom color maps, and a configurable filehandle so you can direct output to files or other streams. The interface is simple and focused on presentation rather than layout logic, and the distribution is an initial release with a basic but useful feature set.

Tags::Output::LibXML is a small Perl formatter that turns a Tags-style structure into a well formed XML document using XML::LibXML. It is designed specifically for XML output and gives you simple methods to add tag/data items, inspect currently open tags, finalize by closing any open tags, flush the generated XML or reset internal state. You can set the XML header encoding (default UTF-8) and version (default 1.1), supply callbacks to preprocess text, CDATA or raw data before emission, and provide an output handler glob for direct printing. A couple of options are marked as TODO and not implemented, but otherwise it provides a straightforward bridge from Tags::Output structures to serialized XML, making it useful when you need programmatic, callback-friendly XML generation built on XML::LibXML.

PDF::Builder is a full-featured Perl library for programmatically creating, editing, and annotating PDF files. It gives you simple object methods to make new documents or open existing ones, add or import pages, draw text and graphics, embed fonts (core, TrueType/OpenType, Type1 and bitmap), place images (JPEG, PNG, TIFF, GIF, SVG), build colorspaces and spot colors, manage metadata, outlines, page labels and viewer preferences, and create form XObjects, patterns and barcodes. The API is familiar to users of PDF::API2 and includes convenience helpers for fonts and images, while optional companion libraries can greatly speed TIFF and PNG processing. Be aware that PDFs produced are mostly PDF 1.4 compliant, that some features such as CJK font support and rendering order when mixing text and graphics have caveats, and that methods like saveas or to_string finalize the document object so it cannot be used further. Full documentation and examples are on CPAN and the project repository on GitHub.

App::Physics::ParticleMotion is a Perl implementation of the tk-motion tool that lets you quickly build and visualize particle simulations defined by any number of correlated second‑order ordinary differential equations. You describe particles, constants and acceleration formulas in a simple INI-style config file and the module uses a fourth‑order Runge‑Kutta integrator together with Math::Symbolic to evaluate the expressions, Tk for a real-time display and Math::Project3D to project 3D data onto a viewing plane. It supports up to three spatial dimensions, configurable time scaling, numerical tolerance, tracing of particle paths and optional data output, so it is handy for students, educators or developers who want an easy way to prototype and watch the numeric solution of coupled oscillators and similar systems. Configuration is handled by Config::Tiny and the packaged tk-motion.pl script lets you run simulations from the command line. Recent maintenance fixed a syntax problem that had kept some examples from running, and performance and memory use naturally depend on CPU speed and trace settings.

Physics::Ellipsometry::VASE is a Perl helper for fitting custom optical models to variable angle spectroscopic ellipsometry data using PDL. It wraps PDL::Fit::LM to perform Levenberg-Marquardt optimization and hides the fiddly mapping between a simple user model interface and the lmfit calling convention, automatically computing numerical Jacobians by finite differences. You feed it a whitespace-delimited data file of wavelength, angle, Psi and Delta and provide a model subroutine that accepts a PDL piddle of parameters and a piddle of input points and returns a flattened piddle of predicted Psi and Delta values. The constructor accepts a layers option (default 1) and you call fit with initial parameter guesses given as a PDL piddle to obtain fitted parameter piddles. It is useful for researchers or engineers who work with ellipsometry and already use Perl and PDL, and it depends on PDL, PDL::Fit::LM and PDL::NiceSlice.

Indent is a tiny object-oriented utility for building and managing indentation strings when generating nested or pretty-printed text. You create an Indent object with an optional starting indent and a step value called next_indent, then call add to increase the current indent, remove to decrease it, get to retrieve the current indentation string, and reset to clear or set it to a specific value. Defaults are an empty starting indent and a tab for the step. The module is useful for formatting code, logs, or structured output and fits into a family of related Indent modules for block, data, string, and word handling. It validates parameters and reports errors for invalid inputs and is distributed under the BSD 2-Clause license.

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.