CPANscan

LWP::Protocol::https is a small plug-in that enables LWP::UserAgent to fetch HTTPS URLs by using HTTP over SSL/TLS, so you do not call it directly but install it to give LWP builtin https support. It honors LWP::UserAgent ssl_opts such as hostname verification and lets you supply SSL_ca_file or SSL_ca_path for certificate validation, and when verification is enabled it will fall back to the CA bundle provided by Mozilla::CA unless you override it. The module was split out of libwww-perl so applications can simply depend on it rather than on its lower-level SSL libraries. Recent releases improved proxy handling to support TLS-enabled (https://) proxies and contain small test-suite fixes to make installation more robust.

Litavis is a fast CSS preprocessor and compiler for Perl that implements its parsing and compilation engine in C and exposes it through XS, designed as a successor to the pure-Perl Crayon with an emphasis on correctness and performance. It accepts CSS from strings, files, or directories and supports nested selectors with flattening, parent selector references, preprocessor variables, mixins, map variables, compile time colour functions, cascade aware deduplication, and both minified and pretty output. Typical use is to create a Litavis object, parse one or more inputs, then compile or write the result to a file, and reset when you need a fresh state. The distribution also installs reusable C header files so other XS modules can embed the same engine, and it preserves CSS custom properties and functions like var and calc by passing them through unchanged. The recent 0.03 update adds portability fixes to improve builds on Windows and MinGW.

Hazy is a tiny Perl-based CSS framework and preprocessor that scans a source folder of simple template files and compiles them into combined CSS files, producing both a readable stylesheet and a minified version. It offers a minimal syntax for variables, shorthands and reusable blocks so you can declare colors, margins and snippets once and reference them across files, and it is configured by pointing Hazy at a read directory, a write directory, a target filename and the file extension to find. Hazy is aimed at small projects and developers who want a lightweight, easy to use tool to generate static CSS without the complexity of larger preprocessors.

Crayon is a Perl-based CSS preprocessor and compiler that lets developers write more maintainable stylesheets by using variables, scoped values, reusable mixins and maps, and nested rules that expand into standard CSS. It includes a set of color and transformation functions like lighten, darken, tint and greyscale, supports inline and block comments, and can output either minified or human friendly "pretty" CSS. Crayon also tries to deduplicate identical declarations across selectors so the final stylesheet is smaller and easier to manage. You interact with it through a simple API to parse strings or files and to compile the internal structure back to CSS or a file. The project has been succeeded by Litavis for those who prioritize speed and correctness, but Crayon remains a straightforward option for Perl programmers who want Sass-like features without leaving the Perl ecosystem.

Apache::Session::Generate::Random is a small driver for Apache::Session that supplies secure, system-sourced random session IDs so your web app can avoid predictable or weak identifiers. It plugs in as the Generate component when tying an Apache::Session or Apache::Session::Flex store and uses the operating system’s randomness facilities (via Crypt::SysRandom) to produce hard-to-guess IDs. If you need stronger session identifiers than simple counters or naive RNGs this module is a drop-in way to improve session security while remaining compatible with older Perl versions. Recent updates added a companion for Apache::SessionX and refreshed distribution metadata and packaging.

Crypt::SysRandom::XS is a small, fast XS-based Perl module that gives you cryptographically secure random bytes from the operating system via a single function, random_bytes($count), which returns a string of $count unpredictable bytes. It selects the best native source available at build time, for example getrandom on Linux, arc4random on BSD and macOS, BCryptGenRandom on Windows, and RDRAND as a final fallback, so your code can get system-quality randomness without platform-specific plumbing. The API is minimal and portable, making the module useful for generating keys, nonces, tokens, or seeds for higher-level crypto libraries, and recent releases include important correctness and security fixes, notably disallowing negative length requests to address CVE-2026-2597.

ExtUtils::CppGuess is a small utility for Perl module authors who need to compile C++ code alongside Perl extensions, helping pick a C++ compiler that is compatible with the C compiler Perl was built with and emitting the correct flags for ExtUtils::MakeMaker or Module::Build. It detects common compiler families such as GCC, Clang, MSVC and Sun Studio, respects the CXX environment variable, and lets you add extra compiler or linker flags while providing ready-made options like CCFLAGS and OTHERLDFLAGS or Module::Build settings. The module can also produce a runnable compiler command, return the appropriate include filename for iostream portability, generate small compatibility macros for standard headers and namespaces, and supply standard-specific flags up to C++23. It is intended to simplify cross-platform build setup for XS or XS-adjacent C++ code, although there is a noted edge case with very old Perls and older ExtUtils::CBuilder releases where detection may have problems.

Eshu is a fast XS-based Perl module and command-line tool for fixing indentation and generating syntax-highlighted HTML for a wide range of languages including C, Perl, XS, XML/HTML, CSS, JavaScript/TypeScript, Python, Go, Rust, Java, PHP, Ruby, Lua, Bash, SQL, YAML, JSON and POD. It adjusts leading whitespace by understanding language-specific constructs so braces, heredocs, strings, comments and other syntax are handled correctly while leaving code content untouched. You can call per-language methods or auto-dispatch by filename or explicit language, configure tabs or spaces and indent width, run it on single files or entire directories, preview diffs or run in CI check mode with the bundled eshu tool, and use the included vim plugin for editor integration. Highlighting produces HTML with span classes for token types so you can style output. File processing skips binary or very large files and relies on extension-based detection when needed. Eshu is aimed at developers and maintainers who want a quick, reliable way to normalize indentation and add lightweight syntax highlighting across many file types.

Dancer2::Plugin::Feed is a lightweight Dancer2 plugin that lets you generate RSS or Atom feeds from your web app without dealing with raw XML. It wraps XML::Feed and XML::Feed::Entry and exposes create_feed plus convenience shortcuts create_atom_feed and create_rss_feed. You pass feed metadata either in your Dancer2 config or as parameters and provide entries as an arrayref of hashrefs with keys like title, link, summary, content, author, issued and modified. The plugin sets the appropriate Content-Type header for the chosen format and surfaces format-related errors via exception roles so you can handle them in route code. If you want quick, configurable feed generation integrated with Dancer2, this module does the job while delegating the XML heavy lifting to XML::Feed.

Devel::Required is a small developer tool that automatically updates your distribution's README and POD with the modules and versions you declare in PREREQ_PM when you run ExtUtils::MakeMaker, saving you from manually copying dependency lists into documentation. You load it in an eval before calling WriteMakefile and it will look for specific marker headings in text or pod files and replace those sections with the VERSION and REQUIRED MODULES information taken from the generated Makefile, or you can tell it which files to use via text and pod options. It can also inject installation guidance for projects that maintain separate maint and blead branches. This module is intended for authors' machines only because it will modify files in-place and it works by wrapping the calling package's WriteMakefile routine.

CGI::BrowserDetect is a lightweight Perl helper for web applications that need to identify a client’s browser, operating system, device type, language and country from HTTP headers. It builds on HTTP::BrowserDetect and takes your User-Agent and Accept-Language header values to return data via a detect method or convenience methods such as device_type, lang and cnty, so you can tailor content or behavior for different browsers, phones or locales. It is simple to drop into CGI or other server-side code and will consult Accept-Language when the User-Agent does not provide locale information. The most recent release is a small maintenance update that removed PAX headers from the package.

UNIVERSAL::dump is a small debugging helper that injects readable inspection methods into every Perl class and object so you can call things like dump, peek, blessed or refaddr without editing your modules. By default dump returns a Data::Dumper representation or prints it to STDERR when used in a void context which makes quick debugging output convenient. You can enable selected method names or map custom method names to the built‑in inspectors and to fully qualified dump routines. It relies on Data::Dumper and uses Devel::Peek and Scalar::Util for the peek, blessed and refaddr behaviors when requested. Be aware that adding methods to UNIVERSAL prevents AUTOLOAD from catching those names and the module will die if you try to register the same method name with a different underlying routine.

BATsh is a pure-Perl bilingual shell that lets a single script mix Windows cmd.exe batch syntax and Unix sh/bash syntax and run them line by line with a shared variable store, so you can call CMD-style commands and then switch to shell functions, pipelines and arrays without launching an external shell. It provides a command-line runner and REPL, supports running inline source and files, preserves exit status across mode boundaries, and includes practical features like CP932 (Shift_JIS) auto-detection for Japanese Windows scripts. Builtins for both CMD and SH are implemented in Perl and external programs are invoked via the host OS, so common Windows or Unix utilities work where they exist. The module runs on Perl 5.005_03 or later and is useful when you need cross-platform or mixed-syntax scripting in a single file. Note that a few complex or platform-specific commands are not reimplemented and some advanced behaviors have limitations compared with the native shells.

setenv is a tiny Perl pragma that lets you set or unset %ENV entries at compile time so you can inject predictable environment variables during program startup or tests. You invoke it like use setenv FOO => 1, BAR => 2 to set values during compilation or use no setenv or no setenv qw(FOO BAR) to clear variables. It is deliberately minimal and dependency free, intended as convenient syntactic sugar for debugging and build scenarios rather than a full runtime environment manager. The module was authored by Elizabeth Mattijsen and was adopted for maintenance in 2019 by Robert Acock.

Coerce::Types::Standard is a helper library that builds on Types::Standard to provide ready-made coercion types for common data conversions, making it easy to turn strings into arrays or hashes, flatten or merge nested structures, switch between hashes and arrays, handle HTML entity encoding and decoding, parse and manipulate URIs, count elements, and encode or decode JSON. Each coercion type can be configured with a simple "by" parameter to control behavior such as split delimiters, selection modes like keys or values, or encoding options, so you can wire these conversions directly into attribute definitions or validation layers. If you work with typed attributes or need consistent, reusable rules for transforming incoming data into the Perl structures your code expects, this module gives a compact, declarative way to do that.

Stats::LikeR brings a broad collection of R-like statistics and tidy-data tools to Perl, packaged as an XS-backed library for much faster numeric work. It understands multiple data-frame shapes (array-of-arrays, array-of-hashes, hash-of-arrays, hash-of-hashes) and provides familiar operations such as aggregation/group_by, merge/concat/rbind, pivot_table/melt, reshaping helpers, many statistical tests (t, ANOVA, chi-square, Fisher, Wilcoxon, Kruskal, KS, etc.), regression and GLM, PCA, interpolation and binning, and utilities like colnames/rownames/vals/value_counts. It also reads and writes delimited files and XLSX workbooks, supports in-place column transforms and column-wise assignment, and aims to match R/pandas behavior where useful while keeping Perl idioms. The module is actively maintained with many recent fixes and speedups, notably moving the numeric interpolate core into XS for large speed gains and a 0.26 fix for a long-double issue, so it is a good choice if you want R-style data manipulation and statistics inside Perl with production-oriented performance and robust error handling. Be aware a few R conveniences are intentionally limited here, for example its ANOVA routines produce Type-I (sequential) tables and predict has constraints around factor-level reconstruction, which the author documents.

PDF::Make is a Perl toolkit for creating, editing, and reading PDF files. It offers a recommended high-level, chainable Builder API that handles layout, page management, word wrap, font metrics, images, and common document tasks for quick report and form generation. For users who need full control it also provides a low-level XS API that maps directly to PDF concepts and content streams. The distribution includes parsers and extractors for reading existing PDFs, font and image support, interactive features like links and AcroForms, security features including encryption and digital signatures, and utilities such as attachments, watermarks, redaction, and linearization. It has minimal runtime dependencies beyond Object::Proto and is a good fit for Perl projects that need reliable programmatic PDF manipulation.

Hash::Typed provides ordered, typed hash containers for Perl that let you declare what keys a hash must have and what types their values must be. You can create a Hash::Typed object or tie a hash to it, enable strict and required-key checks, use type constraints from Types::Standard or supply custom validator coderefs, and even nest Hash::Typed instances for structured data. Assignments or instantiations that do not satisfy the declared constraints raise errors, which helps with input validation, configuration handling, and enforcing clearer data contracts. Recent updates include improved test coverage to 100 percent and a minor packaging cleanup.

HTTP::XSHeaders is a drop-in, C-backed replacement for the Perl HTTP header libraries HTTP::Headers and HTTP::Headers::Fast that gives existing Perl code a big speed boost simply by loading the module. It preserves the familiar public API so you can keep using the same methods for getting, setting, scanning and serializing headers while benefiting from a lightweight, thread-safe native implementation. The module intentionally normalizes header names to standard casing, converts underscores to hyphens, and makes a few small compatibility changes such as not supporting leading-colon literal names or the old $TRANSLATE_UNDERSCORE behavior, and it always loads Storable but performs cloning at the C level. Benchmarks included with the distribution show substantial improvements across common operations, making this a good choice when you need lower-overhead HTTP header handling. Recent releases fixed a heap-buffer-overflow issue and marked the project stable, and the most recent patch added an explicit dependency on HTTP::Headers and a fix for older Perl package declarations.

ExtUtils::ParseXS is the tool that turns Perl XS files into the C or C++ "glue" code needed for Perl to call native functions, applying typemaps to map Perl values to C types and emitting useful runtime checks and #line directives for easier debugging. It is the backend used by xsubpp and is what you reach for when you are writing or maintaining Perl extension modules that include C or C++ code, or when you need to embed custom typemaps to control argument and return value conversions. The module supports modern needs such as version checks, prototype generation, exception stubs and C++ linkage, and it offers both an OO and a legacy functional interface so it can be used programmatically or as part of the normal XS build flow. ExtUtils::ParseXS is actively maintained and has seen recent internal refactoring to an Abstract Syntax Tree for more robust parsing, clearer error messages and improved typemap handling including more flexible support for functions like length().

Kwiki::Comments is a simple Kwiki plugin that adds per-page comment forms so visitors can leave feedback in the style of Slash or Movable Type comments. To enable it you add "Kwiki::Comments" to your plugins file, run kwiki -update, and insert the tag {comments} on any page where you want a form to appear. It is useful for wikis that lock page editing but still want public input, and it is aimed at site maintainers who want lightweight commenting without a separate system. Note that the module currently requires DBD::SQLite as its database backend.

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.