CPANscan

GraphQL::Houtou is an XS-backed GraphQL parser and high-performance execution toolkit for Perl that gives you a canonical Perl AST and a native VM for running compiled query programs. It is designed for real web apps and makes batching simple with a bundled DataLoader and an on_stall hook that collapses N+1 database lookups while still returning a synchronous response to callers. You can render responses directly as UTF-8 JSON bytes inside the XS lane to avoid building Perl data structures, expose a one-line PSGI endpoint with optional GraphiQL, and create persisted artifacts for maximum throughput either as fixed native bundles or as compiled programs for variable-bearing queries. Runtimes can be built for async promise-based resolvers or for a strict synchronous fast lane and include configurable cost limits and program caching for production safety. The module focuses on throughput and efficiency and reports large benchmark gains over pure Perl implementations. Current limitations in the 0.01 profile include no subscription execution or streaming transports, only POST for the PSGI adapter, recognition of only Promise::XS promises, fixed native bundles not supporting GraphQL variables, and no support for Perl ithreads, so use process-based concurrency for parallelism.

Terse::Runtime is the runtime component for the Terse project that provides the support code and environment needed to run Terse-based code under a standard Perl interpreter. It is intended to be installed alongside the main Terse distribution to satisfy runtime dependencies and to supply the lightweight helpers and initialization routines that Terse-generated modules expect. If you work with Terse or need to run code produced by the Terse toolchain this module is relevant, and you can find usage docs via perldoc Terse and report issues through the CPAN RT page; the module is distributed under the Artistic License 2.0.

Terse::Config is a lightweight configuration plugin for the Terse framework that gives your application a concise way to load and read settings. You typically subclass a backend such as Terse::Plugin::Config::YAML to load YAML files and then access values either with a find method that accepts path strings or by chained accessors on the data object, for example $terse->plugin('config')->data->path->to->key. It is intended for Perl developers building Terse-based applications who want a small, convention-driven config layer. The module is available on CPAN, maintained by LNATION, and distributed under the Artistic License 2.0. Report bugs through the CPAN RT tracker.

Terse::Plugin::UA is a small plugin for the Terse framework that exposes LWP::UserAgent style HTTP functionality to your Terse applications, letting models and controllers make simple GET and POST calls via a minimal API. It integrates with Terse config so you can supply paths from your configuration and pass parameters directly, for example calling $t->plugin('ua')->get or ->post with path and params, which keeps HTTP request logic tidy and consistent across your app. The module is lightweight and aimed at straightforward HTTP interactions inside Terse projects rather than advanced HTTP client features. The recent 0.04 release removed PAX headers.

Terse::Plugin::Glitch is a small plugin for the Terse framework that centralizes and standardizes error responses and logging by loading a configurable set of named responses from an external file (YAML or other supported formats). You add it to your Terse app or subclass it, point it at a glitch_config file and then call methods like call('unauthenticated') to obtain a response hash or logError to record a problem, which makes it easy to keep consistent, configurable error payloads across handlers. It is useful if you want a simple, declarative way to manage and reuse response templates in a Terse-based service. The recent 0.05 release simply removed PAX headers.

Terse::Plugin::DBI is a tiny adapter that brings Perl's DBI database access into the Terse web framework so your controllers and models can prepare and execute SQL directly. You subclass the plugin and supply a connect_info method that returns the DSN, username, and password, and then call $t->plugin('dbi')->prepare(...) from your code to get statement handles and run queries. This module is intentionally lightweight and is ideal when you want straightforward DBI access rather than a full ORM or heavy abstraction. It is released as version 0.05 under the Artistic License 2.0 and was recently updated to remove PAX headers.

Terse::Plugin::CHI is a lightweight plugin for the Terse web framework that adds simple response caching by leveraging the CHI caching system. It provides an easy, controller-level API so you can check for a cached response with plugin('cache')->get($t) and store the current response with plugin('cache')->set($t), letting handlers short-circuit repeat work and reduce database or compute overhead. The module is intentionally minimal and acts as a thin bridge to CHI backends, so it is most useful when you already use Terse and want a quick way to cache whole responses without building a custom caching layer. The most recent release only made a packaging cleanup to remove PAX headers.

Terse::Es is a lightweight Perl helper that makes it easy to hook an application up to Elasticsearch by providing simple base plugin and model classes to subclass. You supply connection info in a plugin and declare an index plus column metadata in a model, including display labels, field aliases and basic table or sort hints, and then call straightforward methods such as search to run queries and get results back in a usable form. The module is aimed at projects that want a terse, opinionated glue layer between their app and Elasticsearch rather than a full blown client library. The current 0.04 release only contains a packaging fix that removed PAX headers.

Terse::Static is a small module for the Terse Perl web framework that makes it easy to serve static assets like JavaScript, CSS, images, and HTML alongside your dynamic routes. It integrates with Terse controllers and views so you can map URLs to resources and declare content types using the same method attributes you already use, and it includes a memory-backed view for embedding assets plus a delayed static controller for on-demand delivery. If you use Terse and want a simple, framework-native way to expose static files without wiring up a separate server, this module provides a tidy, low-friction solution.

Terse::Headers is a lightweight plugin for the Terse Perl web framework that provides a simple way to manage HTTP response headers from your application. You attach an instance to your Terse app and then call its set method with the current request context to add or change headers, which makes it handy for middleware, authentication hooks, or any place you need to tweak response headers without boilerplate. The module is small and focused, documented via perldoc and its CPAN page, and the author accepts bug reports through CPAN's RT tracker.

Terse::View::TT is a lightweight adapter that lets Terse web applications render Template Toolkit templates as views. You create a view class that inherits from Terse::View::TT, configure Template Toolkit options such as a wrapper template, place your templates in the application source tree, and mark controller actions with view(tt) so template variables set on the response are available to your pages. The module fits into a PSGI/Plack deployment, so it works with common servers like Starman, and it is a simple way to use Template Toolkit layouts and template features within the Terse controller/view conventions.

Terse is a compact Perl web framework for quickly building JSON-style APIs on Plack, offering a simple, DSL-like way to define endpoints, manage authentication and sessions, and shape the JSON you return. It wraps request handling, parameter parsing and response serialization so you can set response fields directly, and it adds built-in logging, error helpers, redirects and pretty-printing. Terse also supports delayed responses for non-blocking servers and long-polling, has WebSocket handler hooks for realtime use, and provides plugin, model and view support so you can reuse code across apps. You can run it as a PSGI app or mount your own application object and supply custom auth/login/logout routines, making it a pragmatic choice when you want a lightweight, Plack-native toolkit for building RESTful JSON endpoints and simple realtime features in Perl.

CPANSA::DB is a tiny helper module that packages the CPAN Security Advisory reports as a ready-to-use Perl data structure so tools like CPAN::Audit can load and inspect advisory data easily. Its single db() subroutine returns a hashref containing the advisory records and the same data is also provided as a JSON file for non-Perl consumers. Releases are published on GitHub and include a GPG signature and GitHub attestations so you can verify the archive came from the official repository before trusting the data. If you need a simple, verifiable source of CPAN security advisories for auditing, scanning, or integration into your tooling, this module gives you that data in a straightforward form.

mb::JSON is a small, dependency-free JSON encoder and decoder for Perl 5.005_03 and later that is optimized for environments where more modern JSON modules are unavailable and that preserves UTF-8 multibyte text correctly. It exposes simple decode/parse and encode/stringify functions, provides singleton mb::JSON::true and mb::JSON::false objects to represent JSON booleans, and handles common JSON features like skipping a leading UTF-8 byte order mark, combining UTF-16 surrogate pairs into proper UTF-8, and returning Perl arrays and hashes for JSON arrays and objects. The module is configurable via $mb::JSON::MAX_DEPTH to protect against deep nesting and $mb::JSON::STRICT to enable UTF-8 validation and raw control character checks, and it reports circular references and refuses to encode non-finite numbers like Inf and NaN to avoid silent surprises. The recent 0.07 release made decoding linear-time on large inputs, tightened whitespace handling to match RFC 8259, added surrogate-pair support and better error diagnostics, and otherwise improves robustness while keeping the API intentionally simple and portable.

HTTP::Cookies is a simple cookie jar you can attach to Perl's LWP::UserAgent to record cookies sent by servers, apply the right Cookie headers to requests, and manage cookies programmatically, including adding, clearing, scanning, and saving or loading the jar to disk. It understands legacy Set-Cookie and Set-Cookie2 formats and supports RFC 2965 style cookies, and a Netscape-compatible save format is available via a subclass if you need browser-compatible files. The module gives you control over temporary versus persistent cookies, discard behavior, and expiry handling, but it does not implement public suffix checks from newer standards so it may allow cross-site tracking across top level domains. Recent releases fixed cookie lifetime handling so Max-Age is now honored when extracting cookies and Max-Age correctly takes precedence over Expires.

Sah::SchemaBundle::UUID is a small collection of Sah-compatible validation schemas for UUID/GUID values designed to plug into Data::Sah or any Sah-based validation workflow. The bundle currently offers a single schema, uuid::hexdigit, which validates UUIDs expressed as plain sequences of hexadecimal digits, making it useful for validating ID strings in APIs, configuration files, or data models that require simple, well-formed UUIDs. The distribution is intentionally minimal and focused, easy to include in existing Sah schema sets, and this is the initial 0.001 release with source on GitHub and a MetaCPAN page for more information.

SDL3 is a Perl wrapper around the SDL3 cross-platform multimedia C library that brings low-level access to audio, input devices, windows, 2D/3D rendering, timers, threading, file dialogs and other OS services into Perl programs. The module exposes SDL's extensive API through selectable import tags like :video, :audio, :render, :events, :main or :all so you can pull in only the subsystems you need and it supports SDL3's callback-based App system for integrating the main loop. If you want to write games, multimedia tools, device-aware utilities or cross-platform GUI code in Perl while leveraging SDL features such as async I/O, gamepad and joystick support, Vulkan and Metal interop, clipboard and system tray access, this module is a practical choice. Examples and demos are included in the distribution and on the project GitHub, and the code is released under the Artistic License 2.0.

Module::Pluggable makes it trivial to give your Perl module a plugin system by exporting a method (default name plugins) that discovers modules under one or more namespaces or directories, optionally requiring or instantiating them and returning either class names or objects. You configure which namespaces or dirs to search, filter results with only or except, control instantiation or plain require, limit nesting depth, choose result ordering, and attach hooks to veto or handle require and instantiate events. The search runs on each call so new plugins can be picked up at runtime but you can cache results yourself for better performance when dynamic discovery is not needed. It respects blib and @INC hooks so it works well in test environments and with packers, and it will use Module::Runtime when available for safer loading. If you want a small, flexible way to add pluggable handlers to an application without a big framework, Module::Pluggable is a practical and well proven choice.

LibUI is a Perl binding to the libui-ng native GUI library that lets you build simple, cross‑platform desktop interfaces using familiar widgets like windows, buttons, boxes, menus, dialogs, tables, drawing areas, text layouts and more. It exposes a straightforward functional API with helpers and some OO wrappers such as a chainable Matrix object for draw transforms, and it also converts lower‑level C patterns into Perl‑friendly forms so things like date/time, font descriptors and out‑parameters return native Perl structures. The module is aimed at developers who want lightweight native look and feel without wrestling with platform‑specific toolkits and it includes timers, threading hooks, file and message dialogs, rich text attributes and a full table/model system for data views. The recent 1.0.0 release brings the complete libui-ng widget set plus a large collection of example programs from calculators and clocks to a tabbed notepad and table demo, and it improves area handler callbacks so drawing, mouse and key events are delivered as convenient Perl data structures. Note that LibUI requires a libui runtime (provided via Alien::libui) and is best for small to medium GUI tasks where a simple native interface is desirable.

DateTime::Format::Genealogy is a small Perl utility that turns genealogy-style date strings, especially GEDCOM exports, into DateTime objects so you can work with dates programmatically. It understands common nonstandard month names and can parse exact dates, GEDCOM calendar escapes like Julian, Hebrew and French Republican when the appropriate calendar modules are installed, and it returns date ranges as a pair of DateTime objects when the input expresses a range. You can control behavior with quiet and strict flags to suppress warnings or enforce three-letter GEDCOM month abbreviations, and the parser deliberately rejects approximations, year-only strings and dates before AD 100 to avoid misleading results. Recent maintenance releases fixed a number of parsing and cloning bugs, added input sanitization in diagnostic messages and a cache size guard to improve security and robustness, and also improved performance by caching failed parses. If you need to normalize or convert genealogical dates into standard DateTime objects for reporting, searching or downstream processing this module is a practical choice, but be aware that some calendar conversions require optional modules and that very old pre-100 AD dates are intentionally not supported.

Net::BitTorrent is a full-featured BitTorrent client library for Modern Perl (requires v5.40+) that you can embed in scripts or applications to manage swarms, peers, storage, and discovery without committing to a specific event loop. It is designed around loop-agnostic integration, first-class BitTorrent v2 support (Merkle trees and SHA-256 infohashes), and strong security defaults including DHT hardening and protocol encryption, and it exposes a straightforward API to add torrents from .torrent files, magnet URIs, or infohashes, to register event callbacks, to tick or wait a main loop, and to persist and restore session state. The module provides high-level objects for the client, individual torrents, peers, and disk storage, plus DHT get/put/scrape helpers, global rate limiting, and a background hashing queue to keep verification off the hot path. Recent 2.1.1 tweaks make client authoring nicer by adding a fast torrents_hash lookup by infohash, a magnet_uri builder for constructing links, new per-torrent and peer metrics, and a lower-cost tick loop that reduces CPU spikes and improves UI responsiveness, so this is a good choice if you need a modern, secure, and extensible BitTorrent engine in Perl.

App::zipdetails is a tiny Perl package that exposes a tool for inspecting the internal structure of ZIP archives. The module itself is a stub and the actual functionality is provided by the companion script bin/zipdetails, which prints archive entries, headers and other structural metadata so you can examine what is inside a ZIP without extracting it. It is handy for developers and administrators who need to audit or troubleshoot ZIP files. The author is Paul Marquess and the code is distributed under the same terms as Perl.

Affix is a high performance Foreign Function Interface for Perl that lets you call native libraries and languages like C, Rust, Zig, Go and Fortran directly from Perl without writing XS or compiling glue code. It uses a JIT trampoline engine to marshal arguments and returns at near native speed and provides a rich C-like type system including primitives, structs, unions, enums, SIMD vectors and pointers. Affix gives live, zero copy views of C aggregates so you can read and write C memory through normal Perl hashes and arrays, allocate and manage heap memory with malloc/calloc/realloc/strdup, pin Perl scalars to C globals for two way binding, and attach custom destructors for owned buffers. You can load and locate libraries across platforms, bind symbols as named subs or anonymous wrappers, pass Perl coderefs as callbacks, call variadic functions with explicit coercions, and introspect sizes and offsets with sizeof, alignof and offsetof while using built in debugging helpers like errno dualvars and memory dumps. The recent v1.1.0 release introduces a revamped V2 pin system backed by Perl magic VTables to eliminate tied‑variable overhead and boost zero copy performance, adds a Const[...] wrapper to enforce read only C memory from Perl, and improves Affix::Wrap header parsing and type handling.

Plerd is a minimalist static-blog tool that turns Markdown files kept in a Dropbox-synced directory into a ready-to-publish website, making it easy to write posts in your editor and have HTML, tag indexes, recent-post lists, and feeds generated for you. You configure a few basics like the blog path, title, base URL, and author info and then Plerd uses templates to render pages, supports a default social image and Twitter handle, and keeps an internal index so it can republish a single changed file quickly or rebuild everything when post metadata changes. If you want a simple, file-driven workflow for a small blog without a database or heavy CMS, Plerd provides a clean, lightweight solution.

Matplotlib::Simple is a lightweight way to produce matplotlib graphics from Perl without learning the Python API by hand. You pass Perl hashes and arrays describing your data and plotting options and the module writes a Python 3 script (saved in the system temp directory) that uses matplotlib to render bar, boxplot, hist, scatter, imshow, violin, pie, hexbin, hist2d and many other plot types, with support for subplots, overlays, shared colorbars and common axis and style options. The module can either execute the generated script for you or leave it for manual editing and it requires a working Python 3 and matplotlib installation; the proportional-area Venn helper now wraps the matplotlib-venn library when you install it. Recent updates added the unified "p" subplot argument, improved cross-platform behavior and in version 0.31 added the venn_proportional_area helper while removing Term::ANSIColor as a dependency.

Mojolicious::Plugin::BarefootJS connects the BarefootJS server-side template runtime to Mojolicious so you can render BarefootJS templates inside your Mojolicious app. It registers a per-request helper called "bf" that lazily creates a BarefootJS runtime backed by BarefootJS::Backend::Mojo and adds the supporting hooks so compiled marked templates behave like native Mojolicious templates. If you are not using Mojolicious there is a separate backend using Text::Xslate for PSGI hosts. This plugin is simple to install, MIT licensed, and useful whenever you want to integrate BarefootJS rendering into a Mojolicious application.

BarefootJS::Backend::Xslate is a small adapter that lets the BarefootJS runtime render Kolon-style Text::Xslate templates. It wires a Text::Xslate instance into BarefootJS so templates can call the runtime as the bf object and use its helpers and filters. The backend builds Xslate for HTML-escaping by default and supports mark_raw values for helpers that emit raw markup. You create it with a template path or a prebuilt Xslate instance, can override the JSON encoder, and then call render_named to render templates with the runtime bound. Use this module when you want to run BarefootJS templates with Xslate in any PSGI/Plack application or even outside a web framework.

BarefootJS is a lightweight server runtime for templates compiled from JSX/TSX into a marked template plus client JavaScript, letting Perl applications render component-style templates without tying you to a particular template engine or web framework. It delegates framework-specific tasks such as JSON marshalling, raw-string marking, JSX children materialisation and named-template rendering to a pluggable backend so the same runtime can drive different rendering engines, and shipping backends include BarefootJS::Backend::Xslate for Text::Xslate/PSGI and BarefootJS::Backend::Mojo for Mojolicious. The core intentionally pulls in only standard Perl modules unless a chosen backend requires extras, making it easy to adopt in existing PSGI or Mojolicious apps. The module is MIT licensed and actively developed, so it is a good fit if you want to bring JSX/TSX-style server rendering into Perl while keeping your rendering backend flexible.

Chandra::Same::Boy is a Chandra widget that embeds the Same::Boy Game Boy / Game Boy Color emulator into a native webview window so you can play ROMs inside your Chandra GUI. It renders a pixelated, scaled canvas, forwards real keyboard input, supports save states and battery-backed saves with autosave, and provides controls for pause, reset, fast-forward and audio management. You create it with a Chandra::App and a ROM, call mount before running the app to inject the canvas, input bridge and a ~60fps game loop, and you can hot-swap cartridges, save or load state files, and listen for events such as rom loaded, frame, fps and save actions to integrate with your UI. The widget also includes SGB multiplayer input support, a toolbar and HUD with ROM title and measured FPS, native file open for hot-swapping and toast feedback for actions. This is the initial 0.01 release.

Chandra provides Perl bindings to the webview-c library so you can build cross-platform desktop apps with HTML, CSS and JavaScript while keeping your application logic in Perl. It exposes a simple OO interface to create windows, load URLs or data URIs, run or control the event loop, execute JavaScript and register Perl callbacks that JavaScript can call back into. The distribution also includes higher-level helpers such as Chandra::App and a growing component set including forms, tables, modals, toasts, system tray integration and IPC helpers to speed building interactive UIs. On Windows Chandra prefers the modern Edge WebView2 runtime and will automatically fall back to legacy MSHTML when WebView2 is not available so installing the WebView2 runtime and WebView2Loader.dll is recommended for the best web feature support. The recent release documents a per-frame on_tick hook for games and animations and adds on_close and on_reload callbacks to support graceful shutdown and hot-reload workflows.