CPANscan

App::Netdisco is an open source, web‑based network management application that discovers devices via SNMP and stores collected data in PostgreSQL so you can locate machines by MAC or IP, see the switch port they use, manage ports (shutdown, VLAN, PoE), inventory hardware, and generate network diagrams. It bundles a web frontend with a built‑in server and a backend daemon for polling and performing actions, and it supports plugins, a DBIx::Class database API, Docker images for easy deployment, and an online demo to try before installing. The project targets administrators of real networks, documents installation and upgrade steps, and requires Perl 5.10+ and PostgreSQL 9.6+ with additional system packages for full functionality.

Punk is a lightweight, performance-focused MVC web framework for Perl that compiles and freezes routes, guard chains, handlers, helpers and mounts at to_app time so dispatch is a simple fast lookup with no per-request interpretation. It gives a compact DSL for HTTP routes plus WebSocket and Server-Sent Events endpoints, guard scopes, static mounts, view engines, model backends and plugins and can mount OpenAPI 3.1 specs to auto-generate controller stubs and validate requests. Built-in features include signed cookie sessions, single-use CSRF tokens, CORS handling, an outbound user agent per worker and an async-friendly runtime based on futures so handlers can await work without pinning a worker when run on an evented server such as Hyperman. The distribution ships a generator that scaffolds a running app, plus CLI commands for development, route inspection and config checking, and it supports non-blocking model backends like DBIx::Loop. Recent fixes in 0.05 addressed a segfault on older Perls and updated dependency minimums to improve installability.

ClarID::Tools is a reference implementation and command-line toolkit for the ClarID specification, which defines compact, human-readable identifiers to make biomedical metadata integration more consistent and interoperable. The distribution provides a CLI for generating and validating ClarIDs, CSV preprocessing utilities and bulk export helpers, versioned codebooks and schemas, and a Docker image to simplify reproducible workflows. It supports multiple codebook versions and focuses on consistent encoding and platform-independent outputs, so it is useful if you manage samples, specimens, experimental records or other biomedical metadata and need concise persistent identifiers. Recent 0.04 updates migrated the documentation to Docusaurus, added the 0.04 codebook/schema family with stricter duration formatting, expanded CSV preprocessing support (including Python deps in the Docker image), and synchronized CPAN and Docker builds; the package declares Perl 5.32 as the minimum tested version. The author requests that published work using ClarID-Tools cite the accompanying journal article.

Circle::Miner is a small Perl module that integrates basic mining workflows for the Circle blockchain into your Perl programs. It lets you fetch a block to mine for a given wallet address, run a mining step using an external mining binary with optional multi-process threading to search nonces, and post a successfully mined block back to the network. The API is straightforward with methods to create a miner object, fetch a mineable block, perform mining (the mined result is read from a local mined.txt file) and submit the block, and the submit method enforces a 34-character address that begins with "1". This module is useful if you want to automate mining tasks from Perl but you must provide the OS/architecture-specific external miner executable it depends on. The recent 0.03 release mainly revamps the documentation and earlier updates added common debug configuration.

Circle::User is a Perl module in the Circle::Chain SDK that handles common user account tasks such as sending verification codes, registering and logging in (by password or one-time code), logging out, setting and checking a payment password, resetting passwords, and managing contacts and user profile data. Its API exports a set of simple functions that return response hashes with HTTP-like status codes so you can check success or error conditions easily. The module supports sending codes by email and by phone with phone registration limited to mainland China. Use it alongside the other Circle modules like Circle::Common, Circle::Wallet and Circle::Block when building applications on the Circle platform.

Lingua::Lapine::Word is a small utility for representing and managing words in the fictional Lapine language. You construct canonical word objects with new (for example new(string => 'Frith') or from another object), and the module deduplicates instances so identical words share a single object. Words can be registered to remain in memory for later lookups and the class method known lets you enumerate known words or all known items. A natural_language method returns the language tag (Lapine) so the objects play nicely with other Lingua modules. This is an initial v0.01 release aimed at projects that need a simple, consistent way to model and track Lapine vocabulary.

File::Sticker is a Perl toolkit for reading and writing file metadata and keeping a synchronized database of that information, making it easy to manage metadata across many files in a standardized way. It can extract metadata from files, add, replace or delete fields including multi-value tags, derive new values via plugins, and write changes back into files. It also exposes database operations such as updating or removing file records, querying by tag expressions, listing faceted tags, checking for missing or overlooked files, and moving files while updating the DB. A small internal selector picks the appropriate "scribe" for a file type and derive_values can compute metadata without modifying the input, so this module is a good fit when you need scriptable, centralized control and searchability of file metadata.

PlackX::Framework is a lightweight micro‑framework built on Plack for creating PSGI web applications. It wires together a handler, request and response objects, and a small routing DSL so you can define routes and filters with minimal ceremony and call MyApp->app to get a PSGI app. Request and response objects extend Plack::Request and Plack::Response and provide a per-request stash and a flash cookie helper. The framework will auto‑create or load MyApp::Handler, ::Request, ::Response, ::Router and other pieces in your application namespace to keep setup simple. Template Toolkit support, URI helpers and a simple config layer are optional and pluggable so you can add them only when needed. The project favors low memory use and fast startup compared with larger frameworks and keeps dependencies small. It is still marked experimental and recent releases have focused on documentation and test fixes with the distribution published to CPAN in 2026.

App::news supplies small utility routines used by the script/news package that powers a web front end for a news server. Its primary tool is wrap, a plain-text reformatter for mail and news bodies that leaves short lines alone, wraps longer lines to about 72 characters, and preserves quoted blocks when they use the customary ">" marker. The module also offers ranges and sranges helpers to turn lists of message numbers into arrays suitable for XOVER queries and to convert those arrays back into compact, human-readable range strings like "1-2,4". The module is authored by Alex Schroeder and distributed under the GNU Affero GPL.

Cache::FastMmap provides a fast, shared memory cache by mmap'ing a file so multiple processes, such as mod_perl workers or forking daemons, can read and write a common key/value store with very low overhead. Its core is written in C and uses per-page fcntl locks and an LRU scheme to keep contention and eviction costs down, and it supports serializers and compressors (Storable, Sereal, JSON and zlib, lz4, Snappy or custom hooks) plus read-through and write-back or write-through callbacks to integrate with an underlying datastore. It includes atomic operations like get_and_set, batch helpers multi_get/multi_set, and helpful features such as optional stats, explicit expiry, and platform support for Unix and Windows. Be aware that items cannot be larger than a page so choose page sizes to fit your keys and values and consider placing the backing file on tmpfs to avoid disk writes and apparent large RSS sizes. Recent releases add tombstone and 64-bit modseq support to prevent stale write-back races by making remove() and conditional set() record and respect change sequence numbers, so upgrade all processes sharing a cache file before using those features.

WebService::Client is a lightweight Moo role that wraps common HTTP client boilerplate so you can build API-specific clients quickly. Compose it into your class, set the required base_url and any auth headers in BUILD, and you get convenient get, post, put, patch, delete, head and options methods that handle request construction, optional JSON serialization via JSON::MaybeXS, and response deserialization for you; by default these methods return decoded Perl data structures while a special "v2" mode returns a Response object. The role provides a default LWP::UserAgent, accepts settings like timeout, retries, logger, content_type, array_query_style (php or rfc) and custom serializer/deserializer coderefs, and it raises HTTP::Response exceptions for error responses except that GETs returning 404 or 410 yield undef. If you need a simple, tested foundation for talking to RESTful services this role saves you from rewriting the same request, header and encoding handling, and the recent 1.0100 release added head and options support and improved header, content-type and query-encoding behavior.

Lemonldap::NG::Portal is the portal component of the Lemonldap::NG Web‑SSO system that provides a ready-made, extensible way to handle web authentication, authorization and accounting for protecting web applications. It runs as a PSGI/Plack application and wires together configurable authentication backends, user databases and optional plugins so you can add LDAP, CAS, Apache auth, multi‑auth setups, password management, notifications and second‑factor modules without rewriting your apps. The portal manages sessions, produces headers for downstream applications, supports AJAX JSON responses or HTML templates, and reloads configuration and plugins cleanly at runtime. If you need a mature, plugin‑driven single sign‑on portal to centralize login, access control and session handling across multiple web services, this module is directly relevant and provides the hooks and documentation needed to customize authentication and UserDB plugins. Recent development added more flexible auth and userDB modules, password plugin support and notification and session handling improvements.

Lemonldap::NG::Manager is the web-based administration interface for the Lemonldap::NG Web-SSO platform, implemented as a PSGI/Plack REST server with an AngularJS front end. It exposes a documented REST API and bundles front-end static files plus tools to generate configuration trees, making it easy to manage sites, virtual hosts, SAML and OIDC partners, sessions, notifications and second-factor settings from a browser. You can run it with plackup or any Plack launcher and override settings via the lemonldap-ng.ini file or by passing an options hash to run(), with manager-specific options for access protection, enabled modules, languages, logging and template locations. The distribution also includes a configuration builder and CLI helpers for automation and a script to pre-generate the static structure used by the UI. Note that older SOAP support was removed and replaced by the portal/REST approach as of the 0.9 series.

Lemonldap::NG::Handler is the Apache protection module of the Lemonldap::NG Web Single Sign-On system and here serves as an alias for the ApacheMP2 implementation. It plugs into Apache to protect web resources, enforce SSO and session rules, perform redirects and logins, and integrate with the Lemonldap::NG manager and shared configuration so you can centrally control access across sites and virtual hosts. The project supports Apache 1 and 2 environments and common deployment needs such as CGI handling, proxying, cross-domain authentication, logout coordination, and features added in recent releases like SOAP-based basic auth, POST-based login for non‑compatible apps, enhanced logging, and a double-session mechanism. The module is GPL‑licensed and is maintained by the LemonLDAP::NG team; use the project site and OW2 issue tracker to download it or report bugs.

Lemonldap::NG::Common is the shared resource package for the Lemonldap::NG Web single sign-on system, providing the common configuration files, templates and support scripts used by the Manager, Portal and Handler components. It is not a standalone SSO service but a required part of a Lemonldap::NG deployment or customization, so install it when you are setting up or extending Lemonldap::NG on Apache to keep components consistent and avoid duplicating common assets. The project is open source under the GNU GPL and you can find downloads and report issues via the Lemonldap::NG and OW2 GitLab pages.

App::karr is the core library behind the karr command line tool that implements a Git-native kanban board stored under refs/karr/*. Tasks are Markdown payloads with YAML frontmatter and board configuration is kept sparsely in refs rather than as files in the working tree. Commands materialize a temporary view, let you create, move, claim and log cards, then serialize changes back into Git refs so the repo stays free of a persistent board tree and ordinary file-level merge conflicts are avoided. The distribution exposes reusable components for automation such as App::karr::Git for low-level ref work, App::karr::BoardStore for loading and saving tasks, and App::karr::Task for task objects, and it ships the karr CLI and Docker runtime images for running agents or embedding karr into other environments. Use this when you want your issue or kanban state to remain Git as source of truth without adding tracked files to the project. The recent 0.500 release focuses on robustness and interoperability, fixing UTF-8 handling, making restores and ref writes atomic, strengthening concurrency with compare-and-swap for id allocation and log writes, improving locking and board-identity checks to avoid accidental wipes, and generally hardening the tool for multi-clone and automated-agent use.

Lingua::Generic::Interface is a lightweight Perl abstraction that defines a common, language-agnostic API for accessing and manipulating linguistic data, letting you write tools that work with different languages or backends without changing application logic. The module itself does not perform language processing but specifies the standard methods and behaviors that language-specific implementations can follow so they interoperate cleanly. This is useful when building multilingual pipelines, adapter layers, or plugin systems that must remain agnostic to particular language resources. The package is an initial release (v0.01) and is distributed under the Artistic License 2.0.

Mozilla::CA provides a ready-to-use copy of Mozilla's trusted Certificate Authority bundle in PEM format so OpenSSL-based Perl modules can verify TLS server certificates; the module exports a single function, SSL_ca_file(), which returns the absolute path to the bundled PEM file for use with clients like IO::Socket::SSL or LWP::UserAgent to enable standard certificate validation and hostname checks. The bundle is regularly updated from Mozilla, most recently refreshed on 2026-08-13 with additions and removals of root certificates to reflect current trust decisions. The distributed CA data and the module are licensed under the Mozilla Public License 2.0.

MCP::Run is a Perl base class that makes it simple to expose a command-execution tool over the MCP protocol so other processes can ask the server to run shell commands and receive exit code, stdout, and stderr. It registers a configurable "run" tool that accepts a command plus optional working directory and timeout, and subclasses provide the actual execution by implementing an execute method; MCP::Run::Bash is the provided ready-to-use implementation that runs commands under bash. The module offers security and policy hooks via an allowed_commands whitelist and a validator coderef, lets you set sensible defaults for working directory and timeout, and provides a format_result hook to control the returned text. It also integrates optional output compression and filtering aimed at making command output more compact and LLM-friendly, and it includes convenience entry points for running as a stdio MCP server or installing compression hooks. The recent 0.104 release cleans up compressor behavior by normalizing undef streams and avoiding warnings when transforms drop lines, and it fixes filter resolution so the most specific command filters reliably win.

OpenAPI::Modern lets you validate HTTP requests and responses against an OpenAPI v3.0, v3.1 or v3.2 document at runtime. It loads your OpenAPI spec and uses the JSON::Schema::Modern evaluator to check request and response bodies, headers and parameters, returning a structured result object with a pass/fail flag, detailed error locations and the deserialized data extracted from the message. It works natively with Mojolicious message objects and can convert common framework request and response types, supports multipart bodies, media-type content encoding, bundled metaschemas and caching for large specs, and offers options for debugging and populating defaults. This module is useful for API servers, clients and test suites that need automated conformance checks or runtime introspection. Note that message parsing is performed with Mojolicious objects so parsing raw network messages into Mojo::Message is recommended, a few uncommon OpenAPI features are not yet implemented, and the module does not itself enforce Authorization header schemes.

require::relative is a tiny Perl helper that lets you require files using relative paths, so you can pull in a nearby script such as a shared test helper without converting to an absolute path or fiddling with @INC. It is aimed at test suites and other situations where multiple files share configuration or setup, and lets you include those shared files with a simple use require::relative "../test-helper.pl".

Device::Chip::BME280 is a Perl driver for the Bosch BME280 environmental sensor that talks to a host over I2C. It builds on the BMP280 driver to add humidity support while inheriting temperature and pressure features, and it is designed for asynchronous use returning Future objects for operations such as mounting an adapter, reading converted sensor values with read_sensor (pressure in Pascals, temperature in degrees Celsius, humidity in percent) and reading raw ADC values for testing with read_raw. You can read or change chip configuration including humidity oversampling via OSRS_H and mount with a non-default I2C address if needed. Recent updates also add automatic handling of BMP280 variants and detection of failed sensors that report all-zero ADC readings.

Text::Hogan is a Perl port of Twitter's hogan.js that brings Mustache templating to Perl by compiling templates into pure Perl code for very fast rendering. It implements the full Mustache specification, including lambda sections, and aims to behave statement-for-statement like hogan.js so templates are portable between the JavaScript and Perl ecosystems. The module is useful when you need simple logic-less templates, want to precompile templates for repeated high-performance rendering, or require compatibility with existing hogan templates. Recent releases focus on modernizing dependencies and improving compile and runtime speed, so it is a mature, actively maintained choice for Mustache templating in Perl.

Scalar::ValueTags lets you attach metadata to Perl scalar values so that provenance or other annotations travel with the value whenever it is assigned or combined with other values. You register a value-tags type that defines how tags are stored and merged and then use simple functions to add, remove, query, or clear tags; available behaviors include unique string sets, counted hashes, append-only arrays, and de-duplicated reference arrays so you can choose the merging and storage model that fits your needs. It is useful for tracking data flow, auditing, or applying source-based access logic without changing the underlying data structures. The implementation relies on Perl core value-magic (Magic v2) so you should check value_tags_enabled to confirm support on your Perl build. The author notes that the module currently does not throw automatically if value tags are unavailable and that debugging support is not yet implemented.

Dist::Starter is a lightweight command-line utility for bootstrapping Perl distribution skeletons from reusable templates, providing a diststarter script that accepts a distribution or module name and fills a template with sensible defaults for abstract, author, license, minimum Perl version, initial version and more. It can derive author info from the system GECOS, git config or environment variables, supports custom template and output directories, and offers a dry-run mode that prints the generated context as YAML so you can inspect values before writing files. Defaults are configurable via an XDG-style run-control file and templates can include additional "share" placeholders for richer scaffolding. The module is currently alpha and still documents a few TODOs, and the recent 0.2.0 release added license and initial-version options, improved author info handling, introduced share placeholders and now normalizes a provided module name to a distribution name.

Acrux is a compact Perl utility collection that supplies building blocks for application development, offering logging, file locking, a Damm checkdigit/digest implementation and small helpers for parsing and formatting so you do not have to reinvent common chores. It is presented as a companion to Acme::Crux and aims to be a lightweight, practical toolkit for developers who need simple, well scoped services such as configurable logging backends, lock file management and utility routines. Recent updates added a richer file lock metadata (including owner UID) and an optional system-level flock mode, and the logging defaults were changed to STDERR with explicit options to target stdout, stderr or syslog if needed. The project is actively maintained and distributed under the Artistic License 2.0, so Acrux is worth a look if you want straightforward, reusable utilities to support Perl applications.

Business::NAB is a Perl namespace that bundles a set of modules for reading and creating the file formats used to exchange payments and reports with the National Australia Bank. The top‑level package itself does not implement logic but links to focused modules for BPAY batch payments and remittance files, Australian Direct Entry payments, returns and reports, account information (NAI/BAI2) files, and XML acknowledgements. A companion Types package provides reusable type constraints for the namespace. Use this distribution when you need to build, parse, or validate NAB interchange files from Perl, and note the project is open source with source and contribution information available on GitHub.

IO::K8s provides typed Perl objects and serialization tools that model the Kubernetes API so you can build, validate, serialize and deserialize Kubernetes resources with correct JSON types and predictable structure. It lets you create API objects programmatically, inflate JSON or Perl hashes into typed objects, load and validate YAML manifests (including multi-document files), export to YAML or JSON, and extend support for Custom Resource Definitions either by writing small APIObject-based classes or by auto-generating classes from a cluster OpenAPI spec. The module also supports pluggable resource maps so third-party CRD providers like Cilium can be merged in, and it includes a compact Perl DSL for manifest files (.pk8s) when you prefer code over YAML. IO::K8s uses Moo for light, fast classes and is designed to work with Kubernetes::REST for sending requests to clusters. Noteworthy in the recent 1.105 release is the removal of legacy individual *List classes in favor of the unified IO::K8s::List and a full sync to Kubernetes v1.36 plus related CRD provider updates; if you still depend on the old list class names install IO::K8s::Deprecated for compatibility guidance.

Business::ISBN::Data is a data-only companion for Business::ISBN that provides the official ISBN group and publisher ranges drawn from the ISBN Agency's RangeMessage.xml so Business::ISBN can parse and validate ISBNs correctly. It is normally loaded automatically by Business::ISBN and contains a built-in fallback dataset but you can point it at a newer or alternate RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable before loading, or drop a RangeMessage.xml in the current directory for bundled apps. You must use Business::ISBN 3.005 or later because of a data-structure change that fixed ISBN-13 handling. The data are refreshed regularly to match ISBN Agency updates, making this module useful whenever you need accurate, up-to-date ISBN range information in Perl.

CXC::Astro::Regions is a Perl library for describing and manipulating the geometric "regions" astronomers use to mark sources and areas of interest in image and data analysis, making it easy to generate DS9, CIAO, and CFITSIO style region descriptions from Perl code or to convert between those formats. It targets common tasks such as building region files, applying region-based filters to data, and integrating region definitions into processing pipelines, and it includes format-specific helpers (CXC::Astro::Regions::DS9, ::CIAO, ::CFITSIO) so you can produce output compatible with popular astronomy tools. A recent enhancement adds CFITSIO support for using circle, box, and ellipse regions as FITS row-filter functions with extra parameters for column names, and note that a prior release renamed several DS9 parameter names which may require updating older scripts.