CPANscan

CPAN::Perl::Releases is a small convenience module that maps every Perl release on CPAN to the relative authors/id path where its distribution tarballs live, so scripts and tools can look up the exact location of official Perl tar.gz, tar.bz2 or tar.xz files without scraping the site. Its main function, perl_tarballs, returns a hashref keyed by compression type with the authors/id path for a given Perl version, while perl_versions lists all versions known to the module and perl_pumpkins returns the PAUSE IDs of the Perl maintainers. The mapping is static data that is updated as new Perl releases are uploaded, making this module useful for mirroring, packaging, or automation tasks that need reliable locations for Perl release archives.

SVG::Barcode::QRCode is a small Perl module that produces QR codes as scalable SVG images, making them easy to embed in web pages or vector documents. You can use it as an object or via the plot_qrcode function and customize error correction level (L, M, Q, H), symbol version or automatic sizing, dot size, colors, margin, id and class attributes, and output dimensions. Defaults are sensible for most uses but you can tweak parameters for higher capacity or visual styling. It is built on SVG::Barcode, works well alongside Text::QRCode, and is released under the Artistic License 2.0.

App::Netdisco is an open source, web‑based network management tool that helps network teams discover, inventory and troubleshoot switched networks by collecting SNMP and other data into a PostgreSQL database. It lets you find a host by MAC or IP and trace it to the exact switch port, change port state, VLAN or PoE settings, build inventory reports by vendor, model and OS, and visualise topology with neighbour maps. The distribution provides a browser UI plus a background backend daemon for polling and job handling, a command line tool for ad hoc tasks, a REST API and plugin hooks so you can extend discovery, reporting and actions. Deployments can be self‑contained under a local Perl environment, run as containers, or integrated with existing infrastructure, and the project documents install and upgrade steps for major Linux and BSD platforms. Requirements include Perl 5.10 or later and PostgreSQL 9.6 or later and some platform packages such as net-snmp and SSL development libraries. Recent releases add permanent API tokens and basic Bearer auth, a new queue status API endpoint, and finer control over discovery job parameters and queuing behaviour to make automation and scripted discovery more flexible. If you manage Ethernet networks with SNMP-capable devices and need a searchable inventory, topology discovery and port-level control, Netdisco is likely relevant.

Test::Load::Helper automates finding and loading Perl test helper files by walking upward from the calling test file and evaluating the nearest helper into a target package, so you no longer need brittle relative require paths. You can override the default helper filename or give a relative helper path to preserve its own directory hierarchy and you can choose the package into which the helper is evaluated so shared fixtures can live in a dedicated namespace. Helpers can chain to parent helpers by also using Test::Load::Helper, common files are evaluated only once per target package to avoid duplication, and traversal can be limited by setting TEST_LOAD_ROOT. Helper files are evaluated under use strict and use warnings and if no helper is found the module quietly does nothing. This is the initial 1.0.0 release.

DBIO::GraphQL inspects a DBIO::Schema and auto-generates a ready-to-run GraphQL::Schema plus a context tied to your DBIO connection so you can immediately execute queries and mutations. It translates SQL column types into GraphQL scalars, exposes DBIO relationships as fields, and creates root Query and Mutation types with plural allX queries that support nested per-column filtering, ordering, offset and cursor pagination, and createX, updateX and deleteX mutations for every source. Composite primary keys are supported and responses include convenience fields such as total, nextCursor and hasNextPage. The module is ideal when you want a fast, convention-driven GraphQL API over an existing DBIO schema without hand-writing types or resolvers. Be aware of documented limitations though, such as unfiltered relationship fields, no nested mutation inputs, full-update semantics for updateX, cursor pagination tied to primary-key order, custom SQL types mapping to String, and no subscription support.

DBIO::SQLite is the SQLite adapter for the DBIO ORM that makes your schema and result classes work naturally with SQLite. Loading this component into a schema pins the storage type to DBIO::SQLite::Storage so connections and SQL generation use SQLite-aware behavior. It brings SQLite-specific features such as native deploy, schema introspection, DDL generation and diffing without needing SQL::Translator, plus savepoints, deferred foreign key checks via the foreign_keys PRAGMA, native database backup and DateTime::Format::SQLite inflation. The driver is autodetected for dbi:SQLite DSNs, integrates with DBIO result classes and the use DBIO Schema => -sqlite shortcut, and runs tests against in-memory databases. The initial 0.900000 release adds the native storage and SQLMaker, deploy/introspect/diff tooling, and requires Perl 5.36 or newer and DBD::SQLite.

DBIO::PostgreSQL::PostGIS is a DBIO result-class component that adds PostGIS spatial support to DBIO::PostgreSQL schemas by automatically inflating columns declared as geometry or geography into lightweight DBIO::PostgreSQL::PostGIS::Geometry objects on read and deflating them to EWKT on write. The inflated geometry objects give convenient accessors for coordinates and helpers to build points with a specified SRID, and the component also promotes your resultset to include spatial query helpers so you can run distance or nearest-neighbor queries or drop into raw spatial SQL when needed. For schema-level operations like ensuring PostGIS is installed or checking its version there is a Storage class you can enable via storage_type, and you can customize or extend the ResultSet by subclassing the provided resultset class. You can turn off automatic inflation on a per-column basis by setting inflate_geometry to 0.

DBIO::PostgreSQL::Async is an asynchronous PostgreSQL storage driver for DBIO that uses EV::Pg and libpq's async protocol to avoid DBI and maximize throughput. It presents non-blocking API calls that return Future objects, supports a pipeline mode to batch queries into a single round trip, and includes prepared statement caching, COPY IN for bulk loading, and LISTEN/NOTIFY for real-time events. It also provides transaction helpers with connection pinning, an async connection pool, and an AccessBroker hook for refreshing connection info, while still offering synchronous fallbacks for callers that need them. The module works with EV-based event loops including AnyEvent, IO::Async via Loop::EV, and Mojolicious, and this first release bundles these async features into a DBIO storage implementation ready for high-performance, event-driven applications.

DBIO::PostgreSQL::Age is a DBIO component that adds Apache AGE graph support to DBIO::PostgreSQL, letting you work with property graphs and openCypher queries from your existing DBIO schema. It swaps the schema storage for DBIO::PostgreSQL::Age::Storage so you get graph lifecycle helpers like create_graph and a cypher(...) method that executes AGE's cypher() SQL function. To use it you load the component in your Schema and ensure each DB connection runs LOAD 'age' and sets the search_path, typically by using on_connect_call => 'load_age'. This module is a good fit if you use Perl with PostgreSQL and want to integrate AGE graph queries into your current DBIO-based application.

DBIO::Oracle is a thin convenience subclass for the DBIO ORM that automatically wires an Oracle-specific storage backend into your schema so you can connect to Oracle databases without hand-configuring storage. It is meant to be used in place of the base DBIO class or via the -ora shortcut and will even fall back to WHERE-clause joins for pre-9.0 Oracle servers. The initial 0.900000 release introduces a full set of Oracle-oriented features including sequence-based auto-increment, LOB binding and chunking, RETURNING INTO support, ROWNUM-based paging, savepoints and NLS session setup, plus native introspection, DDL generation and deployment tooling so DBIO schemas can manage and diff Oracle schemas natively. Use this module when you want DBIO-based applications to speak Oracle SQL and handle Oracle-specific schema and storage behavior with minimal fuss.

DBIO::MySQL::Async is a non-blocking MySQL/MariaDB storage backend for DBIO that talks directly to MariaDB's C client via EV::MariaDB to avoid DBI and squeeze out higher performance. It exposes Future-based async query methods, supports prepared statements, transaction helpers that pin a pooled connection for the transaction, and a pipeline mode that batches multiple queries into a single network round trip for lower latency. The module provides a connection pool with broker support to refresh connection info for new pooled connections and works with EV and common Perl event-loop frameworks such as AnyEvent, IO::Async and Mojolicious. Synchronous DBIO calls are still available but will block by waiting on the returned Future. This is the first release, aimed at apps that need high-throughput, low-latency async database access in Perl.

DBIO::DuckDB is a DBIO schema component that makes DuckDB the storage engine for DBIO-powered apps and exposes DuckDB-native capabilities from your schema objects. When loaded it forces storage_type to DBIO::DuckDB::Storage so you get a DBIO-aware driver built on DBD::DuckDB, a pure-FFI DBI driver that requires libduckdb at runtime, and benefits from DuckDB’s embedded, columnar analytical engine. The module provides high-level helpers and performance paths such as the DuckDB Appender for bulk inserts, an Arrow-aware columnar fetch path, read_csv/read_parquet/read_json table-function helpers, DDL emission and deploy tooling that uses a test-deploy-and-compare upgrade strategy, and introspect/diff support for schema upgrades. It also supplies a PostgreSQL-flavored SQL dialect with INSERT ... RETURNING and savepoint support, Quack client-server RPC helpers for recent libduckdb releases, and a convenient DBIO Schema => -du shortcut. The first release bundles storage, SQLMaker, DDL/Deploy, introspect/diff, Arrow and Appender escape hatches, extension and checkpoint helpers, and a test suite that runs against in-memory DuckDB instances so you can try it without external credentials.

DBIO::MSSQL is a lightweight DBIO subclass that makes DBIO work smoothly with Microsoft SQL Server by automatically selecting the DBIO::MSSQL::Storage and MSSQL-specific SQL dialect when you connect. Install it into your schema or use the provided -ms shortcut and your DBIO connections will handle SQL Server quirks like identity retrieval with SCOPE_IDENTITY, MONEY casting, TOP and ROW_NUMBER() based paging, and compatibility with DBD::ODBC, DBD::MSSQL and a DBD::Sybase/FreeTDS path. It also brings native DDL generation, schema introspection, and deploy/upgrade diffing so you can create, inspect and migrate SQL Server schemas from DBIO. This 0.900.000 initial release packages storage, SQL generation and schema-management features to provide a ready-made MSSQL driver for DBIO users.

DBIO::Sybase is a lightweight DBIO schema component that makes connecting DBIO-based applications to Sybase servers straightforward by automatically configuring the schema to use DBIO::Sybase::Storage when you connect. Use it directly in your schema or via the shortcut use DBIO 'Schema', -syb to pin the Sybase storage type so the driver and features for Sybase backends are applied automatically. The storage layer introspects the server and reblesses into the appropriate subclass, so it supports Sybase ASE and Microsoft SQL Server via DBD::Sybase and includes practical features such as FreeTDS support, DateTime and LOB handling, identity and bulk-insert helpers, native schema introspection and diffing, and Sybase ASE DDL generation. This is the initial standalone release, extracted from the DBIO core to provide focused, production-ready schema management for Sybase environments.

DBIO::MySQL is the MySQL and MariaDB driver component for DBIO that plugs into your DBIO Schema to provide MySQL-aware storage and schema management. Load it with the -mysql shortcut or as a component and DBIO will use DBIO::MySQL::Storage so you can deploy, introspect, diff and generate DDL for tables, indexes, foreign keys and views tailored to MySQL/MariaDB. The distribution also includes MySQL-aware SQLMaker behavior, DateTime parsing for MySQL timestamps, and a deploy workflow that can test changes against a temporary database before applying them. This first release extracts the historical DBIx::Class MySQL functionality into standalone modules, adds MariaDB variants, autodetects mysql DSNs, and exposes per-table engine, charset and collate options for DDL generation.

DBIO::Firebird is a lightweight convenience module for the DBIO ORM that makes using Firebird databases simpler by automatically selecting the Firebird storage implementation for your schema. It is a thin subclass of DBIO that sets the storage class to DBIO::Firebird::Storage when you call connection, so you do not need to configure the storage type yourself. Load it via the "-fb" shortcut when declaring your schema to pin Firebird storage by default. Use this module when your application talks to Firebird (or the related InterBase variant) and you want the DBIO schema to be preconfigured to the correct storage layer.

DBIO::DB2 is a lightweight helper for the DBIO ORM that makes it simple to use IBM DB2 by automatically selecting DBIO::DB2::Storage for your schema when you connect. Load this class into your schema or use the provided -db2 shortcut and call connect with your DSN, username, and password, and the module will set the DB2 storage driver and then hand off to DBIO's normal connection logic. It exists only to pin the DB2 storage implementation for you so you do not need to name the storage class yourself, making DB2-backed DBIO schemas easier to configure.

DBIO is a Perl ORM built on DBI that maps database tables to Perl classes and gives you a resultset API for building queries while keeping database-native behavior. It supports three ways to declare result classes—Cake (DDL-like), Candy (import sugar), and Vanilla—and provides automatic joins from relationship conditions, lazy resultsets, prefetch for eager loading, multi-column keys, and driver-specific SQL features. Native driver modules supply dialect-aware behavior for PostgreSQL, MySQL, SQLite, DuckDB and others, and you can generate classes from an existing schema with dbiogen. DBIO is a fork of DBIx::Class with namespace and implementation changes and is currently pre-1.0, so the core API is substantial and usable while a few edges are still being refined. Choose DBIO if you want a DBIx::Class-like toolkit that stays close to DBI and emphasizes native SQL features, flexible queries, and efficient fetching strategies.

Dist::Zilla::PluginBundle::DBIO is a ready-made Dist::Zilla plugin bundle for packaging, documenting and releasing DBIO-family Perl distributions. It wires up common build and release tasks like gathering files from git, producing metadata from a cpanfile, generating POD with the DBIO Pod::Weaver profile, moving extra tests into the release test tree, and deriving repository, bugtracker and homepage information from the git remote. You can set heritage=1 to mark code derived from DBIx::Class so generated POD and copyright reflect that, or set core=1 to use the core distribution workflow where the main module supplies the version and packaging is adjusted. Recent changes replace the GitHub metadata plugin with DBIO::CodebergMeta to derive repo info offline from a Codeberg or Forgejo remote, stop versioning submodules so only the main module gets its $VERSION rewritten, and add support for shipping agent skills and installing bundled executables to bin. If you publish DBIO drivers or the DBIO core this bundle consolidates the standard release, metadata and documentation conventions so you do not have to configure them manually.

RPi::ADC::ADS is a Perl module that makes it easy to read analog inputs from Texas Instruments/Adafruit ADS1xxx ADC chips on a Raspberry Pi over the I2C bus. It exposes a simple object interface to read raw counts, volts or percent from any of the four inputs and to configure channel, gain, conversion mode, data rate, comparator polarity and queue. The module handles the different resolutions of ADS10xx and ADS11xx models so you get correct bit shifting automatically. It supports multiple ADC addresses on the same bus and documents the Pi wiring for quick setup. Recent updates added conversion averaging so you can request the mean of N samples to smooth noisy or ripple-laden signals and the averaging is performed efficiently in the XS layer while transient I2C errors are retried, and voltage outputs are now scaled correctly for the programmed PGA gain. If you need reliable analog measurements from sensors or feedback circuits on a Raspberry Pi and want programmatic control over gain and sampling, this module is a practical, well documented choice.

SPVM is a statically typed language that uses familiar Perl-like syntax while aiming for native performance and easy integration with C, C++ and Perl. It supports ahead-of-time and just-in-time compilation, can produce standalone executables, and offers concurrency primitives such as native threads and goroutines, so it fits tasks that need speed or low-level library bindings. You can call SPVM methods from Perl and use its tooling for building, testing and debugging with support for LLVM and MSVC, making it useful for developers who want Perl-style syntax with static types and native interoperability. Be aware that SPVM is not yet at a stable 1.0 release and currently has no guaranteed backward compatibility, so APIs and behaviors may change as the project evolves.

LaTeX::ToUnicode is a small utility that turns common LaTeX markup such as accent commands, special characters and a few simple formatting commands into literal Unicode characters or into numeric HTML/XML entities, making it useful for converting fragments like bibliography entries and abstracts for display on the web or in plain text. It is designed for simplicity rather than complete fidelity so it removes braces, collapses extra whitespace and leaves complex structures such as math, tables, figures and most macros alone so you can spot untranslated commands by remaining backslashes. The convert function accepts options to emit entities instead of binary Unicode, to enable German-package shorthand, to produce minimal HTML output for links and basic emphasis, and to call a user hook for custom substitutions; a supplied regexp for terminating control words helps write safe hooks. This module is not a full document converter and does not attempt to be exhaustive, but it is practical for the common cases encountered when extracting text from LaTeX sources. Recent updates have broadened the set of recognized control sequences and improved handling of some cases, for example recognizing guillemet commands and converting \allowbreak to a zero-width space to produce cleaner output.

BibTeX::Parser is a pure Perl module for reading and parsing BibTeX bibliographies. It provides a streaming serial mode that yields entries one at a time for very large files and a caching mode that loads all entries for random access, counting and key-based lookup. Parsed entries expose their type and field values and offer canonicalized author and editor objects to simplify name handling. The constructor takes a filehandle and options such as an errorlevel setting to control how parse errors are reported. Use next to iterate through entries or read plus entry, entrykeys and has to work with the cached collection, making this module useful for Perl scripts that need to consume, transform or analyze BibTeX data.

RPi::RTC::DS3231 is an XS-based Perl interface for talking to a DS3231 real-time clock chip over I2C, packaged for Raspberry Pi but usable on any Linux system with I2C support. It provides simple methods to read and write individual date and time fields or set the whole timestamp as a "YYYY-MM-DD HH:MM:SS" string, switch between 12/24 hour modes and AM/PM, return an "HH:MM:SS" string, read the module's temperature in Celsius or Fahrenheit, and produce a DateTime-ready hash for easy construction of DateTime objects. The module should also work with DS1307 devices though that is untested, and you should close the device when finished. Recent fixes corrected BCD encoding bugs that could corrupt month and hour writes and normalized temperature output to two decimal places, so date/time and temperature reads behave reliably.

Music::VoicePhrase is a small Perl helper for algorithmic composition that builds measured phrases of multiple voices with both pitch and rhythm. It combines scale and interval selection from Music::Scales and Music::VoiceGen with rhythmic partitions from Music::Duration::Partition so you can generate motifs and matching voices for a measure-length phrase using simple attributes like base note, scale, octave, measure size, duration pool and motif count. The object exposes handy real-time attributes such as a priority queue, an index, current note and onsets so it can be used in live or streaming contexts. If you need to programmatically create short melodic phrases or drive MIDI/playback scripts, this module gives a lightweight, configurable building block for that work. Recent updates added the real-time-friendly attributes and voice handling to make live use easier.

BsDiPa is a Perl wrapper around Colin Percival's BSDiff code that makes it easy to create and apply compact binary patches from memory. It exposes simple core_diff_* and core_patch_* functions for producing and applying diffs and supports multiple compression backends when available, including zlib, bzip2, xz and zstd, plus a raw (uncompressed) mode for testing. The module always uses the integrated libdivsufsort optimization and operates in a 31-bit size mode, and it also offers a special text-oriented differential mode by passing a negative magic_window value. You can control compression behavior and resource use with per-operation I/O cookies or some global settings, and compile-time constants (HAVE_BZ2, HAVE_XZ, HAVE_ZSTD) tell you which compressors are available. Returns are uniform and include status constants like OK, FBIG, NOMEM and INVAL. If you need to build efficient binary-updates, delta distribution or patch-based synchronization inside Perl code, BsDiPa provides a compact, well-tested interface to BSDiff with multiple compression choices.

MetaCPAN::Client is a Perl library that gives you a convenient, DWIM-capable interface to the MetaCPAN web API so you can look up authors, distributions, releases, modules, files, CVEs and other CPAN metadata and get back rich Perl objects or iterable result sets. You can do simple lookups by name or PAUSE id or run complex boolean searches via a hash-based search spec using either/all/not to express OR/AND/NOT queries and you can fetch large result sets efficiently with the built-in scroller. The module also supports helper endpoints like autocomplete, recent releases, POD retrieval in multiple formats, and download_url queries with version ranges, and it lets you plug in a custom user agent or add caching for long running processes or scripts. It aims to be lightweight while exposing the full MetaCPAN API, so it is useful for command line tools, web apps and daemons that need up-to-date CPAN data. Recent maintenance fixes include ResultSet items now returning an arrayref and various Elasticsearch and CVE indexing improvements to keep the client compatible with the evolving MetaCPAN API.

CPAN::Audit is a Perl library for checking installed CPAN modules against the CPAN Security Advisory database so you can find known vulnerabilities that affect your code or servers. It is the engine behind the cpan-audit command line tool and links advisory reports to distributions and the specific versions you have installed, making it easy to see whether an installed module is affected. The advisory data now lives in a separate CPANSA::DB distribution so updates can be delivered independently, and CPAN::Audit will try to load CPANSA::DB and fall back to the older CPAN::Audit::DB with a deprecation warning; support for the old DB is being phased out. Recent fixes include resolving a warning when a module version could not be found and clarifications to how installed-version checks are performed. If you manage Perl installations or worry about supply-chain security, this module provides a straightforward way to automate vulnerability checks against CPAN advisories.

Markdown::Simple is a fast XS-based Perl module for converting Markdown to HTML that defaults to GitHub Flavored Markdown but can be switched to strict CommonMark and tuned by turning individual features on or off. It provides a simple functional interface for one-off conversions and an object-oriented renderer that reuses the parser's internal arena to avoid repeated allocations when converting many documents. There is also a strip_markdown utility that removes markup while keeping text scan-readable. The implementation is performance-oriented, with SIMD acceleration on supported CPUs and recent fixes for platform and build issues including OpenBSD load failures and C89 compatibility, so it is a good choice when you want a configurable, high-performance Markdown-to-HTML converter in Perl.

Amazon::Signature4::Lite is a compact Perl module that generates AWS Signature Version 4 headers for signing S3 and other AWS API requests, returning a hashref of headers ready to merge into HTTP::Tiny requests. You instantiate it with your access key, secret key, region and optional session token for temporary credentials, and it will produce Authorization, x-amz-date, x-amz-content-sha256, host and x-amz-security-token headers as needed. The module is designed to be dependency-light and not rely on LWP or HTTP::Request, so it fits well in small scripts and constrained environments. It also provides a helper to extract service and region from AWS endpoint hostnames, but that parser is focused on S3/AWS patterns rather than general URL parsing.