CPANscan

mb.pm is a modulino that lets you write and run Perl scripts using a variety of legacy multibyte encodings (Big5, Big5-HKSCS, EUC-JP, GB18030, GBK, Shift_JIS/CP932, UHC) as well as UTF-8 and WTF-8 by transpiling MBCS literals into ordinary octet-oriented Perl so your script behaves predictably without relying on Perl's UTF8 flag. It preserves traditional byte semantics for core operations while offering an mb:: namespace of codepoint-aware helpers for length, substr, ord, chr, transliteration and regex work, rewrites regexes and character classes for safe multibyte anchoring, and provides useful variables like $mb::PERL and $mb::ORIG_PROGRAM_NAME for running MBCS programs and preserving original names. You can run scripts via the modulino wrapper (perl mb.pm script.pl), install a source filter on modern Perls with use mb, or use the new runtime interface that exposes mb::qr, mb::valid and mb::split to call codepoint behavior only where needed. Recent releases document and implement that three-way model and clarify mb's strict definition of a "character" versus plain octet semantics so you can choose strict codepoint handling or octet-safe I/O. The module supports many Perl versions back to 5.005_03 and includes Windows-friendly features like DOS-style globbing, but it intentionally omits some Unicode facilities (full Unicode properties, named codepoints and full case folding) and inherits a few platform limits noted by the author, so it is most relevant if you need to maintain or write Perl programs that must work with native multibyte encodings without forcing UTF-8 conversions.

App::ChangeShebang is a small command line utility that fixes the shebang lines of Perl scripts so they still run after you move a relocatable Perl installation. When Perl is built with relocatable support scripts can contain absolute paths to the build-time perl binary that break if the installation is relocated. change-shebang rewrites those shebangs into a tiny portable shell wrapper that locates and execs the perl binary next to the script so the script remains executable wherever the Perl tree is moved. Run it on a script path like change-shebang /path/to/bin/script.pl and it is particularly useful for packagers and anyone who ships or moves Perl installations.

Command::Run is a compact, core-only Perl helper for running external commands or Perl code references and capturing their output in a simple, chainable API. You can feed data to stdin, capture stdout and stderr separately or merge stderr into stdout, or obtain a file-descriptor path like /dev/fd/N to hand to other programs. Code references are run in a forked child by default but can be executed in-process with the nofork option and paired with raw mode to avoid PerlIO encoding overhead for much higher throughput. The interface supports method chaining via command, with and run so the same runner can be reused with different inputs. It is intentionally lightweight compared with feature-rich tools like IPC::Run, so it is ideal for straightforward capture-and-run tasks rather than complex pty or timeout management. A recent fix eliminates PerlIO encoding-layer accumulation in nofork mode so long-running processes no longer slow or leak memory and raw mode is no longer required to avoid that problem.

Desktop::Workspace::Util provides small, focused helpers for working with DesktopWorkspace specification modules, letting you locate and instantiate a workspace module, enumerate its items with rich tag and type filters, and open those items (programs, files, directories, URLs) from scripts or tools. The API is deliberately script-friendly, returning enveloped arrays with HTTP-like status codes and optional metadata, and the list and open functions accept options for tag-based inclusion or exclusion, type filtering, query and shuffle, module arguments and namespace prefixes (defaulting to "DesktopWorkspace" and ""), and opening-time overrides such as KDE activity or forcing a new browser window. Functions are not exported by default but can be exported when needed. This module is useful if you want to automate launching or inspecting grouped desktop resources and integrate workspace specifications into other automation, and version 0.001 is the initial release.

Regex::Range::Number generates compact regular expressions that match whole numbers inside one or more specified numeric ranges. You can use it as an object or import the number_range function to get a ready-made regex string for a single range like 100 to 1999 or for a list of ranges such as [[55,56],[75,89],[92,100]], and it can optionally wrap the result in a capture group. The returned pattern plugs directly into Perl m// expressions, making it convenient for input validation, parsing, or filtering when you need precise numeric-range matching without handcrafting complex regexes.

Object::Proto is a compact, high-performance object system for Perl that stores objects as arrays with compile‑time slot mapping and optional prototype chains, giving you fast, memory efficient accessors and method dispatch that still work with normal bless, isa and can. You define classes and properties with object or Object::Proto::define, get automatically generated getters and setters that can be imported as function-style accessors for extra speed, and use built‑in type constraints, defaults, lazy builders, triggers, weak references, readonly flags and other modifiers for robust data handling. The module supports classical inheritance including multiple and multi‑level extends, roles, method modifiers like before, after and around, singleton construction, clone, freeze and lock for mutability control, and BUILD and DEMOLISH hooks for setup and teardown. Advanced users can register custom types from Perl or from XS to move checks and coercions into C for minimal overhead, and a full set of introspection utilities exposes properties, slot metadata, ancestors and prototype chains. If you need a feature rich yet faster alternative to hash‑based Perl objects, especially for performance sensitive code, Object::Proto is a practical choice.

Tk::FileBrowser is a Perl/Tk widget that gives your Perl GUI a multicolumn file system explorer with configurable, sortable and resizable columns. It supports multiple view modes (compact, detailed, icon) and lets you add custom column types via -columntypes by providing display and test callbacks so you can control what each column shows and how it sorts. The widget exposes hooks for custom icons, double‑click file invocation, load and postload callbacks and provides simple methods such as load, reload, collect and openFile to manage the current folder. Header and tree context menus make it easy to toggle case dependent sort, show hidden files and open entries and handy key bindings like Ctrl+A, Ctrl+F and F5 speed common tasks. This module is a good choice when you need an embeddable, extensible file browser for a Tk based Perl application but be aware the author notes loading and sorting very large folders can be slow.

Test::CPAN::Health is a command-line tool and Perl API for evaluating the overall health of a CPAN distribution and producing a scored, configurable report. It accepts a local path, a CPAN distribution name, or a module name and runs a broad suite of checks — from licensing, META and CI configuration, documentation and POD coverage to dependency freshness, known security advisories, CPAN Testers results, test coverage, code complexity and duplicate code — then returns a weighted score out of 100 and renderable output in terminal, JSON, HTML or TAP for CI integration. You can skip or limit checks, disable network queries, require a minimum score to fail a build, or embed the analysis in scripts, though note that coverage checks need Devel::Cover and run the package test suite which can be slow, network checks depend on external APIs and rate limits, and duplicate-code analysis can false positive on generated or data-heavy files. The module provides both a simple CLI for quick audits and a programmatic interface for automated tooling. This is the initial release on CPAN.

Algorithm::Classifier::IsolationForest is a Perl implementation of Isolation Forest and Extended Isolation Forest for unsupervised anomaly detection that builds an ensemble of random trees to score and flag outliers, returning per-sample anomaly scores in (0,1] and optional binary labels. It supports classic axis-aligned splits or oblique hyperplane splits for the extended variant, a majority-voting aggregation mode, learned thresholds from a contamination parameter, several strategies for handling missing values, and named-feature support for single-row scoring. The module offers persistence to JSON, a packed-data wrapper to speed repeated scoring in interactive workflows, reproducible fits via seeding, and multiple ways to speed up training and scoring with an optional Inline::C and OpenMP backend or by forking worker processes while keeping a pure-Perl fallback that produces identical results. Overall it is a practical, feature-rich choice for detecting anomalies in numeric datasets, especially when you want flexibility over aggregation, missing-data treatment, performance tuning, and easy model saving and reloading.

Matplotlib::Simple is a Perl helper that converts Perl data structures into ready-to-run Python3/matplotlib scripts so you can produce charts without learning matplotlib itself. You provide hashes, arrays or nested structures and simple options and the module emits Python that creates single plots, overlays and multi-panel figures in many common styles including bar, boxplot, hist, hist2d, hexbin, imshow, pie, plot, scatter, violin and colored tables. It supports labels, colors, legends, colorbars, shared axes and twin axes and writes the script into the system temporary directory so you can edit or execute it to save PNG, SVG or other image formats. The module is aimed at making common plotting tasks easy from Perl and works cross platform, but it does require a Python 3 interpreter and matplotlib to be installed.

Algorithm::EventsPerSecond is a compact sliding-window meter that tracks events per second over a fixed recent window, keeping per-second counts in a small ring buffer so memory use stays constant even under high event volumes and mark and rate operations are effectively O(1). You create a meter with a window length, call mark to record events, and query count, rate, and total to get the number seen in the window, the averaged events/sec and the lifetime total; rate uses the meter's elapsed lifetime when it is younger than the window so early readings are reasonable. The module ships with an optional XS backend that stores the ring in packed int64 buffers and scans the window in C, using SIMD (AVX2 or SSE4.2) when available for extra speed, while a pure-Perl implementation with identical behavior is used if the XS backend cannot be built or is disabled at runtime. Install-time and runtime controls let you force a pure-Perl build or tweak compiler flags and architecture, and the backend and simd methods let you detect which implementation is active. This is an initial 0.0.1 release, useful when you need a low-overhead, predictable-rate meter for monitoring or throttling in event-driven systems.

CPAN::Maker::Bootstrapper is a command line scaffold that creates a complete, buildable Perl CPAN distribution in one step, producing a managed Makefile, buildspec.yml, stub source and test files, and a ready-to-run build system so you can run make to generate a distributable tarball immediately. It uses a traditional stack of GNU make, bash, and Perl to give you reproducible, local builds without relying on cloud CI services and encourages good practices with .pm.in sources, automatic dependency scanning, syntax checks, perltidy and perlcritic gates, and an upgrade-safe extension point in project.mk. You can import existing projects or use built-in or custom stubs for normal modules or CLI tools, and the installer seeds VERSION, ChangeLog, README generation, and release targets so versioning and release-notes workflows are integrated. Advanced features include AI-assisted code, POD, and release-note generation via the Anthropic Claude API with a structured review and annotation workflow to iteratively suppress noise and certify findings. Configuration is read from your git config or a simple ini file and you can customize prompt profiles, API key retrieval, install locations, and build options. Be aware that imported files become .in sources, generated .pm and .pl files are overwritten by the build, import and stub modes are mutually exclusive, and the tool expects git, make, and curl on your PATH and an LLM API key for AI commands.

Chorus is a Perl-based symbolic inference platform for turning legal, policy or other normative text into deterministic, reproducible compliance-checking pipelines. It bundles a typed inference engine where rules can be written in Perl or in a compact YAML DSL, together with an AI agent companion that helps extract and formalize rules from source documents while leaving execution fully deterministic and offline. Chorus is suited to teams building auditable automation for compliance, policy enforcement or risk checks who want clear, reproducible decision logic rather than opaque statistical models. Recent releases add a declarative TERMINAL field for YAML pipelines, better frame selection and lifecycle hooks, logging and loop-guarding to avoid runaway cycles, plus expanded bilingual documentation and AI agent skills to streamline corpus-to-pipeline workflows.

Crypt::OpenSSL3 is a modern Perl wrapper around the OpenSSL crypto and TLS library that lets Perl code use SSL/TLS connections, asymmetric keys, symmetric ciphers, message digests, MACs, key derivation functions, and X.509 certificate handling through a set of focused modules. The top-level distribution provides lightweight error handling and introspection of how the underlying OpenSSL was built, exposing helpers to query version and build configuration so you can adapt to different OpenSSL installs. If you write Perl that needs secure network connections, certificate parsing and validation, or cryptographic primitives without dropping into C, this package gives you a direct, maintained interface to those OpenSSL features. The recent 0.010 release switched the license to Apache 2.0 and added conveniences such as DER encode/decode from strings, generic ASN.1 value support, PEM helper functions, an EDIPartyName class, a get_all_certs helper for X509::Store, and a set of memory-management fixes, making it easier and safer to work with modern OpenSSL capabilities.

Object::Remote lets you create Perl objects and call their methods in other processes or on other hosts, typically over ssh, without having to install non-core modules on the remote side. It provides a simple API to connect to a remote interpreter, construct objects on that interpreter with new::on, obtain remote subroutine references with can::on, and perform asynchronous calls with its Future helpers. Configuration and behavior can be controlled with environment variables for the remote perl executable, event loop implementation, and logging options, and it can forward remote log events back to the local process. This makes it handy for running pieces of Perl code or maintenance tasks across machines while keeping your local code interface natural and minimal. Be aware of documented limitations though: all data is passed via JSON which can be slow or memory intensive for very large or deeply nested structures; the cooperative run loop requires you to yield control so I/O and timers run; high load can delay timers or starve connections; deadlocks are possible and a watchdog helper exists to mitigate them; and there are known issues with IO::Async on nested connections. Overall it is a powerful tool for remote execution and control when you need to work with remote Perl objects without deploying extra software on the far side.

Getopt::Class is a lightweight wrapper around Getopt::Long that helps you define, group and validate command line options as named classes of properties so different parts of your program can declare their own sets of options cleanly. You supply a dictionary that describes each option with type, aliases, defaults and validation rules and the module generates the Getopt::Long specs, parses the arguments and returns a blessed values object you can access as a hash or as object methods. Supported types include booleans, strings, integers, arrays, hashes, file and uri objects, datetimes and code actions, and it adds conveniences such as mirrored enable/disable or with/without options and automatic dash/underscore aliasing. The module provides class-level helpers to extract and validate only the options for a given feature, reports validation or parsing issues via an error object instead of dying, and wraps values in small typed objects for easier downstream use. The current 1.1.5 release made dependency updates only and did not change the public API.

Perl::Tidy exposes the perltidy formatter as a library so you can clean up and consistently style Perl source from within your own programs instead of calling the perltidy command line. Call Perl::Tidy::perltidy with files, string or array references, or objects that implement getline and print to read or write code, or supply argv and perltidyrc arguments to control formatting and to dump or inspect the effective options. You can insert custom prefilters and postfilters to transform input or output, or provide a formatter object with a write_line callback to receive tokenized lines for specialized analysis or processing. The routine returns an exit flag so your program can detect fatal parameter errors or warnings, and perltidy can also produce separate stderr, .ERR, log, tee, and debug streams as needed. Note that handling of decoded versus encoded UTF8 output strings changed in recent versions and is controlled with the -eos or -neos flags, so take care when passing or receiving string references. The module ships with the perltidy command line script and is installable from CPAN.

CTK (CTKlib) is a compact toolkit of Perl utilities and helper modules designed to simplify building daemons, automation "robots" and command line applications. It gives you a central CTK object to manage project layout, config files, data and temp paths, logging and debug output, command line options and plugin loading, and it bundles a variety of supporting modules for tasks such as DBI access, file handling, FTP/SFTP, serialization and running as a daemon. The library emphasizes simple, readable APIs and pluggable extensions so common infrastructure is handled for you while you focus on application logic. Note that versions 2.00 and later are not compatible with earlier releases and the 2.x series added a serializer, CTK::Daemon, CTK::Timeout and expanded plugin and network support while removing some deprecated utilities. If you need consistent configuration, logging, plugin and daemon support for Perl services or automation scripts CTK is likely a good fit.

Number::ZipCode::JP is a compact Perl module for checking whether a Japanese postal code is valid according to Japan Post rules, letting you construct a zip object from either two parts (area and suffix) or a single string with or without a dash and then call is_valid_number to verify it. You can limit validation to specific categories such as area or company codes by importing the matching table, and you can change the target code with set_number. The module relies on updatable table classes that are refreshed frequently to track postal changes, so it stays current with Japan Post data, and a past release fixed a regex compatibility issue to support older Perl versions.

Mail::Sendmail is a lightweight, cross-platform Perl module that lets your script send email directly via SMTP with minimal setup. You provide message fields and options in a simple hash and call sendmail, and the module handles common needs like Date headers, Bcc and Cc, real names in addresses, retries and alternate servers, and optional quoted-printable encoding when MIME::QuotedPrint is installed. It only requires Perl 5 and a network connection, so it is handy for CGI pages and automation scripts. It is not intended for very large attachments because the whole message is built in memory. Headers are not MIME-encoded so accented characters may not always be handled unless you use MIME::QuotedPrint. You must configure or supply an SMTP server and note that SMTP authentication support is experimental.

Module::Generic is a feature-rich base class for building Perl object APIs quickly and consistently. It provides a large collection of helper accessors and lvalue-capable setters for common types such as scalars, numbers, booleans, datetimes, URIs, IPs and UUIDs, plus machinery to turn hashes and arrays into object wrappers or dynamically created classes with typed fields via create_class. The module also centralizes error and exception handling, offers flexible serialization/deserialization (JSON, CBOR, Sereal, Storable::Improved), runtime class loading, debugging and coloured terminal output, and optional XS-accelerated utility routines for better performance. It is aimed at module authors and application developers who want to prototype or implement rich data objects without writing repetitive boilerplate, and the distribution pays close attention to thread and process safety while documenting which metaprogramming features should be run at startup to avoid races. Noteworthy in the recent v1.6.0 release are new pure-Perl subroutine introspection helpers (_subinfo and _subname) and further refinements to the numeric handling and cloning behavior.

File::Raw::Archive is a compact, streaming reader/writer for archive containers that makes it easy to list, inspect, extract, or build archives from Perl without loading whole files into memory. It ships with a robust tar plugin that understands real-world tar dialects including ustar, GNU @LongLink, and PAX and preserves sub-second mtimes and SCHILY.xattr.* extended attributes when extracting on platforms that support xattr. The API is simple and script-friendly with methods and exportable functions for open, each, list, extract, extract_all, and create, plus options for gzip compression, format selection, entry filtering, and safe extraction that blocks path traversal. For heavier workloads extract_all can dispatch file writes to a forked worker pool for parallel extraction and the module exposes a C plugin API so additional format plugins such as zip, cpio, or ar can be added at runtime. This release is the first public version and highlights streaming gzip handling, PAX global metadata support, entry filtering, and the plugin architecture.

Travel::Status::DE::IRIS is a Perl client for the Deutsche Bahn IRIS web departure monitors that fetches scheduled and realtime departure/arrival information for a given station and returns structured Result objects you can use in scripts or infoscreens. It supports blocking requests and an experimental non‑blocking constructor that works with Mojo::Promise and Mojo::UserAgent, optional caching of station and realtime queries, automatic merging or preservation of trains that change IDs at a stop, and a with_related option to include nearby or subdivided platform entries. The module aims to mask IRIS quirks such as transfer trains and platform changes while exposing useful options like lookahead/lookbehind and access to related station metadata. Note that the IRIS backend is deprecated and this module is not actively maintained, so it is not recommended for new projects and you should consider Travel::Status::DE::DBRIS as an alternative. The current 2.05 release mostly updates station and meta databases to keep the built‑in station data current.

OpenSearch::Client is an unofficial Perl client that lets Perl applications talk to OpenSearch clusters for indexing, searching and cluster management. It was created when OpenSearch forked away from Elasticsearch and is derived from the familiar Search::Elasticsearch API, so existing Perl code using that client can be adapted more easily. The module defaults to connecting to localhost:9200 and provides a comprehensive API surface with documentation available in OpenSearch::Client::Manual. This distribution is maintained by Mark Dootson, is released under the Apache 2.0 license, and the 3.007.000 series represents the initial release with subsequent minor pod updates.

Net::Nostr::Relay is a compact, in-process Nostr WebSocket relay that accepts client connections, manages subscriptions, stores events in an indexed in-memory backend (or a pluggable store), and broadcasts matching events to subscribers. It implements the core Nostr protocol and several NIPs such as authentication (NIP‑42), relay info (NIP‑11), event deletion (NIP‑09), proof‑of‑work (NIP‑13) and expiration handling, and it respects event semantics like replaceable, ephemeral, and addressable events. The module offers practical controls for real deployments including per-connection rate limiting, configurable event and message size caps, subscription and filter limits, idle and graceful shutdown timeouts, optional TLS, and an on_event hook for custom validation or filtering. Events are not persisted across restarts unless you supply a persistent store, and you can also inject events programmatically for testing. This release splits the relay implementation and default RelayStore out of Net::Nostr into its own distribution and depends on Net::Nostr::Core for protocol objects and validation.

Net::Nostr::Client is a lightweight WebSocket client for connecting to Nostr relays and exchanging protocol messages. It gives a callback-driven API to publish signed events, manage subscriptions and receive stored and live events, perform one-shot counts (NIP-45), and run negentropy set reconciliation (NIP-77), and it supports NIP-42 authentication. You can connect synchronously or asynchronously to ws or wss relays and control TLS verification via options like ssl_no_verify and ssl_ca_file. Register handlers for event, ok, eose, notice, count, closed, auth, neg_msg and neg_err to react to relay messages as they arrive. Methods will croak when called with bad arguments or while disconnected and assigning a new handler for a given event type replaces the previous handler. If you need programmatic, Perl-native access to Nostr relays with built in support for these NIPs, this module provides a straightforward, callback-based way to do it.

Net::Nostr::Core is a focused Perl toolkit that implements the core data types and protocol utilities for the Nostr decentralized messaging protocol. It provides modules like Net::Nostr::Event, Net::Nostr::Key, Net::Nostr::Filter and Net::Nostr::Message so you can create, sign, filter and process Nostr events and messages, and it is the foundation used by client and relay distributions. This first independent release splits core protocol functionality out of the larger Net::Nostr distribution, targets the current NIP set as of 2026-07-01, and makes HTTP support optional by lazy-loading AnyEvent::HTTP only for NIP-05 lookup and verification. If you want a full client or relay stack use the Net::Nostr shim which pulls in the recommended dependencies, but if you only need protocol primitives for building or testing Nostr tools, Net::Nostr::Core gives a compact, minimal implementation.

Perl5::Build::Warnings is a small utility for parsing the output of make when building the Perl 5 core so you can study compiler warnings across a build. You point it at a plain text or gzipped make/test_prep log and it extracts warnings that match the typical "<file>:<line>:<char>: warning: ... [-W...]" form, normalizes the warning class to a "W..." name and exposes the results programmatically. The module can return a list of all parsed warnings, counts by warning class, or filtered lists for a particular warning class or source file, and it can pretty-print a summary to STDOUT. It has no runtime dependencies outside the Perl core and is primarily aimed at Perl core developers or maintainers who want a quick way to tally and inspect build-time warnings, provided the log uses the expected warning format.

JSON::Schema::Tiny is a slim, fast Perl validator that checks ordinary Perl data structures against JSON Schema rules. It offers a simple functional call and an object-oriented API and returns a clear result indicating validity and, when validation fails, JSON Schema style error details. The module implements the most commonly used keywords so it is well suited for everyday validation tasks while deliberately omitting some advanced features such as external $ref resolution, annotations and several newer draft keywords to keep the code small and quick. You can tweak behavior with options like boolean-only results, depth limits, and tolerant handling of boolean or numeric-like values. Be aware that regexes from schemas are evaluated without sanitization so do not use untrusted schemas, and use a reliable JSON decoder such as Cpanel::JSON::XS so data types are preserved. For a more complete, specification-compliant alternative see JSON::Schema::Modern.