CPANscan

Algorithm::Classifier::IsolationForest is a Perl module for unsupervised anomaly detection that implements the original Isolation Forest and the Extended Isolation Forest variants to find outliers in multivariate numeric data. You train it with an array of numeric vectors and it builds an ensemble of random trees where points that are isolated quickly get high anomaly scores between 0 and 1, while typical points score below about 0.5. The module offers configurable parameters such as number of trees, sample size, random seed for reproducibility, mode (axis-aligned or oblique hyperplane splits), and an optional contamination setting that learns a score threshold for flagging anomalies. Common methods include fit to train the model, score_samples to get per-point anomaly scores, predict to return 0/1 labels, path_lengths for inspection, and JSON save/load for persisting models. Extended mode removes the axis-aligned bias of classic Isolation Forest and often performs better on elongated or multi-modal data, making this a practical choice for detecting anomalies in many real world datasets.

HTML::Gumbo is a Perl wrapper around Google's Gumbo C library that brings a fast, robust, and HTML5‑conformant parser to Perl programs. It can parse HTML into a rebuilt string, drive a callback-based event stream similar to HTML::Parser, or produce an HTML::Element-based tree though the tree output is still experimental. The module accepts different input types and encoding hints so you can feed it decoded Perl strings, raw octets, or trusted UTF-8, and it supports fragment or full-document parsing. Some advanced features of the underlying C library are not exposed or fully implemented here, including source location pointers, full encoding sniffing and nested browsing context handling, and SVG/MATHML fragment testing, and the tree formatter and fragment enclosing tag handling are noted as alpha, but for most uses this module provides a simple way to use a production-tested HTML5 parser from Perl.

Alien::SNMP is an Alien::Base style Perl distribution that downloads, builds and installs the Net-SNMP C library and its Perl bindings so your Perl SNMP code can run on systems that lack libnetsnmp. It exposes simple methods like bin_dir to locate Net-SNMP command line tools and cflags and libs to provide the compiler and linker flags you need, and it is intended to satisfy the dependency for the SNMP.pm extension. The packaged build is tailored for use as a lightweight library and developer kit by enabling IPv6, Perl modules and Blumenthal AES while intentionally disabling the SNMP agent, manuals, scripts, MIBs and embedded Perl.

Alien::LibGumbo is a helper module that installs the libgumbo C HTML parsing library on your system so Perl bindings like HTML::Gumbo can find and use it. It does not itself parse HTML or provide parsing APIs but instead builds and provides the native library at install time. This distribution uses the actively maintained fork of libgumbo by Grigory Kirillov rather than the now-archived Google original, so you get a recent upstream release. If your goal is to parse HTML in Perl, reach for HTML::Gumbo; use Alien::LibGumbo when you need the underlying native library made available to Perl modules.

Data::Intern::Shared is a Linux-only, 64-bit Perl module that provides a shared-memory string interning table so multiple processes can agree on compact uint32 ids for arbitrary byte strings and map those ids back to the original bytes. It stores each distinct string once in an append-only arena and returns a dense id for lookups, which makes it efficient to store string keys as small integers in other shared structures such as Data::SortedSet::Shared. Lookups are O(1) via an open-addressed hash and mutation is protected by a futex-based write-preferring rwlock with dead-process recovery, so many processes can intern and query concurrently; the table supports anonymous mappings, file-backed maps, and transferable memfds. Interning is permanent and ids never change, capacities for number of strings and total string bytes are fixed at construction, keys are compared by raw bytes so wide strings must be encoded beforehand, and the empty string and embedded NULs are supported. The module is designed to be crash-consistent up to the last completed intern operation but does not detect PID reuse, and the author warns not to share writable mappings with untrusted processes. Initial release 0.01 published 2026-06-23.

Params::Get provides a single helper, get_params, that normalises a Perl subroutine's arguments into a single hash reference so your public methods can accept and handle any common calling style without repeating parsing code. You can pass it @_ or a reference to @_ and it will accept a lone hashref, named key/value pairs, a single scalar that becomes the value for a default key, an arrayref shorthand, a mandatory positional value followed by an options hashref, scalarrefs, blessed objects or coderefs, and it returns a consistent hashref for validation or further processing. The $default argument may be a string, undef, or, as of the recent 0.15 release, an arrayref of positional key names to map positional arguments into named fields. The module reports errors clearly when the caller uses an unsupported convention and documents a few corner cases such as the ambiguity of a single empty arrayref and the fast-path where a lone hashref bypasses default-key wrapping. The 0.15 update also fixed caller-variable mutation bugs and removed a problematic Devel::Confess dependency in favor of Carp::confess.

Aion::Format is a compact toolbox of text and number formatting helpers for Perl that makes command line output, logging and light text processing easier. It provides color-aware printing and logging helpers, human-friendly size, interval and rounding formats, number formatting and radix conversion utilities, Roman numeral conversion, Russian transliteration, and small wrappers for Data::Printer plus safe STDOUT/STDERR capture helpers. It also includes a simple template-to-regex helper aimed at extracting fields from HTML and convenience routines to convert Perl string literals. If you write scripts that need prettier terminal output, readable numeric units, quick data extraction from HTML, or simple transliteration and formatting utilities this module is a practical, lightweight choice. Recent tweaks include safer handling of STDOUT/STDERR in the capture helpers to avoid leaks on exceptions and a small configuration change to use Aion::Env::Etc.

Aion::Emitter is a lightweight, annotation-driven event dispatcher that calls listener methods based on the class of an event object. You create a plain event object, register listener methods by annotating them with #@listen, and then call emit with the event and an optional qualifier key to invoke matching listeners. Listeners are represented by single long-lived objects, and handler methods typically mutate the event object so the emitter can inspect results after dispatch. The optional key lets you scope delivery to a subset of handlers when you need targeted notifications, for example per controller, and may contain letters, numbers, underscores, dashes, colons and periods. Use Aion::Emitter when you want a simple publish/subscribe pattern integrated with Aion that relies on source annotations rather than manual wiring.

CGI::Session is a mature Perl module that gives CGI programs a simple way to persist user-specific data across HTTP requests by creating, loading and storing session objects tied to cookies or query parameters. It uses a modular backend system so you can store sessions in plain files, BerkeleyDB, MySQL, SQLite or other drivers and choose different serializers and ID generators to match your needs. You interact with a session by getting and setting named parameters, expiring whole sessions or individual keys, deleting sessions, and emitting the correct cookie header with header(). There are helpers to copy query parameters into a session and to load them back into a CGI object and a find callback useful for batch housekeeping such as purging old sessions. The module recommends calling flush() explicitly because automatic flushing can be unreliable and also documents UTF8 considerations for handling non-ASCII data. Overall CGI::Session is a practical, configurable solution for adding server-side session state to classic CGI applications.

Term::CLI is a compact framework for building interactive command‑line programs in Perl that wraps Term::ReadLine to provide a ready REPL with command dispatch, argument parsing, tab completion, history, paging and signal-safe cleanup. You describe commands as Term::CLI::Command objects and supply callbacks to handle parsed options and arguments while the library handles prompts, word splitting, quoting and escaping for completion, reading and writing a history file, and optional external pagers. It works with Term::ReadLine::Gnu or Term::ReadLine::Perl and exposes hooks to customize the split function, quote characters, word delimiters, pager, prompt and history behavior, plus a cleanup callback for graceful exit. Note that its default I/O handle behavior differs from some readline implementations so you may want to set filehandles explicitly to ensure UTF-8 I/O behaves as expected. If you need a small, extensible foundation for building interactive shells with tab completion and history support, Term::CLI provides a well-documented, example-driven starting point.

Config::INI::RefVars is a Perl INI file reader that adds powerful variable interpolation and Make-like assignment operators so you can reference other INI variables, environment values, or Perl Config entries inside your config files. It supports lazy and immediate expansion via operators like = and :=, conditional defaults ?= and ??=, appending and prepending (.=, +=, .>=, +>=), includes, line continuation, and user-defined functions with a built-in function dispatcher, and it can copy a special tocopy section into every section or treat those values as globals. You feed it a filename, string, or array and it returns a hashref of sections to key/value pairs, and you can customize behavior with options for custom builtins, a section separator, comment handling, and variable name validation. The parser reports syntax errors, recursive references, unknown functions and similar problems by throwing exceptions, and a failed parse may leave the object unusable so callers should recreate the object after errors.

File::FStore is a toolkit for managing a hash-based, final-state file repository in the Fellig format where files are treated as immutable and tracked by cryptographic digests and a small set of integrity-focused metadata. It lets you create and open stores, query files by digests, properties or identifiers, run transactions, and perform maintenance tasks like scanning, scrubbing and fixes to repair or rebuild links and metadata. The module integrates with Data::TagDB for richer metadata, File::Information for file analysis and Data::URIID for extraction, and it exposes helpers to add new digests and to run migrations and exports, although some helper methods are marked deprecated and the add_digest API is experimental. Use File::FStore when you need a durable, integrity-checked file store with digest-based lookup and basic lifecycle tools, and use companion modules if you require more extensive tagging or metadata features.

Zuzu is a small Perl helper for running ZuzuScript from Perl programs. It offers zuzu_eval to parse and execute a script string and zuzu_evalfile to load and run a UTF-8 script file, with both returning the evaluation result and accepting runtime options such as module denial and additional library paths for sandboxing or extending the environment. Use it when you need quick one-shot execution of ZuzuScript, lightweight integration into Perl tools, or simple testing of Zuzu code.

SPVM::Go brings the Go language style of concurrency to SPVM, providing a Go class that lets you spawn lightweight goroutines, create buffered or unbuffered channels, perform select-style multiplexing, and coordinate work with wait groups, timers and contexts. It exposes scheduler primitives to yield and to block on IO with optional timeouts, plus sleep helpers and signal utilities, and ships companion modules such as Go::Channel, Go::Select, Go::Sync::WaitGroup, Go::Time and Go::Context. The implementation builds on coroutines so you can use familiar Go patterns inside SPVM programs, and note that some scheduler operations must be invoked from the main thread. Development and examples are on the project GitHub and runtime debugging can be toggled with the SPVM_GO_DEBUG environment variable.

Map::Tube::Generic is a lightweight wrapper that lets you pick a metro network at runtime and then find shortest routes between stations using whatever concrete Map::Tube implementation you choose. You construct it by naming a location or by supplying an existing map object, and most calls are simply delegated to the underlying map module so you get the network features without hardcoding a specific implementation. The module also provides utilities to discover available map modules across namespaces and to check which features a chosen map supports, but XML and JSON map input are not yet implemented. Errors are raised if a requested map module cannot be found or loaded. This is the first public release (version 0.1.0) and is intended for cases where you want runtime flexibility in selecting or enumerating metro network backends.

CVSS is a Perl module for calculating Common Vulnerability Scoring System scores and converting between representations such as vector strings, JSON and XML. It supports CVSS versions 2.0, 3.0, 3.1 and 4.0 and offers both object oriented and simple functional interfaces so you can build metrics programmatically, parse an existing vector string, or generate a vector string from metric parameters. From a CVSS object you can obtain base, temporal and environmental scores, the qualitative severity label and the individual metric values, and the module includes convenience helpers like decode_cvss, encode_cvss and cvss_to_xml. The implementation follows the official FIRST CVSS specifications, is open source, and is listed by FIRST as a community CVSS calculator library.

EV::Websockets is a Perl interface that lets EV-based applications use the native C libwebsockets library to run WebSocket clients and servers without blocking the EV loop. It gives you a Context to manage connections and listeners, high-level connect/listen/adopt calls, and simple callbacks for connect, message, close, error, pong and drain events so you can integrate WebSockets into existing event-driven programs. The module supports TLS, proxies, per-connection headers, connect timeouts, streaming fragmented sends, backpressure control via send_queue_size and on_drain, and a per-connection stash for metadata, and it can adopt sockets from PSGI servers like Feersum. Performance-focused by design, it uses libwebsockets for low latency and high throughput and includes examples and benchmarks. API calls that mutate a gone connection will croak while lifecycle controls like close or pause_recv are safe no-ops in cleanup paths. Recent releases fixed loop-stalling and TLS context issues and a 0.09 update ensures compressed frames using permessage-deflate are correctly reassembled into single messages.

SimpleFlow is a tiny pure-Perl workflow manager and logger that helps make long, error-prone shell pipelines easier to run, debug and reproduce. It exports two helpers, task and say2, where task runs a single shell command while timing it, capturing stdout and stderr, recording exit code and signal, validating declared input and output files, logging a structured record and returning a detailed result hash, and say2 prints a message both to standard output and to a given log filehandle prefixed with the calling file and line number. Tasks are restartable because SimpleFlow will skip a step when all declared outputs already exist, and you can force reruns with an overwrite flag or inspect the plan with a dry run. By default task dies on a nonzero exit or missing outputs but you can disable that to handle failures yourself. SimpleFlow runs commands via Perl system calls so making the commands portable across operating systems is your responsibility, while the module itself includes sensible cross-platform handling for exit decoding and terminal color. It is lightweight, easy to drop into existing Perl scripts, and aimed at improving reproducibility and traceability of shell-based workflows.

Tk::ListEntry is a lightweight Tk widget that acts like BrowseEntry but without a separate button, so clicking the text field itself pops up a selectable list. It supports all standard Entry options and adds convenient features such as a -command callback fired on Return or item selection, an optional -filter mode to live-filter list entries, a -motionselect flag to pick items on hover, and the familiar -popdirection and -values behavior from PopList. The module exposes Entry and List subwidgets and a validate method to check whether the current text is one of the allowed values. Recent updates simplified event handling by using Enter and Leave to relax the global grab and removed prior workarounds, improving the reliability of the pop-up interaction.

CPAN::Maker is a command line tool that helps Perl authors build a CPAN distribution from their project by reading a YAML "buildspec" and producing a Makefile.PL and a packaged tarball, typically by invoking a supplied bash helper called make-cpan-dist. It can scan your modules and scripts for dependencies, include executables and extra files, populate META information and resources, and validate a buildspec against a JSON Schema so it is useful in repeatable builds and CI pipelines. The tool normalizes common buildspec key styles and can auto-generate dependency lists or accept cpanfile-style inputs, and it honors environment flags such as PRESERVE_MAKEFILE to keep the generated Makefile.PL, SKIP_TESTS to avoid running tests, and DEBUG for verbose diagnostics. If you want an automated, configurable way to assemble a CPAN release from a project tree without hand-editing Makefile.PL, CPAN::Maker provides that workflow. In the recent 1.9.3 release the script was made friendlier to embedding and testing by returning from its main path instead of forcibly exiting, and a bug in man-page link generation was fixed.

CLI::Simple is a focused, object-oriented base class for building Perl command line tools that need options, subcommands, and positional arguments. It is built around the modulino pattern so a module can also be run as a script, it auto-creates getter/setter accessors for options, integrates with Log::Log4perl for logging, and provides handy internal commands to generate bash completion, dump a YAML manifest of your interface, scaffold role stubs, and migrate legacy scripts. For larger projects it supports a role-based workflow declared in a YAML manifest where each command is implemented as a Role::Tiny role, letting you move from a single-module script to composable roles incrementally. The module deliberately keeps dependencies small and does not impose a heavyweight framework, making it a good fit for internal tools, admin scripts, and any CLI where you want just enough structure without complexity. Recent 2.0.x work introduced the role and scaffolding features and the 2.0.7 release includes small packaging tweaks such as changing the default modulino install path to the system site bin.

Font::FreeType is a Perl wrapper around the FreeType2 library that makes it easy to load font files, inspect font metrics, render glyphs to bitmaps, and extract scalable outlines for use in images, SVG, PDF or layout tools. You work with a small, Perl-friendly API: create a Font::FreeType object, open a face from a font file, set size and resolution, then fetch glyphs by character, code point or name and get bitmap data, outline paths and metric values. The module exposes FreeType load flags and adds higher-level helpers such as iterating glyphs and accessing name tables, character maps and bounding boxes. It requires the underlying FreeType C library and was originally noted as beta, but recent maintenance through 2020 fixed compatibility and loading issues and added convenience features, so it is a practical choice when you need programmatic font access or glyph rendering from Perl.

Zonemaster::Backend is the server-side component for running Zonemaster DNS tests remotely and asynchronously via an RPC API. It lets you decouple test execution from client code so you can submit zone checks, let the backend run them, and retrieve results later, which makes it a good fit for web front ends, automation pipelines, or shared testing services that need to scale or run tests in the background. The module is provided as free software under a 2-clause BSD license.

Zonemaster::LDNS is a Perl binding to the ldns DNS library that gives Perl programs a full-featured resolver for sending and receiving DNS queries, performing zone transfers, and inspecting packets. It exposes a simple object you can construct from system or explicit nameserver addresses and use to run queries by name, type and class, perform reverse lookups, collect AXFR records via a callback, and load zone files, while offering control over common resolver options such as recursion, DNSSEC, EDNS size, retries, timeouts, source IP and port. It also provides utility functions for IDN conversion when libidn2 was present at build time and query helpers that return Zonemaster::LDNS::Packet objects or plain address/name lists, and it will throw exceptions on error so callers can handle failures. The module is maintained as part of the Zonemaster project, is BSD 2‑clause licensed, and the recent 5.1.0 release added support for Extended DNS Errors and updated the bundled ldns to 1.9.2.

Zonemaster::Engine is the core Perl component of the Zonemaster DNS test system that automates a wide set of checks to assess the quality and correctness of a DNS zone. It exposes a simple API for running all tests for a zone or individual test modules and methods, and returns structured log entries while letting you control profiles, logging, caching and recursive lookups. The module also offers helpers for ASN lookups, synthetic test setups such as fake delegation and fake DS records, and utilities to preload or save caches and reset internal state so it integrates well into tooling and automated workflows. If you operate DNS zones, run a registry or build DNS validation tools this is the programmatic engine you would use to run Zonemaster tests. Note that the recent v9.0.0 release removed some deprecated profile properties and changed the format for saved packet serialization and added independent caching for custom recursive lookups so review the upgrade notes before updating.

Zonemaster::CLI provides a simple command line front end for running Zonemaster DNS zone tests from the terminal, so system administrators, domain owners and automation scripts can perform quick checks and diagnostics of domain name configurations. It wraps the Zonemaster engine into commands you can run interactively or call from shell scripts to validate delegation, name server behavior and other common DNS issues, making it easy to add zone validation to troubleshooting and monitoring workflows. The module is free software released under the 2-clause BSD license and is maintained by Vincent Levigneron.

AI::Agent::Skills::SiteKit is a tiny Perl helper that makes it easy to build links and metadata for the AI Agent Skills site at aiagentskills.net. It exports simple functions like skills_url to return the base skills endpoint and search_url to create a search link from a query string. If your script, web app, or bot needs to generate or canonicalize links to AI Agent Skills without hardcoding paths or rolling your own URL logic, this lightweight module gives a straightforward, focused way to do that.

Algorithm::Heapify::XS is a small, fast Perl extension that adds in-place heap primitives for treating ordinary arrays as binary heaps so you can efficiently get or maintain the top element without sorting the whole list. It provides heapify, push, shift, and adjust operations in four flavors for numeric or string ordering and for min or max heaps, plus helper functions to compute parent and child indices. Typical uses are finding the top K items, implementing lightweight priority queues, or adjusting an element whose weight has changed, and all operations work directly on the array and return the current top. The module is implemented in XS for speed and therefore must be built with a C compiler and Perl build tools, and functions are not exported by default so you must request the symbols or use the provided export groups.

PAGI is a modern specification for building asynchronous web applications in Perl and a direct successor to PSGI designed to handle long‑lived protocols like WebSocket and Server‑Sent Events as well as traditional HTTP. It defines a simple, async message-based application interface where your app is an async coderef that receives a scope describing the connection and two async callbacks for receiving and sending events, with explicit backpressure via Futures so streaming and background work are practical. PAGI is the specification only and is intentionally split from the reference server and the application toolkit which now live in the PAGI::Server and PAGI::Tools distributions, though the PAGI distribution still pulls them in temporarily for compatibility. The specification is stable while the reference server and toolkit are considered beta and are recommended to run behind a reverse proxy in production until they are more battle tested. The project ships extensive learning material including a tutorial, cookbook, and migration guide from PSGI and recent changes reorganize the distribution into pure spec POD, add connection metadata flags like response_started and response_complete, document middleware scope cloning semantics, and shift header byte-safety enforcement to the server. If you need to write async-capable Perl web apps that stream, push events, or maintain persistent connections, PAGI is the place to start and you can try it quickly by installing PAGI::Server and PAGI::Tools and running pagi-server.

Data::URIID extracts identifiers and useful metadata from URIs, QR codes and related inputs so your app can display, link and enrich objects with names, thumbnails, icons and canonical IDs. You create an extractor object, call lookup on a URL or other supported input and receive a Data::URIID::Result that exposes identifiers by type and attributes like displayname. The extractor can work offline or perform controlled online lookups, is configurable with a user agent and preferred language tags, and integrates with Data::Identifier and a catalog of service handlers to recognize many URI schemes, tag and acct URIs, digests, barcodes and common well known IDs. Recent updates added explicit support for geo: and ni:// URIs, replaced built‑in ISBN handling with Business::ISBN, improved result casting and added an is_on_earth attribute plus the ability to set the identifier used for Earth. This module is a good fit for systems that need to parse scanned codes or links and reliably map them to canonical identifiers and display information, but note that lookup will die on failure rather than return an empty result.