CPANscan

Netdisco is an open source, web-based network management system that gathers SNMP data into a PostgreSQL database to let administrators discover, map and manage their switched networks. It helps you find a device by MAC or IP and show the exact switch port, change port state, VLAN or PoE settings, build inventory reports by vendor and OS, and produce topology visualizations, all via a built-in web UI and accompanying backend daemon that polls devices. Designed to run on Unix-like servers, it requires Perl and PostgreSQL and works with SNMP-capable switches and routers, offers command-line utilities, a plugin system for customization, and official container images and documentation to simplify installation and upgrades. If you need automated discovery, port-level troubleshooting and centralized hardware inventory for a layer 2/3 network, Netdisco is a mature, community-backed option.

greple is an advanced, configurable grep-like tool written in Perl that lets you search text with the full power of Perl regular expressions while also extracting and formatting matched regions and blocks. It supports multi-line patterns, pattern files, capture-group indexing, custom output formats and colors, callbacks and plugin modules, and can be used as a filter for processing code, logs or other text-heavy data. The tool is aimed at developers and power users who need more flexible region handling and post-processing than standard grep. The recent 10.05 release adds a -P option to search multiple patterns in parallel using child processes and fixes a UTF-8 block-printing performance issue when producing many matches.

Time::Nanos is a tiny, easy-to-use Perl extension that gives you high-resolution timestamps by calling the system clock, exposing simple functions nanos, micros and millis to get time in nanoseconds, microseconds or milliseconds. In scalar context each function returns the total units elapsed since the clock epoch and if you pass a true argument you get a two-element list of seconds and subsecond units. You can choose the clock source via the $Time::Nanos::CLOCK variable, which defaults to realtime but can be set to monotonic when you need reliable elapsed-time measurements that are not affected by NTP or user clock changes. The module is suitable for profiling, building stopwatches, or any task that needs submillisecond timing and the recent 0.1.4 release added the seconds-plus-units return option, an externally settable clock choice, Windows high-resolution timer support and a stopwatch example.

YAML::LibYAML is the Perl wrapper around the libyaml C library, exposed via XS to give fast, standards-aware YAML parsing and generation for Perl programs. It makes it easy to convert Perl data structures to YAML and back with support for anchors, aliases, booleans, regexps and common YAML features and it provides convenient Load, Dump and file helpers. The module is mature and production ready so it is a good choice when performance and fidelity to libyaml matter, and it includes security-minded options such as disabling automatic loading of blessed objects and recent defaults that avoid following cyclic references. Recent releases add experimental object oriented interfaces and improved YAML 1.2 handling along with a new boolean option and various robustness fixes. Note that the CPAN distribution name YAML-LibYAML corresponds to the YAML::XS module so consult YAML::XS documentation for usage examples.

Dezi::App is a lightweight convenience wrapper for building search applications with the Dezi toolkit that pulls together an index, an indexer, an aggregator, and indexing configuration into a single App object. You instantiate it with simple parameters like an invindex directory, an indexer shortcut (for example lucy or test), an aggregator shortcut (fs, spider, mail, or mailfs), a config file or object, and an optional filter coderef, and you can enable test_mode to run only the aggregator without touching the index. Call run(paths) with files or URLs that the aggregator understands and it will return the number of documents actually indexed, and the count method reports the indexer count. This module is useful when you want a quick, configurable way to crawl files or mail and index their contents without wiring Dezi components together by hand. Recent releases improved mail aggregator support with FileRules and FileMatch and better attachment handling, fixed dot-file path parsing and CLI docs, and moved CI to GitHub Actions.

Sidef is a Perl module that embeds the Sidef programming language engine into Perl, so you can parse, compile and execute Sidef code from Perl programs or convert Sidef to Perl for faster execution. The language blends object oriented and functional styles and ships with first class numeric types including arbitrary precision integers, rationals, floats and complex numbers, plus features like multiple dispatch, pattern matching, lazy evaluation, closures and a friendly REPL and CLI. Sidef integrates directly with the CPAN ecosystem, supports AST inspection and transformation, and offers multi-level optimization and optional DBM-backed compilation caching to speed repeated runs. Installation requires a few C libraries for high precision math and optional DBM modules for caching, and the module notes limitations such as cache thread safety, Unicode depending on Perl, and potential performance differences versus native compiled languages. If you want a modern, expressive scripting language tightly integrated with Perl for embedding, configuration, metaprogramming or high-level numeric work, Sidef provides a polished engine with compilation, caching and tooling to make that easy.

Seed::Audio::AI::SiteKit is a tiny helper library that provides easy access to canonical metadata and URLs for the Seed Audio AI site, letting your Perl scripts fetch things like the site homepage or specific pages such as pricing with a single function call. It is lightweight and meant to simplify linking and basic site information lookups inside applications. This module is unofficial and not an SDK for ByteDance, Seed, Volcengine, or any model provider, so it does not implement API calls, authentication, or other service integrations.

JSON::JSONFold reformats pretty-printed JSON into a more compact but still readable layout, collapsing arrays and objects to reduce vertical space while preserving clarity and structure. It can be used as simple functions, an object-oriented formatter, a drop-in replacement for encode_json/to_json, or a streaming post-processor that folds JSON as it is written without buffering the entire document. The module supports configurable presets and per-call overrides for target width, indentation, key sorting and other folding options, and it can report basic formatting statistics when writing to filehandles. The recent 0.2.0 release adds grid layout support for arrays of similar arrays or objects and new presets to present such data in a tabular style, along with improved configuration handling and validation. JSON::JSONFold is a practical choice when you want human-friendly, space-efficient JSON for logs, command-line tools, or files and it integrates with JSON::PP by default for the initial pretty-printing step.

DateTime::Fiction::JRRTolkien::Shire is a DateTime-compatible calendar class that models the hobbits' Shire calendar from Tolkien's Lord of the Rings, providing constructors, accessors and arithmetic so you can create, compare, stringify and convert Shire dates to and from epoch or other DateTime objects. It implements the Shire layout of twelve 30-day months plus five special holidays and an extra leap-day holiday, supports weekday and holiday names, strftime formatting via Date::Tolkien::Shire::Data, and duration arithmetic using a dedicated Shire duration class, while exposing almost the full DateTime interface with the one known omission of format_cldr. The module requires DateTime, keeps time-zone and time fields for interoperability, and intentionally uses the modern Gregorian leap-year rule rather than the simpler rule quoted in Appendix D so Shire dates stay aligned with our calendar. If you want to work with Tolkien-style dates in Perl this package handles construction from epoch or other DateTime objects, stringification, localized on_date event text, and arithmetic, and the latest release fixes argument handling so now(), today(), from_epoch() and from_object() properly accept the accented and traditional options documented.

Archive::SCS provides a simple API for treating SCS game archives and extracted directories as a single merged filesystem so you can mount multiple archive files or folders, enumerate directories and files, and read entries either by their path or by their hash. It hides archive-format details behind a consistent interface and supports multiple handlers such as directory, HashFS, HashFS2 and ZIP, letting you change which formats are active and powering the bundled scs_archive command line tool. The module is useful when you need to inspect or extract game data across several SCS packages without writing format-specific code, and recent updates (1.10) switched internal hashes to 16-byte hex strings, cut memory use for HashFS v1, and relaxed build requirements to make installation easier. Note that texture object handling is still evolving and may be inconsistent between format handlers.

OIDC::Client is a Perl library that implements an OpenID Connect and OAuth 2.0 client, letting your scripts or applications initiate authorization flows, build the provider authorization URL, fetch and refresh tokens, verify JWT ID tokens, introspect opaque tokens, retrieve userinfo, exchange access tokens for different audiences, and create web clients already configured with access tokens for calling protected APIs. It is configuration driven and supports multiple grant types and client authentication methods, claim mapping, automatic JWKS key rotation and helper objects for identities and access tokens, and it is intended for direct use in scripts or via framework plugins for Mojolicious, Catalyst or Dancer2. Recent updates added support for tls_client_auth, stronger startup checks for client authentication, a fix to avoid a Data::UUID-related runtime crash, and integration tests to improve reliability. Use this module when you need a ready-made, configurable OIDC/OAuth2 client in Perl to integrate with identity providers and secure API access.

HTML::Composer is a Perl library for building validated HTML from nested Perl data structures, inspired by TyXML and Hiccup, so you describe pages as arrays of tag names, optional attribute hashes and child arrays and the module renders tidy HTML or partial fragments. It validates output and will croak if validation fails, escapes text by default while offering an unsafe wrapper for raw insertion, and supports optional caching and compact class lists via attribute arrays. Use it when you want a programmatic, data-driven, high-performance way to produce safe, well-formed HTML from Perl rather than concatenating strings.

Mojolicious::Plugin::BarefootJS makes it easy to run the BarefootJS server-side rendering runtime inside a Mojolicious app by registering a per-request "bf" helper that lazily creates a BarefootJS instance backed by BarefootJS::Backend::Mojo. With the plugin you can render BarefootJS-marked templates as native Mojolicious templates and access the same runtime from controllers and templates, giving you a straightforward way to combine Mojolicious routing and BarefootJS rendering. The plugin wires up the necessary helpers and hooks so the runtime only boots when needed, and if you prefer to run outside Mojolicious there is a BarefootJS::Backend::Xslate backend that drives the runtime with Text::Xslate instead.

BarefootJS::Backend::Xslate is a rendering backend that lets the BarefootJS runtime render Kolon (.tx) templates using Text::Xslate, so you can serve compiled BarefootJS templates from any PSGI/Plack app or from a plain Perl process without tying into a web framework. It binds the runtime into templates as the bf object so helpers emitted by the @barefootjs/xslate compile-time adapter can be invoked directly from templates, and it builds Text::Xslate with HTML auto-escaping enabled while providing mark_raw, encode_json, materialize and render_named hooks the runtime expects. You can pass an existing Text::Xslate instance or supply template paths and options when constructing the backend, making it a straightforward, drop-in way to render Kolon templates from Perl code.

BarefootJS is a lightweight server-side runtime for templates compiled from JSX or TSX into marked templates and accompanying client JavaScript. Compiled templates call into a bf runtime object to perform tasks like JSON marshalling, marking raw strings, materializing JSX children, and invoking named templates. The runtime is intentionally engine and framework agnostic and delegates any environment-specific work to pluggable backends so the same core can be used with different template engines or web frameworks. Shippped backends include Xslate for PSGI/Plack and a Mojolicious plugin for Mojo applications. The core relies only on Perl core modules so you only load extra libraries when a chosen backend requires them, making this a good fit if you want a portable, backend-flexible server rendering layer for JSX/TSX-based templates.

SPVM::Resource::Coro is a small resource wrapper that packages the libcoro coroutine context switching C library for use in SPVM native extensions. It provides the coro.h header and coro.c source compiled as C99, auto-detects and supplies the platform-specific compiler flags and defines needed for the correct context switching implementation, and exposes those defines so you can add them into your SPVM builder config. You enable it in your build with use_resource('Resource::Coro') and then pull the resource defines into your config before compiling native code that uses coro_context and related APIs. The bundled code is taken from Coro 6.57 and this SPVM resource was first released in version 0.001.

Class::Unload is a small utility that lets you unload a Perl class at runtime by clearing its symbol table and removing the module from %INC so a subsequent require will reload it. It also removes Moose metaclasses when present, and takes care of common issues around inheritance and older Perl versions so it is useful for test suites, plugin systems, live development or any situation where you need to reload code without restarting the process. The module is mature and conservative in scope; recent maintenance releases added repository and packaging tweaks and earlier updates explicitly improved Moose cleanup and compatibility with Perl 5.10 and older releases.

Future::IO::Impl::AnyEvent is a lightweight backend that makes Future::IO run on the AnyEvent event loop. Simply loading the module registers AnyEvent as the Future::IO implementation so asynchronous primitives like sleep, timers, and other Future::IO operations execute on AnyEvent or its compatible loops such as EV. There are no new APIs to learn, just load it to integrate Future::IO with an AnyEvent-based event loop, which makes it a good choice when your application already uses AnyEvent or needs to coexist with AnyEvent-driven libraries.

Data::SortedSet::Shared provides a Redis-like sorted set that lives in a shared memory mapping on Linux so multiple processes can read and write the same ordered collection of members concurrently. Each member is a 64-bit integer with a double score and ties are broken by member id, and the set is implemented with an order-statistics B+tree plus a hash index so you get fast O(1) lookups of scores and O(log n) rank, pop and range operations while range scans run linearly through linked leaves. The module supports common ZSET-style operations such as add, incr, remove, rank, range_by_score, pop_min/pop_max, iteration and bulk adds, and it can be backed by a file, an anonymous mapping for forked children, or a transferable memfd, with an eventfd API for notifying other processes of updates. There is also a bundled Data::SortedSet::Shared::Strings helper that interns string keys to dense ids so string-keyed sets can be shared the same way. Note that this is Linux only, requires 64-bit Perl, scores must not be NaN, the mmap is writable by any process that opens it so do not share with untrusted users, and the futex-based lock recovers if a holder dies but cannot detect rare PID reuse.

Data::RoaringBitmap::Shared offers a Linux-only, 64-bit-Perl implementation of a Roaring bitmap stored in shared memory so multiple processes can observe and mutate a compressed set of 32-bit unsigned integers via a backing file, memfd, or an anonymous mapping inherited across fork. It splits values by their high 16 bits into buckets and stores each bucket's low 16 bits either as a compact sorted uint16 array or as a 64k-bit bitmap, which keeps memory efficient for both sparse and dense workloads. The API covers membership, add, add_many, remove, cardinality, min/max, export to an array, and in-place union and intersection with another shared bitmap, while a futex-based write-preferring rwlock with dead-process recovery serializes mutations across processes. You size the fixed container pool at creation time and operations that would need more slots fail cleanly, so plan capacity for the number of distinct high-16 groups you expect. Notes for v1: there are no run containers, no xor or andnot operators, and bitmap containers are not down-converted back to arrays after removals. The module warns against reopening files from untrusted sources because a crafted backing file could subvert internal offsets. This is the initial 0.01 release from 2026-06-26.

Data::RadixTree::Shared implements a compressed radix-256 (PATRICIA) prefix tree in a Linux shared memory mapping so multiple processes can share a compact mapping from raw byte-string keys to 64-bit unsigned integer values. It offers fast exact lookup, existence checks and efficient longest-prefix queries ideal for routing tables, dispatch tables and autocomplete back ends, and uses edge compression so operations run in time proportional to key length. Trees are created with fixed node and label-arena capacities and can be shared via a backing file, an inherited anonymous mapping after fork, or a transferable memfd; concurrent readers run in parallel under a read lock while inserts and deletes take a write-preferring futex lock with dead-process recovery. Note that keys must be byte strings (encode character data first), deletes are lazy in this initial release and do not reclaim space until clear, and reopened backing files are trusted so do not reuse or open files from untrusted processes.

Data::NDArray::Shared provides a Linux-only, 64-bit-Perl shared-memory numeric tensor you can use to share typed, row-major arrays across processes via a backing file, an anonymous mapping inherited across fork, or a memfd. It supports common numeric dtypes (f64, f32 and signed and unsigned integers down to u8), 1–8 dimensions and a fixed contiguous buffer, and offers element and flat indexing, bulk fills, reshape without copying, reductions (sum, mean, min, max), in-place scalar and element-wise arithmetic, and conversion to and from PDL including an optional zero-copy PDL alias when PDL is installed. Concurrency is handled by a write-preferring futex rwlock with dead-process recovery and a global lock ordering to avoid deadlocks when operating on two arrays, so concurrent writers serialize cleanly, but integer types wrap on overflow, there is an internal 1 TiB size cap, the PDL alias bypasses the lock and must be coordinated manually, and the shared mapping is writable by any process that opens it so do not expose backing files to untrusted code. This module is a practical choice when you need efficient, typed, cross-process sharing of numeric buffers for IPC or parallel processing.

Data::DisjointSet::Shared provides a Linux-only, shared-memory union-find (disjoint-set) structure for 64-bit Perl that lets multiple processes maintain and query a partition of a fixed universe of integer elements. You create it over an anonymous mapping, a backing file, or a memfd and then call union, find and connected to merge sets and obtain canonical representatives. The implementation uses union by size and path compression to keep operations near-constant time and stores a compact 8-bytes-per-element payload plus a small reader table. Because the arrays live in an mmap, every process that opens the same backing file or inherits the mapping across fork sees the same partition and contributes unions. Mutating operations, including find, perform path compression and therefore take a write-preferring futex lock with dead-process recovery, and a union_many operation lets you perform many unions under one lock for efficiency and atomic validation. The module exposes set_size, num_sets, capacity, reset, stats, sync and unlink, and capacity is fixed at creation so you cannot combine two separate structures. Note the mapping is writable by any process that opens it so do not share backing files with untrusted processes and that crash safety is best-effort with possible PID reuse limitations. Initial release 0.01 implements the functionality described.

Data::SpatialHash::Shared is a Linux-only, 64-bit Perl module that provides a fast shared-memory spatial index for 2D or 3D points and simple volumes, letting multiple processes read and update the same map concurrently. You store points (with optional per-entity interaction radii) and then run proximity queries such as radius, k-nearest, axis-aligned box, per-cell scans, and collision-pair broad phases, with bulk insert/move and batched queries to amortize locking. It supports seamless toroidal worlds for wraparound maps and a spherical mode with geo helpers and cube-sphere cell ids for planet-style coordinates and LOD chunking. Concurrency is handled by a futex read/write lock that recovers if a holder dies and the map can be backed by a file or a memfd and integrated with an eventfd for notifications. Tuning is straightforward: pick a cell_size near your typical query radius and a bucket count sized to expected entries, and note the module warns about large-region scans and documents a PID-reuse corner case in lock recovery as a practical limitation.

Data::HyperLogLog::Shared provides a Linux-only, 64-bit-Perl HyperLogLog sketch that lives in shared memory so multiple processes can count distinct items into a single, tiny estimator. With the default precision of 14 it uses only a few dozen kilobytes and gives about 0.8 percent relative standard error, making it ideal for counting unique visitors, events, or keys without storing every item. Processes can share the same sketch via a backing file, an anonymous mapping inherited across fork, or a transferable memfd, and you can add items, add batches, read the current estimate, clear, merge two equal-precision sketches to get a union, and manage syncing or unlinking the backing store. Mutations are guarded by a futex-based lock with dead-process recovery so concurrent add and count operations are safe and a crash leaves the sketch consistent up to the last completed update. Do not share backing files with untrusted processes because the mapping is writable.

Data::Histogram::Shared provides a Linux-only, 64-bit-Perl implementation of an HdrHistogram kept in shared memory so multiple processes can record and read a single compact, fixed-size histogram. You configure the lowest and highest trackable integers and the number of significant figures to get a fixed relative error across many orders of magnitude, which makes this ideal for latency and response-time measurement where values span microseconds to seconds. The API lets you record single values or batches, query percentiles, min, max, mean and total count, merge histograms with identical geometry, and share the backing via a file, memfd or fork inheritance. It stores integer values only so you should scale floats yourself, and mutation is guarded by a futex-based write-preferring lock with dead-process recovery for safe concurrent use. Do not share writable mappings with untrusted processes and be aware the lock recovery does not detect PID reuse, otherwise this is a small, efficient tool for cross-process telemetry on Linux.

Data::CuckooFilter::Shared provides a compact, fixed-size cuckoo filter stored in shared memory for Linux so multiple processes can efficiently share approximate set membership data with support for deletions. You add byte strings and the filter stores 16-bit fingerprints rather than full items, so memory use scales with the configured capacity not item size, and contains returns true for "probably present" or false for "definitely absent" with no false negatives for items you actually added. The table can be backed by a file, an anonymous mapping inherited across fork, or a memfd passed between processes, and concurrent mutation is protected by a futex-based lock that includes dead-process recovery so many processes can add, remove, and query safely. The filter has a bounded capacity and add returns false if it is full, adds do not de-duplicate so duplicates increment the stored count, and you must remove an item as many times as you added it to fully forget it. Important caveats: removal may corrupt other items if you try to remove keys you never added because of 16-bit fingerprint collisions, cuckoo filters cannot be simply merged, it is Linux-only and requires 64-bit Perl, and wide-character strings must be encoded to bytes before use; also avoid sharing writable backing files with untrusted processes.

Data::CountMinSketch::Shared is a Linux-only, 64-bit Perl module that implements a Count-Min sketch in shared memory so multiple processes can maintain a compact, fixed-size approximate frequency counter. You add items (optionally with counts) and get estimates that never fall below the true count and are probabilistically bounded above by configurable epsilon and delta error parameters. The structure stores only a small matrix of 64-bit counters so memory usage depends on the error settings rather than the number of distinct items. It supports concurrent adds and estimates across processes via a backing file, an inherited anonymous mapping after fork, or a transferable memfd, and it can merge sketches with identical geometry to combine streams exactly. Mutation is guarded by a write-preferring futex lock with dead-process recovery and individual increments are safe enough to leave the sketch consistent after a crash. Note that items are taken as raw bytes so you must encode wide characters first and that the module uses the standard Count-Min update rule to keep merges sound.

Data::BloomFilter::Shared is a Linux-only, 64-bit Perl module that implements a compact Bloom filter in shared memory so multiple processes can record and query set membership without storing the items themselves. You create a fixed-size filter by giving an expected capacity and a target false positive rate and the module maps a power-of-two bit array into shared memory via a backing file, a memfd, or an anonymous mapping inherited across fork. It hashes items once with XXH3 and uses double hashing to drive multiple probe positions, and exposes add, add_many, contains, merge, clear and introspection methods including an estimate of distinct items and bit-fill statistics. The filter guarantees no false negatives while false positives are tunable by your capacity and rate, and strings with codepoints above 255 must be encoded to bytes before use. Mutation is protected by a futex-based write-preferring lock with dead-process recovery so concurrent adds and merges are safe and crashes only lose the last incomplete operation. Merging folds another filter of identical geometry into yours by bitwise OR so multiple processes or producers and consumers can combine views. Be aware the mapped region is writable by any process that opens it so do not share backing files with untrusted parties. This is the initial release.

RT-Extension-AI brings conversational AI features into Request Tracker 6 so teams can summarize ticket threads, assess sentiment, get suggested or translated replies, autocomplete text while composing, and even have an interactive assistant build new queues for them. The extension works with any REST-based conversation API and ships preconfigured examples for OpenAI, Google Gemini, and Anthropic Claude, with per-queue and global configuration, customizable prompts, and optional context files to feed example ticket histories into suggestions. Features appear both as scrip actions that update tickets automatically and as CKEditor toolbar tools for interactive use, and there is a beta natural-language search that turns plain English into TicketSQL queries. Be aware that some features can send large inputs to your AI provider so you should test token usage and limits before enabling broadly, and the natural-language search currently cannot infer your site-specific queue and custom field names unless you include them. Installation follows standard RT plugin steps and the extension is provided and supported by Best Practical Solutions.