CPANscan

JSON::LINQ provides a LINQ-style, method-chained query API for working with JSON and JSONL files in Perl, letting you filter, project, group, sort and aggregate JSON data in a readable, fluent way. It brings the 60-method LINQ surface from LTSV::LINQ plus JSON-specific I/O helpers (FromJSON, FromJSONL, FromJSONString, ToJSON, ToJSONL) and boolean singletons JSON::LINQ::true and ::false, and supports streaming JSONL with O(1) memory while FromJSON loads a top-level array once and then iterates lazily. The module includes a pure-Perl built-in JSON encoder/decoder so no CPAN JSON module or XS is required and it even runs on very old Perls back to 5.005_03. The bundled parser has a few documented limitations such as no surrogate pair support, possible infinite recursion on circular references during encoding, and stringification of non-ARRAY/HASH references. This initial release is a convenient choice for querying, transforming and streaming JSON data in Perl, especially for log processing, ETL and quick data analysis without adding external dependencies.

LMDB_File is a Perl interface to the Lightning Memory-Mapped Database (LMDB) that lets Perl programs use a tiny, extremely fast embedded B-tree key/value store with full transactional semantics. It exposes LMDB concepts as Perl classes such as LMDB::Env to open an environment, LMDB::Txn for transactions, LMDB::Cursor for iteration and a convenience LMDB_File object that pairs a transaction with a database so you can use familiar put, get and delete calls or even tie a hash to a database for simple use. The module supports LMDB features like named databases, duplicate keys, custom key comparators, and a zero-copy read mode to avoid memory copies when you need maximum throughput. It also provides UTF-8 mode to automatically encode and decode text, configurable error handling, and a rich set of flags to tune durability and performance. Recent updates keep compatibility with modern Perl releases and add support for transaction identifiers and other maintenance fixes, so this module is a good choice if you need a lightweight, high-performance embedded database from Perl.

App::Raider is a compact CLI wrapper around Langertha::Raider that gives you an autonomous coding and system agent able to inspect a project tree, read and edit files, run bash commands, and fetch web content while being confined to a configurable project root. It ships with filesystem and shell tools, web search and fetch, automatic engine selection from *_API_KEY environment variables with sensible per-engine defaults, and flexible skill loading from Claude/OpenAI-style skill files or plain markdown directories. Configuration is straightforward via a .raider.yml file plus command line overrides and engine options, and the tool includes a REPL with persistent history, live trace and situation-injection plugins, on-the-fly skill documentation export, and session token reporting. The initial release emphasizes a small, practical toolbox and an almost unlimited tool-calling loop by default while exposing safety caps and tuning parameters for developers who want an interactive autonomous agent to explore, summarize, and modify repositories from the command line.

Mojolicious::Plugin::OpenAPI::Modern makes it easy to wire an OpenAPI::Modern document into a Mojolicious app so you can validate requests and responses against your OpenAPI schema. You register the plugin with a schema, a filename or URI for the document, or pass an existing OpenAPI::Modern object, and the plugin provides a shared openapi helper plus validate_request and validate_response helpers that return JSON::Schema::Modern::Result objects. You can also supply an after_response callback for post‑response checks or logging, and the plugin stores useful operation metadata under stash->{openapi} for controllers and templates. Matching is done from the request URI itself rather than Mojolicious route objects and the shared OpenAPI::Modern instance is reused across requests. Recent updates keep the plugin compatible with changes in the OpenAPI::Modern error handling and test behaviors.

SQL::Wizard is a Perl library for programmatically building SQL using composable expression trees so you can construct SELECT, INSERT, UPDATE, DELETE and compound queries as nested, immutable objects and only render SQL with placeholders and bind values when you call ->to_sql. It treats everything as an expression so columns, functions, CASE, subqueries, joins, window functions, CTEs and arithmetic can be nested naturally, it defaults to safe bind-parameterization and automatic identifier quoting to reduce injection risk, and it produces ANSI SQL by default with optional MySQL quoting. The API is designed for developers who want fine-grained control without hand-crafting SQL strings and it integrates with DBI by returning a SQL string and ordered bind values ready for execute. Note that recent releases introduced an important behavior change: as of 0.10 a hashref value that is an arrayref now generates OR conditions for each element rather than an IN list, so use the explicit -in form for IN clauses; 0.11 relaxed alias validation to allow dotted aliases in ->as().

LRU::Cache is a compact, C-backed Least Recently Used cache for Perl that delivers constant-time operations for common cache tasks. It stores key/value pairs up to a fixed capacity and automatically evicts the least recently used entry when space is needed. The module provides a simple object-oriented API for set, get, peek, exists, delete, size, capacity, clear, keys, oldest, and newest operations and also offers a function-style API you can import for even lower call overhead. The function-style calls avoid method dispatch and yield substantially higher throughput for get and set, making this a good choice when you need a fast in-memory LRU cache with minimal latency.

DBIx::Wizard is a lightweight, chainable database toolkit for Perl that sits between raw DBI and heavy ORMs like DBIx::Class. Point it at a DSN and table and you can build queries with a fluent API like ->find->sort->limit->all without defining schemas or result classes. It uses SQL::Wizard to generate safe, composable SQL expressions so you can use column and function expressions, joins, subqueries, window functions and arithmetic in queries. Rows come back as plain hashrefs and the module supports inserts, updates, deletes, aggregates, streaming cursors, automatic DateTime inflation with configurable classes, transactions with nested savepoints, and environment-driven database registration for twelve-factor style deployments. Debug logging is available via environment variables. If you want an ergonomic, minimal ORM for straightforward SQL work in Perl, DBIx::Wizard gives you fast, zero-configuration access to powerful SQL features.

Google::ProtocolBuffers::Dynamic is a Perl runtime that parses .proto definitions and produces fast, native Perl classes for encoding and decoding Protocol Buffer messages. It leverages Google"s C++ protobuf parser and the upb library to generate blessed-hash message objects with auto-generated accessors, supports JSON input and output, and can produce gRPC clients using Grpc::XS. You control how proto packages and messages map to Perl packages and can tune behavior for booleans, big integers, default encoding, map emulation and enum checking, and every mapped type exposes runtime introspection. The module also documents an ahead-of-time generator if you prefer precompiled code. Known limitations include partial proto3 coverage, discarded unknown fields on decode and occasional inconsistent handling of invalid field values.

Module::CoreList lets you discover which Perl modules and versions were bundled with each Perl release, either from a command line tool called corelist or from a simple programming API. You can ask when a module first appeared in core, whether a given module version is part of a particular Perl, which modules match a pattern, what changed between two Perl releases, and whether modules were deprecated or removed, and the module exposes data hashes with per-release module lists, release dates, deprecation info, upstreams and bug tracker pointers for automation. It is handy for packaging, compatibility checks, and deciding whether to rely on a core module or vendor a dependency. Coverage includes the main Perl 5 series with all stable releases since 5.6.0 and development releases since 5.9.0, and the module is maintained by the Perl 5 Porters.

CPAN::Perl::Releases is a compact, data-only module that maps Perl release numbers to the relative CPAN "authors/id/" paths where the release tarballs live. Its main function perl_tarballs($version) returns a hashref keyed by archive type like "tar.gz", "tar.bz2" or "tar.xz" with the corresponding authors/id path for that tarball, while perl_versions lists the supported release strings and perl_pumpkins returns the PAUSE IDs of Perl maintainers. The information is static but maintained and republished whenever new perl releases appear on CPAN, and it accounts for historical differences such as releases that lack certain archive formats or tarballs that have been removed. Recent updates include support for v5.43.10 and the removal of v5.41.10 from the data set.

MooseX::Params gives Perl subroutines and methods a clear, attribute-driven way to declare and validate parameters using a signature syntax, so you can write readable declarations like ":Args(Int x, :y = 'foo')" and access processed values via a read-only %_ hash instead of manually unpacking @_. It integrates with Moose type constraints and coercions, supports positional and named parameters, required and optional flags, slurpy rest arguments, simple defaults and lazy builders, plus hooks to preprocess arguments or run custom checks with BuildArgs and CheckArgs. It also offers basic return-value validation and a small set of options to control scalar versus list return behavior, and it provides a concise invocant notation for methods. The module is experimental and actively limited in testing and performance, so expect some rough edges and possible incompatibilities, but if you use Moose types and want more declarative, self-documenting parameter handling it can significantly simplify your argument processing.

Lemonldap::NG::Portal is the authentication portal component of the Lemonldap::NG Web-SSO system that lets you protect web applications with minimal changes. It is a PSGI/Plack-compatible portal that manages authentication, authorization and accounting headers so you get full AAA coverage for a web space. The portal is modular and loads authentication backends, user databases and other features as plugins at configuration reload, provides JSON responses for AJAX and template rendering for normal requests, and exposes a clear API for writing custom plugins. Configuration is centralized and treated as read-only at runtime and plugin initialization failures will cause requests to return a 500 error, so it is best suited to projects that need a flexible, extensible single sign-on gateway integrated into a PSGI deployment.

Lemonldap::NG::Handler is the Apache protection module for the Lemonldap::NG Web Single Sign‑On system that enforces access control and session management at the web server level. It is provided as an alias to Lemonldap::NG::Handler::ApacheMP2 and supplies Apache handlers to protect web applications, integrate with centralized Lemonldap policies, handle logouts and session sharing, and support CGI and proxy scenarios. Over its lifecycle it has gained features like shared configuration, cross‑domain authentication, custom functions and improved virtual host handling. Recent updates added POST-based login for nonstandard clients, moved basic authentication to a SOAP backend, improved logging through PerlLogHandler and introduced a double-session option for better session isolation. Choose this module when you need an Apache-integrated SSO protection layer that works with the Lemonldap::NG ecosystem.

Lemonldap::NG::Common is a support library that bundles shared functionality used across the Lemonldap::NG Web single sign-on suite, providing the building blocks for its Manager, Portal and Handler components. It is not an application itself but supplies common utilities such as SOAP and WSDL helpers, logging and syslog wrappers, session and configuration storage backends (including LDAP support), a Crypt object for configuration, and small helpers like setApacheUser and a safe library for custom rules. If you are deploying or extending Lemonldap::NG this module is where reusable infrastructure code lives, so it is relevant when you need consistent logging, session handling, remote API support or central configuration for the suite. Recent releases added SOAP/WSDL tooling, improved logging wrappers and LDAP storage, reflecting its role as a consolidation point for shared features.

Mojo::DOM::Role::Style is a lightweight role that adds a convenient style() method to Mojo::DOM elements for reading and manipulating an element's inline CSS. Calling style with no arguments returns a Style::Value object that stringifies to the CSS text and can be used like a hash to read individual properties, while calling it with a single property name returns that property's value. You can replace the whole style by passing a raw CSS string or an even length list of property/value pairs, merge new properties by passing a hash reference, or remove the style attribute by passing undef. Setter calls return the element for method chaining which makes it handy in DOM transformations, scraping, or server side HTML generation. If you work with Mojo::DOM and need simple programmatic control over inline styles this role makes those operations concise and predictable.

Git::Server is a drop‑in replacement for a plain Git SSH server that gives repository hosts far more control over access and automation by adding granular ACLs, richer server hooks and built‑in deployment and webhook features. It is aimed at sysadmins and teams who want to enforce fine‑grained rules such as read/write restrictions, restricted branches and files, IP or author‑email whitelists, push‑force protections and automatic post‑push deployment or notification workflows without adding heavy external tooling. The distribution also includes helper tools like a git-client wrapper and git-deploy, supports proxy syncing to external remotes and provides configurable webhook callbacks for push and pull events. The project is actively maintained on GitHub and recent updates have improved proxy syncing reliability and caching of remote failures, fixed identity and portability issues for git-deploy, added webhookcallback.cgi support and tightened various security and compatibility behaviors, so it is a good fit if you need a more policy‑driven, hookable Git server than stock git-shell.

Graphics::Framebuffer is a Perl library for drawing directly to a Linux console framebuffer, letting you plot pixels and draw lines, shapes, gradients, rounded boxes, Bezier curves, text with TrueType, load and blit images and even play animations without X. It maps the framebuffer into memory and exposes a straightforward API where most methods take a hash reference for parameters so you can control clipping, drawing modes (XOR, mask, alpha, add, multiply and more), color handling, and blit transforms such as rotate, scale and merge. The module supports 32/24/16 bit framebuffers and provides an emulation mode for offscreen development or testing on systems without framebuffer devices, and many operations can be accelerated via Imager or optional C code while a pure-Perl fallback remains available. You must run it from a real console with a framebuffer-capable open source driver rather than inside X or with proprietary DRM drivers, and 24/32-bit modes are recommended for best performance and TrueType support. If you need compact, console-only graphics, fast blitting and image manipulation from Perl, Graphics::Framebuffer is a practical, well documented choice.

AsposeCellsCloud::Role is a small model class in the Aspose.Cells Cloud Perl SDK that represents a user or permission role used by the service. You use it to build, inspect, and pass role data such as id, name, and permissions when making API calls via the SDK’s ApiFactory and Configuration components. The module lets you work with role information as a native Perl object and handles the conversion to and from the JSON structures the REST API expects. It is helpful whenever you need to create, update, list, or delete roles or include role details in requests to the Aspose.Cells Cloud service.

XS::Parse::Sublike is a small XS helper library for people writing Perl keyword plugins that need to parse "sub"-style declarations. It provides a boot function to initialize hooks and a compact API to parse the usual pieces of a subroutine declaration such as an optional name, attributes, an optional signature and the code body, plus helpers to register custom sub-like keywords or prefixing keywords so your plugin can be invoked automatically. The module exposes hook points and a shared parse context so you can inspect or modify the parse at stages like attribute handling, signature start/finish and the creation of the CV or optree, and it offers experimental signature helpers to query or add parameters programmatically. This is an XS-level tool aimed at keyword/plugin authors and not intended for normal Perl code. The interface is still experimental and evolving so newer releases have added extended signature features including named and refalias parameters and additional signature inspection APIs, and ABI changes may require rebuilds of dependent modules.

Data::HashMap is a family of C-backed, type-specialized hash maps for Perl that trade Perl hash flexibility for much lower memory use and much higher speed. Each variant targets a specific key/value combination such as 16/32/64-bit integers, strings, or generic Perl SV* values and exposes both a keyword API that bypasses Perl method dispatch for maximum throughput and a convenient method API. Built-in features include configurable LRU eviction with an optional approximate mode for cheaper promotions, per-map and per-key TTL with lazy expiry, fast counter and atomic operations on integer variants, iteration and bulk snapshot helpers, and zero-copy read-only string access when you need the absolute fastest reads. The implementation is designed for real-world caches and hot workloads and shows large performance and memory advantages over Perl hashes. Keep in mind a few practical caveats documented by the author: TTL expiry is lazy, get_direct returns a read-only view that must not be held across map mutations, some integer variants require 64-bit Perl and reserve a couple of sentinel integers, and freeze output is native-endian only. If you want a compact, low-latency map or cache in Perl with LRU and TTL support this module is a strong fit.

PDL::Graphics::PLplot is the PDL bridge to the PLplot plotting library, offering a Perl object oriented API plus direct access to PLplot's lower level C routines so you can produce PNG, PostScript, X11 and other device outputs from PDL ndarrays. It makes common tasks simple with high level methods for XY plots, colored point plots, shaded contour and image plots, histograms, bar charts, strip plots, color keys and annotated text while exposing many options for colors, palettes, viewports, ticks and fonts. The module accepts PDL arrays directly and understands bad values so you can mask points or create gaps in lines, it can decorate in‑memory PDL images with the mem driver, and it supports advanced features like custom coordinate transforms, grid maps for irregular grids and stacked bars. Note that full compatibility requires PLplot 5.15.0 or newer and that a few low level calls have slightly different argument ordering because of the PDL wrapper, but overall this is a powerful, mature plotting backend for anyone using PDL who needs fine control or direct access to PLplot functionality.

DBIx::Spreadsheet makes an Excel or ODS workbook look like a database so you can run SQL queries against sheets using DBI. It treats each worksheet as a table and uses the first row as column names, filling empty headers with generated names and cleaning names for safe use. The module reads files through Spreadsheet::Read so it can handle CSV, XLS, XLSX and ODS when the matching parser modules are installed, and it exposes a DBI handle and helper methods to list available tables. Parsing and normalizing cell values is handled with pragmatic hacks, so results may vary between file formats, but for quick ad hoc querying and simple integrations this provides a convenient way to query spreadsheets with familiar SQL.

Quiq is a large, actively maintained Perl class library that bundles more than 260 small, reusable modules to speed up common development tasks. It provides utilities for filesystem and path handling, temporary files, logging and debugging, database access and result management, HTML and JavaScript generation, web clients and APIs, charting and plotting, image and media operations, XML and JSON handling, time and date utilities, plus domain helpers such as ZUGFeRD invoice XML generation and related validators. The collection is deliberately broad and pragmatic so you can pick stable building blocks instead of reinventing utility code for scripts, web tools, data pipelines, or quick prototypes. Installation is simple via cpanm Quiq and the project is under continuous development by Frank Seitz, with recent releases refining the database connection documentation and adding features and validators for electronic invoicing and a range of convenience methods across the library.

CPANSA::DB supplies the CPAN Security Advisory dataset as a ready-to-use Perl data structure, primarily to back CPAN::Audit but useful to any code that needs machine-readable vulnerability and advisory reports for CPAN modules. The distribution exposes a single subroutine, db, which returns a hashref of all reports so you can quickly integrate advisory data into audits, monitoring, or build tools. Releases include a JSON export and are signed with GPG and GitHub Attestations so you can verify the archive came from the official source, and GitHub releases include attestations and attestations instructions. The project is actively maintained with regular data updates; the recent 2026-04-19 update refreshed records and fixed a couple of improperly split affected_versions for Encode and IO::Socket. If you need an up-to-date, verifiable feed of CPAN vulnerability reports for security checks or automation, this module is likely relevant to you.

LaTeX::Replicase is a compact Perl template engine for programmatically filling real TeX/LaTeX files, letting you drive document content from Perl data structures rather than embedding logic in the template. You place simple tags into an existing .tex template to substitute scalars, arrays and hashes, to repeat table rows, and to add or suppress surrounding text based on whether values exist or are defined, and the module can write the filled file to disk or stream it to STDOUT. It includes options to treat templates as UTF‑8, to escape TeX metacharacters automatically, and to control handling of undefined names, debug output and silence, while protecting the original template from being overwritten. The interface is deliberately minimal so templates stay readable and all conditional logic stays in your Perl data, and common practical limits are documented such as avoiding spaces in file paths and preferring simple variable names. Recent updates added a tex_escape helper for safer TeX output and special magic values that let a value force early termination of the generated document by inserting \endinput or \end{document}, making it easier to control final output.

OpenAPI::Modern lets you validate HTTP requests and responses against OpenAPI v3.0, v3.1 and v3.2 documents so you can ensure clients and servers follow your API contract. It loads an OpenAPI document and uses a full JSON Schema evaluator to check paths, parameters, headers and bodies, converting many common request and response types into Mojolicious message objects and returning a structured JSON::Schema::Modern::Result that includes any deserialized data. The module helps find the matching path and operation in a spec, follows $ref chains, supports many query, cookie and path parameter styles, bundles up-to-date metaschemas, and can be cached for faster startup in preforked apps. A few areas are not yet implemented such as multipart and application/x-www-form-urlencoded media handling and it does not validate Authorization headers against security schemes. Recent releases improved parameter parsing, cookie and query decoding, added the with_defaults option to populate default values, and the latest 0.134 update adds a new JSON Schema format "media-range" and smarter media-type matching that takes parameters and structured suffixes into account. If you need runtime or test-time validation of messages against an OpenAPI spec and you work with Mojolicious or can convert your requests and responses to its message objects, this module is likely a good fit.

IPC::Manager::Client::SharedMem is a protocol plugin for IPC::Manager that stores client state, messages, and statistics in a SysV shared memory segment so multiple processes on the same host can exchange messages without a network. It serializes access with a SysV semaphore and keeps the whole dataset as JSON prefixed with a 4 byte network-order length, re-allocating a larger segment automatically if the data grows. The module is simple to use via ipcm_spawn and ipcm_connect and encodes the route as "shmid:semid". Because each mutation acquires the semaphore and reads and writes the entire segment, it is best suited to moderate-volume local IPC rather than extreme high-throughput workloads. Requires IPC::SysV 2.09 or later and was split out from IPC::Manager in its initial release.

DateTime::Format::Lite parses and formats datetimes using familiar strptime-style patterns and returns lightweight DateTime::Lite objects, making it a compact alternative to DateTime::Format::Strptime for projects that prefer fewer dependencies. You can set locale and time zone, supply a zone_map to disambiguate abbreviations, and the module resolves timezone abbreviations live against an included IANA tzdata SQLite database so lookups stay current. Common formatting and parsing paths are XS-accelerated when a C compiler is available at install time with a pure-Perl fallback otherwise. Errors are exposed via an error object or can be made fatal, one-shot convenience functions strptime and strftime are provided for quick use, and the formatter can be serialized for transport or storage.

Docopt is a Perl port of the Docopt command-line interface description language that turns a program's help or usage text into a working argument parser. You write a conventional help/usage block describing commands, options, positional arguments, optional groups, alternatives and repeating elements and docopt() extracts that specification and returns a HashRef of parsed options and arguments so your script can use them directly. The module reads the SYNOPSIS pod by default but you can supply your own doc text and control argv, automatic --help handling, --version, and parsing mode. It follows the familiar short/long option and default-value conventions, is based on the original Python implementation, and is aimed at developers who want a readable, spec-driven way to define and parse command-line interfaces. Note that the module is still under development and its API may change.