CPANscan

App::HTTPThis is the small engine behind the http_this command that makes it trivial to run a local HTTP server to serve a directory and optional directory indexes. It is essentially a thin wrapper around Plack::App::DirectoryIndex and exposes command line and config-file options to control host, port, whether autoindexing is enabled, prettier listings, Bonjour name publishing, and special handling for Windows Subsystem for Linux networking. The module defaults to binding to localhost for safety but you can restore all-interfaces behavior with a flag, and recent releases added a --host option and a --wsl mode plus improved config handling so command-line options take precedence. If you need a quick, no-friction way to share files, preview static sites, or run a tiny local web server, App::HTTPThis via the http_this command is a convenient choice.

lazy is a tiny convenience module that automatically installs missing Perl modules at runtime by delegating to App::cpm, so you can run one-off scripts without manually resolving dependencies. You can enable it on the command line with -Mlazy, in code with use lazy, or globally for test runs via PERL5OPT, and it supports installing into a local::lib directory with -L or passing extra App::cpm options through the import. By default it installs modules globally unless local::lib is already in use, making it handy for quick development and ad hoc testing but not intended to be left enabled in production. The recent 1.000002 release adds compatibility safeguards for older Perls by capping the App::cpm version on Perl < 5.24 and improves CI and test coverage to avoid breakage from newer cpm releases.

SimpleFlow is a compact, pure-Perl workflow helper that makes long shell pipelines easier to run, debug and reproduce by turning each step into a single task() call that cheks inputs, runs your shell command, times it, captures stdout and stderr, records exit status and signal, and verifies the declared outputs. It returns a simple hashref describing what happened so your script can log, fail fast or continue, and it skips steps whose outputs already exist to make pipelines restartable while offering a dry-run mode for inspection. A helper say2 prints messages both to STDOUT and a supplied log file with file/line provenance, and task() accepts options to control failure behavior and overwriting. Because it runs the command with Perl's system() you are responsible for supplying cross-platform commands, but SimpleFlow itself includes portable status decoding and logging. Recent updates added a single-file convenience option output.file and removed the Term::ANSIColor dependency to simplify deployment.

Catalyst::Plugin::Static::File is a minimal Catalyst plugin that gives your application a simple serve_static_file method to send one specific static file from a controller. It will set Last-Modified and Content-Length headers, determine the MIME type with Plack::MIME unless you override it, and attach the file path to the filehandle so Plack middleware like XSendfile and ETag can optimize delivery. This plugin intentionally only handles a single file and will throw a fatal error if the file does not exist, it does not validate filenames and it does not log, so you must validate any external input and use middleware such as Plack::Middleware::ConditionalGET for conditional requests. Use it when you need a lightweight, explicit way to return a known static asset from application code rather than serving a whole static directory.

WebService::Fastly is a Perl client for Fastly's REST API that lets you automate and script almost everything you can do in the Fastly control panel, from creating and configuring services, domains, backends, logging endpoints, and VCL or Compute code to managing users, billing, WAF rules, observability metrics, KV stores, and notification integrations. The client is generated from Fastly's OpenAPI spec and kept up to date with the platform, so it is useful for CI/CD pipelines, operational tooling, and programmatic reporting. It is maintained by Fastly, licensed under MIT, and links back to Fastly's Developer Hub for the authoritative API reference. Recent updates add new notification integrations (Datadog, Jira, OpsGenie, Splunk On-Call), improved Next‑Gen WAF simulation and workspace/account search, expanded observability and Compute metrics, and new routing and event-mapping APIs, but note that releases sometimes include breaking changes such as defaults or removed metrics, so review the changelog before upgrading.

File::Unpack2 is a Perl library and command line unpacker that identifies files by MIME type rather than filename and recursively extracts a wide range of archive and wrapped formats such as bz2, gz, zip, tar, cpio, rpm, deb, cab, lzma, 7z, rar and many common document payloads, exposing all unpackable contents even through multiple nested layers. It relies on libmagic and the shared-mime-info database to recognize multi-level types and chooses either built-in handlers or external shell-script helpers to unpack efficiently while recording every extracted item in a JSON-formatted logfile. The module provides safety and configuration options for destination layout, maximum unpacked file size, filesystem free-space checks, permission modes, symlink handling and one-shot or dry-run modes, and it is easy to extend by adding custom helper scripts. The author notes the MIME recognition code has to work around competing magic databases and that the shipped helper list is not exhaustive, but the plugin model makes adding missing handlers straightforward.

POE::Component::Metabase::Relay::Server is a POE component that accepts CPAN Testers reports sent via Test::Reporter::Transport::Socket, deserializes the Storable payloads, queues them in a local DB and forwards them to a Metabase server for storage and analysis. It runs as a POE session, can create a SQLite queue automatically, binds to one or more addresses and ports, and uses an HTTP client or libcurl for submissions when available. You can control parallel submissions, disable automatic curl usage or disable relaying entirely, and register hooks so your session receives an event whenever a report arrives or the queue changes. Use this module when you need a lightweight, configurable relay to collect test reports locally and reliably submit them into a Metabase instance.

App::ZofCMS is a lightweight, plugin-based Perl web framework and templating system designed for small to medium sites and very limited hosting environments where installing CPAN modules, using SSH, or running SQL is not possible. It uses a single index.pl dispatcher, page templates expressed as Perl hashrefs that fill an HTML::Template base, and page-specific plugins so you only load the functionality you need. A helper script can build a ready-to-upload site bundle so you can deploy without installing extra modules on the server. The author warns they no longer intend to maintain ZofCMS and recommends modern alternatives like Mojolicious, Catalyst, Dancer or Dancer2 for new projects, but recent updates have kept the distribution working and a 2026 change removed the App::ZofCMS::Plugin::GoogleTime plugin after its upstream dependency disappeared from CPAN.

Perl::Critic::PolicyBundle::LoopsAndLabels is a convenience bundle of Perl::Critic policies that help keep loop control flow and label usage safe and readable. Install this bundle to enable checks that require explicit labels on loops that use next, last, or redo, that forbid those loop-control keywords inside non-loop constructs like bare blocks, do{}, eval{}, anonymous subs and map/grep, and that flag goto LABEL when the target label is inside a loop or block. These policies are configurable via your perlcriticrc so you can tune when labels are required or when particular keywords are allowed, and they help catch both surprising runtime behavior and patterns deprecated by modern Perl. Recent releases converted the distribution into this policy bundle, merged the bare-block controls policy, and added the check against goto into constructs which is deprecated and due to become a fatal error in Perl 5.44.

MIDI::RtMidi::FFI is a lightweight Perl binding to the RtMidi C library that lets Perl programs talk to realtime MIDI devices and virtual ports across platforms such as ALSA, JACK, CoreMIDI and Windows Multimedia. It exposes a near-direct FFI interface for creating input and output devices, enumerating and naming ports, opening and closing ports, sending messages and installing callbacks for incoming events, and it can create virtual ports where supported. You will need librtmidi version 4.0.0 or later and the module pairs well with Alien::RtMidi for installing the native library, while MIDI::RtMidi::FFI::Device offers a higher level object interface if you prefer OO usage. This release is alpha quality so expect possible crashes, memory issues and API changes while the interface stabilizes, but it is useful now for developers who need low-level, realtime MIDI access from Perl.

Sereal::Encoder is a high-performance binary serializer for Perl that turns complex Perl data structures into compact Sereal-format byte strings for fast storage or transport and works together with Sereal::Decoder to rehydrate them. It provides both an OO interface (recommended for speed) and functional wrappers and offers built‑in support for optional compression (Snappy, Zlib, Zstd), string deduplication, control over how blessed objects are handled, and a FREEZE/THAW callback mechanism so classes can customize how they are serialized. Advanced options let you trade CPU, memory, and output size, enable a best‑effort canonical representation for repeatable encodings, control recursion depth, and tune numeric and floating point handling; note that Perl’s fuzzy string/number semantics and aliasing mean canonicalization has caveats. The encoder is thread-safe, supports protocol versioning (protocol 5 adds better float handling and Perl 5.36 boolean support), and for best results you should upgrade Sereal::Decoder before upgrading to encoder protocol 5.

Sereal::Decoder is a high-performance Perl module for deserializing data encoded in the compact Sereal binary format, supporting protocol versions 1 through 4 and designed for speed and small output size. It provides an object-oriented decoder with functional wrappers for extra speed, can extract optional per-document headers, supports incremental parsing from strings or files, and exposes bytes_consumed so you can detect trailing data. The constructor accepts many safety and tuning options such as refusing or not blessing objects, disabling automatic THAW calls, restricting which classes may be thawed, UTF-8 validation, limits on recursion depth and maximum array, hash or string sizes, and options to share small integers or make results readonly. The module implements a FREEZE/THAW callback mechanism for custom object serialization and documents how thawing is ordered and controlled, and it aims to be robust to invalid input by throwing Perl exceptions rather than crashing while noting that Snappy decompression can still cause issues on corrupted compressed data. Thread safe on modern Perls, Sereal::Decoder is a good choice when you need a fast, feature rich and configurable binary deserializer for interoperable Perl data exchange.

Sereal is a high-performance, compact binary serialization system for Perl that makes it easy to encode and decode complex Perl data structures quickly and with small output size. The top-level Sereal module is a thin wrapper that ensures both Sereal::Encoder and Sereal::Decoder are loaded and gives you convenience helpers such as shared encoder/decoder objects via get_sereal_encoder and get_sereal_decoder, simple file read/write helpers, and optional functional interfaces for one-off encode/decode calls. It supports compression backends and is designed for speed, so the object-oriented interfaces or the sereal_encode_with_object and sereal_decode_with_object functions are recommended for best throughput. Encoder and decoder are released separately so you can upgrade the decoder first to avoid compatibility problems, which makes Sereal a good choice for Perl developers who need fast, compact, and reliable binary serialization for network transfer or persistent storage.

WebService::Ollama is a Perl client for the Ollama API that makes it simple to run and interact with local large language models. It offers an object oriented interface plus an exportable ollama() functional call and supports chat, completion, embeddings, multimodal image input, streaming responses with callbacks, and structured JSON or JSON-schema outputs. You can manage models locally by creating, copying, deleting, loading and unloading them, and you can register tools for function calling or let the client drive automatic tool execution via chat_with_tools. The module uses OLLAMA_URL and OLLAMA_MODEL environment variables by default and the recent 0.08 release added the functional API and tool registration/chat_with_tools support while making async dependencies required for async operation.

Sisimai is a Perl library that parses and normalizes email bounce messages into structured Perl objects or JSON so you can automatically extract who bounced, why, and when. It reads mailboxes, Maildir folders, individual eml files or raw input from STDIN and exposes a simple API where rise() returns decoded objects with fields like recipient, addresser, delivery status, reply code, reason, timestamp and origin, and dump() returns JSON. You can enable options to include successful deliveries or vacation autoresponses, add callback hooks to inspect or augment headers and per-message processing, and use helper methods to list supported decoding engines, map error text to a canonical reason, or get the module version. Sisimai is aimed at anyone who needs reliable, machine-readable bounce analysis for mail operations, reporting, or automated handling.

Perl::Critic::Policy::Performance::ProhibitRegexForSimpleSubstring is a Perl::Critic rule that detects uses of plain regular expression matches when a simple literal substring check would do and recommends using index() instead for better performance. It flags m// or bare // matches that contain only literal characters and no modifiers, while intentionally ignoring cases that require real regex features such as modifiers, character classes, quantifiers, anchors, groups, interpolation, alternation, substitutions or qr//; it also does not flag grouped expressions even if the group body is purely literal. The policy has no extra configuration, is part of the Perl-Critic-Policy-Performance-ProhibitRegexForSimpleSubstring distribution, and this 0.01 initial release was contributed by Dean Hamstead under the MIT license.

Encode::Wide is a lightweight Perl utility for turning non-ASCII text into plain 7-bit ASCII safe for HTML or XML by replacing wide characters with entity references. It provides two functions: wide_to_html emits named HTML entities when available and also escapes ampersands, angle brackets and quotes for safe embedding in HTML fragments, while wide_to_xml always emits hexadecimal numeric entities and folds en/em dashes to a simple hyphen so the output is valid XML. The functions accept Perl Unicode strings, raw UTF-8 byte strings or scalar references and by default normalize existing entities to avoid double-encoding. Optional flags let you preserve trusted markup (keep_hrefs) or keep apostrophes literal for JavaScript contexts (keep_apos for HTML only), and a complain callback lets you log unexpected characters. Be aware that keep_hrefs shifts trust to the caller and can create XSS risks if used on untrusted input, and the module is designed for text fragments not whole HTML documents. The recent 0.07 release tightened security by suppressing entity decode when keep_hrefs is set, fixed a ReDoS risk in the ampersand-handling regex, removed unsafe eval-style replacements, and added tests, command-line helper scripts and a few additional character mappings including the trade mark (TM) symbol.

App::GrepUtils is a tiny toolkit of command-line helpers that extend the familiar Unix grep for common small tasks, making grep workflows simpler and more convenient. The distribution provides three utilities: grep-nonblank to filter matches while skipping blank lines, grep-nonblank-clipboard to produce similar filtered output and place it on the system clipboard, and grep-terms to search for one or more terms with optional highlighting. If you often run quick ad-hoc text searches, copy matched results to the clipboard, or need multi-term highlighting without building complex grep pipelines, these lightweight wrappers save keystrokes and reduce boilerplate. The current release is 0.007 and newly adds grep-nonblank and grep-nonblank-clipboard.

Concierge::Users is a user-record manager that gives your app a simple CRUD API for user profiles and lets you choose how data is stored, with backends for SQLite, flat files, or per-user YAML so you can pick production-ready database storage or lightweight file formats. You run a one-time setup to define the storage location and the field schema, including built-in core and standard fields plus custom application fields, then load the generated config at runtime to register, fetch, update, list, and delete users. The module validates input with a variety of validator types and will either reject bad data or warn and drop invalid fields depending on configuration, and it supports skipping validation for bulk imports. It also auto-manages system timestamps, archives existing data on schema changes to avoid accidental loss, and integrates with the rest of the Concierge suite while remaining usable on its own.

Concierge::Sessions is a lightweight session manager for Perl that gives your application a simple, consistent service layer for creating, retrieving, deleting and cleaning up user sessions. It supports a production-ready SQLite backend via DBI and a file-based JSON backend for testing and small deployments, stores any JSON-serializable data, enforces one active session per user, and implements sliding-window expiration plus optional indefinite sessions for application-wide state. The API returns uniform hashrefs so callers can check success and get either a session object or a descriptive error message, and session objects expose methods to read, modify and save data which extends the timeout. The module is written for modern Perl and emphasizes performance and predictable behavior, and the latest release fixes a crash during program shutdown by guarding the SQLite handle in DESTROY.

Concierge::Auth is a tiny factory that loads and returns a live authentication backend instance when you give it a fully qualified class name. You call Concierge::Auth->new with backend => 'Concierge::Auth::Pwd' (or another backend class) and any other parameters are passed straight to that backend's constructor, and the returned object implements the standard auth contract so you call authenticate, is_id_known, enroll, change_credentials and revoke directly. The factory does no name guessing, supplies no defaults, and dynamically requires only the backend you name so unused auth code is never loaded. The distribution also provides Concierge::Auth::Base, which defines the backend contract and convenient generators for tokens and IDs, and Concierge::Auth::Pwd, a built-in file-backed password backend. Note that in v0.5.0 the module was redesigned from a monolithic password manager into this thin factory model, so existing code must now use a concrete backend class, and the recent v0.5.1 release made small internal cleanups and expanded test coverage.

Net::Blossom::Server::Backend::Postgres is a PostgreSQL-backed storage plugin for Net::Blossom::Server that keeps blob metadata and payloads in Postgres via DBI and DBD::Pg. It stores actual blob bytes as PostgreSQL large objects and provides Storage-compatible operations for starting uploads, committing validated blobs, streaming downloads (including ranged reads), peeking metadata, deleting owners or blobs, and listing a user’s descriptors. Downloads are streamed from the database so blob bodies do not have to be loaded into Perl memory, and uploads are imported transactionally after validation; each active download uses a cloned DBI connection and a read transaction so you must provision enough Postgres connections for your concurrency. The backend uses advisory locks to serialize uploads and deletes for the same hash, can deploy and migrate its schema automatically, and accepts either a DSN or an existing DBI handle at construction. This module is ideal when you want tight integration of blob bytes and metadata inside Postgres, though very large public media services may prefer storing blob data outside the metadata database.

Net::Blossom::Server::Backend::SQLite is a SQLite-backed storage implementation for Net::Blossom::Server that stores blob bytes and metadata in a local SQLite database via DBI and DBD::SQLite. It implements the server Storage contract and gives you the tools to begin uploads, commit validated blob metadata, fetch whole blobs or byte ranges, read descriptors, delete blobs or owners, and list blobs for a given key while exposing the DBI handle and a configurable public base URL. The module coordinates separate metadata and blob store components on one SQLite handle and accepts either a file path or an existing DBI connection. Calling deploy_schema will create the required tables and perform an automatic migration from older schemas, so you should back up before upgrading. This backend is best for self contained single node deployments, local development, and tests and can be suitable in production when blob sizes, traffic, and write concurrency are limited, but very large media archives or high traffic public servers will generally want Postgres or an external blob store.

DBIx::QuickORM is a DSL-driven builder for creating composable, reusable ORMs in Perl that lets you declare servers, databases, schemas, tables, columns, links, types, row classes and plugins in a concise, structured way. It supports introspection via an autofill mode so you can generate schema and row classes from an existing database, offers pluggable SQL dialects and DBI drivers for PostgreSQL, MySQL/MariaDB, SQLite and DuckDB, and includes features for controlling identity, defaults, lazy/omitted columns and volatile/generated columns. The builder supports variants so you can maintain multiple backend-specific flavors from the same definition and provides hooks for custom naming, plugins and custom type inflation/deflation. Full usage and worked examples start with DBIx::QuickORM::Manual::QuickStart. Be aware this project is still in early development and the API and behavior may change as it stabilizes.

Net::Blossom::Server is the framework‑neutral server core for the Blossom protocol that implements the HTTP operations you need to store, retrieve, list, mirror, and delete content while delegating actual storage to pluggable backends. Gateway adapters such as PSGI or PAGI translate native requests into Net::Blossom::Server::Request objects and this module handles PUT/GET/HEAD/DELETE and list endpoints, streams uploads with SHA‑256 calculation and optional size limits, supports a configurable mirror fetcher for origin downloads, and returns standardized JSON blob descriptors for clients. It requires a storage implementation that follows the Net::Blossom::Server::Storage contract and provides options for chunking, clocking, max upload and list limits, and pass-through uploader authorization so framework adapters can manage authentication. Recent updates split storage contracts into distinct metadata-store and blob-store component interfaces and moved object construction to Class::Tiny to simplify backend implementations and testing.

Concierge is a Perl service-layer orchestrator that wraps authentication, session handling, and user record storage behind a single, consistent API so applications never talk to those components directly. It coordinates an Argon2-based Auth, flexible Sessions (SQLite, file, or in-memory) and Users stores (SQLite, YAML, CSV/TSV) and provides simple lifecycle operations for visitors, guest sessions, and logged-in users while tracking active clients with persistent user_key tokens stored in a desk directory. Every method returns a predictable success/message hashref and user lifecycle calls return Concierge::Desk::User objects so your code can restore, upgrade, or log out users and transfer guest session data to authenticated accounts. The suite enforces a single-session-per-user policy, supports backend substitution for custom auth or storage implementations, and is extensible with additional components. In the recent v0.10.0 release the internal base scaffold was removed and a component method promotion feature was added so you can expose a curated subset of a component's methods directly on the Concierge object for convenience while retaining the full component API via its accessor.

Task::BeLike::GEEKRUTH is a CPAN task bundle that installs the collection of Perl tools and libraries Ruth Holloway uses to develop and release software. It gathers development infrastructure like git, cpanminus, perlbrew, Dist::Zilla and its plugins, Perl::Tidy and Perl::Critic, a PostgreSQL and DBIx::Class based database stack, and web app components such as Dancer2 and its plugins, Starman, JSON and templating helpers, plus common utility modules like Moo, Try::Tiny and YAML::Tiny. The goal is to recreate the author’s workstation and workflow quickly so you can follow her conventions for building, testing and releasing Perl applications. This is aimed at developers who want a ready-made dev toolchain rather than at end users, and the POD even lists Debian packages the author installs first to prepare a fresh machine.

Dancer2::Plugin::QuickORM is a small plugin that injects QuickORM-style convenience into Dancer2 web apps, making it easier to use QuickORM models inside route handlers without repetitive setup code. If you use the Dancer2 framework and want to access database-backed models with terse, familiar QuickORM syntax, this module wires that syntax into your app so you can write CRUD and model access more quickly and with less boilerplate. It is an early, lightweight release that expects Dancer2 and QuickORM to be available and is aimed at developers who want straightforward integration rather than a heavy, feature-rich ORM bridge.

Dancer2::Plugin::ContentCache is a Dancer2 plugin that lets your app cache rendered HTML or JSON responses and optionally redirect users to a cached GET URL after a POST to avoid double-posts and timeout-related resubmissions. It stores content through a pluggable driver interface with a bundled DBIx::Class driver by default so you can use the storage backend you prefer. The plugin provides simple route-level helpers like cache_and_redirect and cache_and_send plus utilities to set, retrieve and clean up cache entries, and it supports optional cache aging with a configurable default lifetime and a built-in retrieval route that can require login. Cache entries are immutable once created and cache aging requires driver support for creation and expiry timestamps. This is the initial 1.0.0 release and includes the DBIC/DBIx::Class driver.

App::SeismicUnixGui is a Perl/Tk graphical front end for the Seismic Unix toolkit that lets you pick and configure parameters for SU modules through windows and dialogs instead of editing command lines. It is aimed at users who process seismic reflection or signal data with Seismic Unix and prefer a visual way to assemble processing steps, inspect options, and reduce manual command-line editing. The package is in beta and uses Perl/Tk, a mature and freely available GUI framework, so it is a good fit if you already use Seismic Unix and want a simpler, more interactive way to set up processing tasks.