CPANscan

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.

Log::Any::Adapter::JSONLines is a lightweight Log::Any adapter that writes each log entry as a single JSON object on its own line, following the JSON Lines format, and it defaults to printing to STDOUT but can write to any file or filehandle you provide. It works with Log::Any structured logging and context data and lets you tweak records with before and proxy hooks so you can add metadata, mask sensitive fields or insert location info just before serialization. You can set the log level, output encoding, and optionally enable alphabetical key sorting for predictable output, and the adapter supports common use patterns where a message string and a data hash become a single JSON object. Be aware of a couple of limitations: passing more than two mixed arguments produces a messages array instead of a single message and formatted logging routines like debugf are not supported due to how Log::Any handles sprintf. This is an early release, version 0.001, and the module is still under development.

Travel::Status::DE::DBRIS is an unofficial Perl client for Deutsche Bahn's bahn.de departure monitor and train information APIs that makes it easy to fetch station departure boards, search for stations by name or coordinates, retrieve journey details, and request carriage formation data. It supports both blocking and non-blocking workflows so you can use it in simple scripts or integrate it into evented applications via promises and Mojo::UserAgent, and it offers useful options such as caching, an optional failure cache, filtering by mode of transit, limiting intermediate stops, and loading prepared JSON for testing. The module exposes high-level result objects for stations, journeys and formations and includes a developer_mode to print raw requests and responses for debugging. Be aware that this is a work in progress and that Deutsche Bahn’s recent Akamai WAF behavior can make frequent requests risky, so the module provides randomized headers and caching hooks to reduce that risk and a note of caution about caching failed requests permanently. The latest release updates rolling stock models and fixes mis-detected models for non-German carriages, improving carriage formation accuracy.

Net::Blossom::Server::Backend::Filesystem provides a filesystem-backed storage layer for Net::Blossom::Server that stores blob bytes as ordinary files while letting you use any compatible metadata store implementation, so you get simple, local file storage with pluggable metadata. It stages uploads under a configurable root, publishes immutable generation-specific keys via non-overwriting hard links, shards paths by the first four hex characters of the SHA-256 hash, and streams downloads from filehandles to avoid loading whole blobs into memory. The constructor requires a metadata_store and a base_url and accepts either a root directory for the default file-backed blob store or a custom blob_store object, and it supports custom filename-generation and a post-commit cleanup error handler. The design targets durability and safe concurrent writers on a POSIX filesystem that supports hard links and directory synchronization and has been tested on local Linux filesystems, so be cautious on multi-node filesystems such as NFS or CephFS. Use this module when you need a straightforward, efficient on-disk blob store with separate metadata management and streaming I/O.

Catalyst::Plugin::MCP adds a Model Context Protocol (MCP) server to a Catalyst application by levering Catalyst::Plugin::JSONRPC::Server and exposing a simple seam for registering per-request provider objects that supply tools, resources or prompts and for dispatching MCP requests. You call mcp_register_provider during an action to add providers for the current request and then call mcp_dispatch to build a fresh, request-local MCP engine, route the verb and write the response, which avoids cross-request handler leakage and concurrency hazards. The plugin reads and size-checks the request body for you unless you supply a raw JSON body, supports configurable protocol versions and advertised server_info, and requires that the application load Catalyst::Plugin::JSONRPC::Server first. It intentionally ships no authentication or Origin validation so you must protect the endpoint and validate Origin before dispatching. Recent releases tighten compatibility with the underlying JSONRPC server and now require Catalyst::Plugin::JSONRPC::Server 0.003 so mcp_dispatch can return the correct HTTP 202 empty-status for notification-only requests.

AWS::Lambda provides an easy path to run Perl code on AWS Lambda by supplying a custom runtime plus prebuilt Lambda layers, zip archives and container images so you can drop in a handler.pl or build a Docker image and deploy quickly. It bundles helpers to find the correct layer ARNs, preinstalls common modules such as JSON and AWS::XRay, supports streaming responses and X‑Ray tracing, and offers optional Paws layers for calling AWS APIs from your function. The distribution includes tooling for local testing with Docker and guidance for creating custom module layers, follows the Perl community policy for supported Perl releases, and targets Amazon Linux 2023 while marking older AL and AL2 layers as legacy and no longer maintained. The latest 0.10.0 release adds support for Perl 5.44.0 and performs a few dependency updates while temporarily removing two regions for safety.

Catalyst::Plugin::OAuth2::ResourceServer is a Catalyst plugin that makes it simple to protect routes with OAuth 2.1 bearer JWTs by verifying access tokens, checking audience and issuer, and exposing token claims, scopes, and an app-resolved identity to your controllers. It handles extraction of Bearer tokens, performs cryptographic verification with a configured signing key, provides helpers to require authentication and specific scopes, and emits RFC 6750 WWW-Authenticate challenges plus an RFC 9728 protected-resource metadata document served with Cache-Control no-store. Configuration covers signing_key, resource and issuer validation, allowed JWT algorithms, clock skew leeway, advertised authorization servers and scopes, and an optional metadata URL which is otherwise derived from the resource URI when possible. You can implement oauth_resolve_subject to map the token subject to an application identity which is important for enforcing revocation or account deactivation, and the actual verification engine lives in a separate Server module so this plugin remains a thin Catalyst integration layer. An examples directory provides a runnable demo to get you started.

Catalyst::Plugin::OAuth2::AuthorizationServer adds a ready-made OAuth 2.1 authorization server (MCP profile) to a Catalyst application, providing authorization_code with PKCE-S256 for public clients, refresh_token rotation, dynamic client registration and standard AS metadata endpoints so you can expose a discovery document, register clients and issue tokens from your app. It issues signed JWT access tokens using symmetric HMAC (HS256/HS384/HS512) only, so it is intended for single-deployment setups where the Authorization Server and Resource Server share a secret and not for scenarios where third parties must verify tokens via JWKS. The plugin wires protocol logic into Catalyst and expects your app to handle user authentication and consent via an oauth_authenticate hook that calls back to oauth_issue_code; an optional oauth_dcr_allow_registration hook can rate-limit dynamic registration. Note the important operational limits: refresh-token reuse revokes the entire token family and does not retroactively invalidate already-issued stateless access tokens so you should keep access_ttl short, there is no built-in revocation endpoint or denylist, and Store implementors must follow the module's Role::Store contract. Recent updates mostly clean up examples and documentation to use generic example scopes; earlier changes introduced stricter PKCE verifier validation, signing_key length checks and an updated Store contract to support refresh-token family revocation.

Catalyst::Plugin::JSONRPC::Server is a small plugin that adds JSON-RPC 2.0 request handling to Catalyst apps by giving your context two helpers, jsonrpc_register and jsonrpc_dispatch, so you can register method handlers inside a request and have the plugin parse, route and respond to JSON-RPC calls over HTTP. It builds a fresh dispatcher per request so handlers and any closures do not leak between requests, and you can tune behavior with configuration like max_body_bytes (default 10 MiB) or supply your own dispatcher to change limits such as max_batch (default 1000). Handlers receive the JSON-RPC params and return results or throw a Catalyst::Plugin::JSONRPC::Server::Error to signal JSON-RPC errors while a plain die becomes a guarded internal error. Dispatch writes the appropriate HTTP response, returning the response payload or undef for notifications, and there is a jsonrpc_dispatch_with method if you need to reuse or preconfigure a dispatcher. The distribution includes a runnable example app and client so you can see echo and sum handlers in action.

Arango::Tango is a lightweight Perl client that gives you a straightforward mapping to the ArangoDB REST API so you can create and manage servers, databases, collections and documents from Perl without a heavy dependency. It exposes a simple top-level object that returns Database and Collection objects and covers common tasks such as creating and deleting databases and collections, managing users and permissions, running queries and cursors, importing documents in bulk, and inspecting server and cluster metadata and statistics. The distribution focuses on practical, easy to use methods rather than covering every advanced feature and it validates options with JSON::Schema::Fit which may silently adjust inputs, and it will die on errors so callers should use eval or a try/catch wrapper. Recent work refactored error behavior and added a create_index method to create hash, skiplist, persistent and geo indexes. The module is intentionally minimalist and evolving so contributions and patches are welcome.

RPi::OLED::SSD1306::128_64 is a Perl driver for 128x64 SSD1306-based monochrome OLED panels on the Raspberry Pi that makes it easy to draw text and simple graphics from Perl. It uses a small bundled C layer and wiringPi to mirror the display's 1KB framebuffer on the Pi and push updates over I2C, and exposes simple methods for text, characters, pixels, lines, rectangles, display refresh and clearing so you can build and then push a whole frame. The module defaults to I2C address 0x3C, requires wiringPi (3.18+), supports dimming and inversion, and is implemented as a singleton so repeated new() calls return the same live display object. Recent improvements include a flicker-free clear_buffer/display workflow and a much faster display() that streams the full framebuffer in one I2C transaction for noticeably quicker refreshes.

BarefootJS::Backend::Xslate is a rendering backend that lets the BarefootJS runtime render Kolon (.tx) templates using Text::Xslate, without tying you to any web framework. It can take a prebuilt Text::Xslate instance or build one from a list of template paths and options, and it configures Xslate for HTML auto-escaping while providing a mark_raw helper for emitting raw markup. Templates compiled by the companion @barefootjs/xslate adapter call runtime helpers as methods on a bound bf object, so the backend needs no special function map and works equally well inside PSGI/Plack apps or in standalone scripts. The module exposes a small set of runtime operations such as render_named, encode_json (customizable), materialize, and mark_raw, making it a lightweight bridge between BarefootJS templates and Text::Xslate rendering.

BarefootJS is a lightweight server-side runtime that supports templates compiled from JSX/TSX into BarefootJS "marked" templates and accompanying client JavaScript. It supplies the runtime helpers those compiled templates call at render time, for tasks like JSON marshalling, marking raw strings, materializing JSX children, spreading attributes, and invoking named sub-templates. The design deliberately avoids locking you into a specific template engine or web framework by delegating engine- and framework-specific behavior to pluggable backends such as BarefootJS::Backend::Xslate for Text::Xslate or Mojolicious::Plugin::BarefootJS for Mojolicious, so the core itself only pulls in Perl core modules unless a chosen backend requires more. If you need to render JSX-style templates from Perl in a PSGI/Plack or Mojolicious app and want a minimal, backend-agnostic runtime, BarefootJS is a good fit and it is actively maintained under the MIT license.

Lingua::JA::Moji is a comprehensive Perl toolkit for converting among the many written forms of Japanese text and related encodings, including romanized Japanese, hiragana, katakana, halfwidth and fullwidth kana, circled forms, braille, Japanese morse, wide ASCII, hentaigana, and a range of kanji variants such as pre- and post‑1949 forms and bracketed/circled kanji, and it also offers experimental mappings to Cyrillic and Hangul; it provides validators and normalizers for romaji with multiple strictness levels and supports several romanization styles like Hepburn and Kunrei, while expecting Unicode (UTF-8) input and loading conversion data on demand to avoid heavy memory use. The module does not attempt to convert kanji into kana readings or perform morphological segmentation for accurate braille, and some experimental conversions warn of limited correctness. A small but useful recent change in version 0.62 makes is_romaji_semistrict return a canonical romaji form rather than a simple true value when the input is accepted.

Langertha is a unified Perl toolkit for talking to modern large language models and local inference servers that hides provider differences behind a consistent API. It lets you do chat, streaming, embeddings, transcription and image generation across many engines (OpenAI, Anthropic, Gemini, Ollama, Groq, Mistral, HuggingFace, Replicate, vLLM, and more) and includes support for tool/function calling, automatic multi-round MCP tool loops, and an autonomous agent called Raider with history, compression and plugins. The library provides sync and async APIs, streaming iterators/callbacks, response objects that carry token usage and rate‑limit info, a plugin system and Langfuse observability hooks, and dynamic discovery of third‑party engine extensions under LangerthaX. The project is still a work in progress, but recent fixes include correct parsing of OpenAI's Responses API function_call output so tool calls work reliably with reasoning-only models such as gpt-5.5-pro. If you need a single Perl surface to experiment with multiple LLM providers, tool-calling agents, or to add observability and structured outputs, Langertha is designed to make that integration straightforward.

AI::Anthropic is a lightweight Perl client for Anthropic's Claude API that makes it easy to send single messages or full chat conversations to Claude models such as Claude 4 Opus, Sonnet, and Haiku. It exposes simple methods like message and chat, handles model selection and parameters like max_tokens, temperature, and timeout, and supports streaming responses, image (vision) inputs, and tool or function-calling workflows. You can provide your API key when creating the object or via the ANTHROPIC_API_KEY environment variable, and the module can also list available models. If you want to integrate Claude into Perl scripts, chatbots, or services, this module provides a straightforward, high-level interface. The initial 0.01 release includes support for the messages API, streaming, vision, and tools.

CANBUS is a small Perl extension that provides a straightforward way to send and receive Controller Area Network (CAN) messages on Linux by wrapping the system CAN socket API. It exposes functions in the CANBUS namespace to open and bind a socket to a named interface, transmit frames by ID with an arrayref of data bytes, read incoming frames, and close the socket. The module assumes a Linux environment with CAN interfaces configured and typically requires you to bring the interface up with ip link or use the can-utils tools beforehand. This minimal wrapper is useful when you need quick scripting access to CAN devices from Perl, and the package is at its initial 0.01 release.

PAGI::Nano is a compact Perl micro-framework built on PAGI-Tools for demos and small web apps of roughly under 20 endpoints. It gives you a simple DSL that returns an assembled PAGI app instead of mutating globals so apps are composable, nestable, and testable. It provides HTTP routing with named routes and path placeholders, raw handlers for full control, per-route and app-wide middleware, lifecycle hooks with a shared app state, static file serving, streaming, WebSocket and SSE support, and a tiny three-scope service registry. Handlers use sensible return-value coercion to JSON or text and the framework includes strong-parameters for asynchronous input parsing. Builders run eagerly at startup and must be synchronous, there is no automatic service teardown, and mounted Nano apps do not run their own startup/shutdown or declare services, so it is best suited to small, self-contained apps that benefit from a readable single-file structure while still exposing the underlying PAGI primitives when you need them.

PAGI::StructuredParameters is a lightweight, no-dependency Perl utility that whitelists and reshapes incoming request parameters into well-formed nested data before they reach your model or validator. It understands flat form and query keys like "name.first" and "email[0]" and reconstructs them into nested hashes and arrays while simply whitelisting already-nested bodies such as decoded JSON. You interact with it through a lenient permitted() call or a strict required() call that invokes a caller-supplied callback for missing keys, and there are convenient request adapters for body, query, or decoded-data sources with async support. The module also offers sane defaults for array flattening and protects you from abusive input with a configurable maximum array depth that raises an exception when exceeded. This initial release is a focused, decoupled port of the core of Catalyst::Utils::StructuredParameters intended to sit upstream of validation rather than perform validation itself.

DBIx::Class::Valiant plugs the Valiant validation system into DBIx::Class so you can declare filters and validations on your result classes or columns and have them run automatically when records are created or updated. If validation fails the database operation is aborted and you get back the DBIC result object with the attempted values and an errors collection you can inspect, which makes wiring server-side form handling and error reporting straightforward. It also supports nested creates and updates with accept_nested_for, aggregates errors across related records and will roll back the whole changeset on failure, and it honors validation contexts like create and update. You can declare validations inline in add_columns, use it schema-wide by adding components to base result/resultset classes, and it integrates with DBIx::Class::Candy. Be aware nested validation support and many-to-many handling are still evolving and require careful use of prefetch and parameter sanitization to avoid edge cases and security issues.

Valiant is a domain-level validation framework for Moo or Moose objects that gives you a compact, Rails-style DSL to declare attribute and model validations, apply input filters, and collect human-friendly error messages instead of raising exceptions at construction time. You can write simple coderefs, reuse or extend validator classes, or plug in Type::Tiny constraints, and Valiant bundles many common validators plus internationalization, nested object/array support, an Errors collection with message formatting and JSON output, and helpers for generating HTML form elements. It is intended for business-logic and form validation where invalid but well-formed objects must be reported back to users rather than aborting execution. Note that the project recently refocused the distribution so the core framework is now framework-agnostic and ORM/web integrations such as DBIx::Class::Valiant have been split into separate distributions, so upgrading may require installing those companion dists.

PAGI::Middleware::Session::Store::Cookie provides a simple way to keep session data on the client by encrypting it into the cookie so you can avoid server-side session storage. It uses AES-256-GCM for authenticated encryption and derives the key from a required secret you pass to new(), and its async API returns Futures for set (which produces the encrypted blob to store in the cookie), get (which accepts that blob and returns the decoded session hash or undef on tampering) and delete (a no-op for cookie-backed sessions). Because everything lives in the cookie you must keep session payloads small to avoid the roughly 4KB browser cookie limit and you cannot revoke sessions without introducing server-side state such as a blocklist. Recent important fixes include replacing an insecure rand() fallback with Crypt::PRNG to generate IVs (security fix CVE-2026-5087) and declaring the PAGI::Tools runtime dependency to prevent installation/runtime failures.

PAGI::Tools is a convenience toolkit for building applications on top of PAGI, the Perl Asynchronous Gateway Interface, that saves you from hand-emitting low-level protocol events by providing request and response objects, routing, a middleware suite, high-level endpoint helpers for HTTP, SSE and WebSocket, test utilities, and assorted composition and lifespan helpers. It lets you write normal handler code or mount ready-made apps and responses, then run them on any PAGI server or embed them inside larger PAGI apps, so authors exploring PAGI or building higher-level frameworks get a consistent, ergonomic base. Recent notable changes include the distribution split that formalized PAGI::Tools as its own package and a breaking API shift where PAGI::Response is a value and endpoint handlers return response values instead of sending them directly, so upgrading callers should check the new return-and-respond pattern. The toolkit continues to evolve with practical fixes and features such as better session handling for non-HTTP scopes, improved CSRF options, and a new constant-time compare utility used by security-sensitive components.

RPi::PWM::PCA9685 is a pure-Perl driver for the NXP PCA9685 16-channel, 12-bit PWM and servo controller accessed over I2C from a Raspberry Pi. It gives a simple object interface to set a single PWM frequency for all channels and control per-channel duty, phase or raw on/off ticks at 4096 resolution so LEDs and hobby servos are driven in hardware with almost no CPU overhead. The module supports percentage or tick duty settings, microsecond servo pulses, hard on/off, phase control, inversion and an open-drain sink_mode for wiring LEDs to an external supply, and it exposes low-level register access plus sleep, wake and reset operations. It is pure Perl but uses RPi::I2C for the bus transport so it runs on Linux, and new() wakes and verifies the chip for you. This initial release adds the OO API, examples and documentation, bundled datasheet, and the new drive and sink_mode conveniences, making the module a practical choice if you want to manage many PWM channels from a Pi without writing low-level I2C code.