CPANscan

CPANSA::DB packages the CPAN Security Advisory dataset as a ready-to-use Perl data structure so programs can easily consult known advisories, with a single db subroutine that returns a hashref of all reports; it is primarily used by CPAN::Audit but any script or tool can call CPANSA::DB->db to access the data, and the release also ships a JSON version for non-Perl consumers. Each release includes a GPG signature and GitHub attestation so you can verify the archive came from the official source, and the project is published on GitHub releases for easy download.

Data::Sync::Shared is a Linux-only Perl module (64-bit Perl required) that provides five cross-process synchronization primitives implemented in file-backed shared memory and using futex for efficient blocking. It offers a counting semaphore for limiting resources, a barrier for N-way rendezvous, a reader-writer lock for shared vs exclusive access, a condition variable with a built-in mutex for predicate waits, and a once-gate for one-time initialization. All primitives support anonymous or memfd-backed regions, optional timeouts, scope-based guard objects that auto-release on exit, and optional eventfd integration for use with event loops. The implementation includes PID-based stale-lock detection so other processes can recover if a holder dies, but the shared memory is writable by anyone who can open the backing file so do not share backing files with untrusted processes. The recent 0.02 release fixes an eventfd_set self-assignment issue and adds additional SEE ALSO cross-links to related shared-data modules.

Data::Stack::Shared implements a high-performance LIFO stack in POSIX shared memory so multiple Linux processes can push and pop values with minimal overhead. It ships as two typed variants, Data::Stack::Shared::Int for 64-bit integers and Data::Stack::Shared::Str for fixed-length strings, and offers nonblocking and blocking push/pop calls with optional timeouts, peek, size and capacity queries, clear, and runtime statistics. The module uses atomic compare-and-swap on a top index for lock-free operations and falls back to futex-based blocking when the stack is empty or full, and it supports anonymous, memfd or file-backed mappings so you can pass a file descriptor between processes and use eventfd helpers for notifications. It requires Linux and 64-bit Perl and is aimed at high-throughput interprocess communication, but note the mmap region is writable by any process that opens it so you should not share backing files with untrusted code. This is the initial 0.01 release.

Data::Pool::Shared is a Linux-only Perl module that gives you a fixed-size, shared-memory object pool so multiple processes can allocate and return slots like a tiny cross-process allocator. It supports raw byte slots and typed variants for integers and floats, offers atomic operations and zero-copy read access for large entries, and exposes raw pointers for FFI or graphics use. The API includes blocking and non-blocking allocation, batch alloc/free, automatic scope guards, memfd or anonymous backing, eventfd notifications, and a recover_stale call to reclaim slots held by dead processes. Performance is focused on low-overhead atomic operations and futex-based wait/wake for full pools, so it fits use cases such as shared caches, counters, and IPC buffers where fixed-size records are acceptable. Note that it requires 64-bit Perl on Linux and that the shared mmap region is writable by any process with access to the backing file so do not share it with untrusted processes.

WebService::Bugzilla is a lightweight Perl client for the Bugzilla REST API that makes it straightforward to query and manipulate bugs, comments, attachments, users, products and other Bugzilla resources from Perl programs. Built with Moo and using the WebService::Client role, it provides lazy resource accessors so you can call methods like bug->get, bug->search and comment->create against a configured base URL and optional API key. The module enforces HTTPS by default and will append the Bugzilla REST path to your base URL when needed, while an allow_http option allows plain HTTP for local development. It unwraps responses and converts non-2xx results into exceptions or undef for missing resources, and the author labels this release as alpha and welcomes feedback and patches.

CGI::Info is a compact Perl toolkit for CGI scripts that centralizes and normalizes environment details and request handling so you do not hard-code paths or parameters into your code. It gives easy access to script names and paths, document root and temporary directories, host and protocol detection, cookies, and a simple browser classification for mobile, tablet, robot or search engine clients. Its params method reads CGI input or sensible fallbacks when you run scripts locally, supports upload directories and configurable max upload sizes, and includes a flexible allow schema that accepts regexes, Params::Validate rules or custom callbacks to validate or reject parameters, adding a lightweight web-application-firewall layer against common injection attacks. The module can be configured from files or environment variables, supports pluggable logging and caching, and exposes helpers for status, messages and stringified parameter snapshots for debugging. Note that tablet detection is limited and params returns a direct hashref that callers can mutate, and the author documents special licensing terms for commercial use beyond single-user GPL2.

Wikibase::Datatype is a Perl distribution that provides object classes for the core data types used by Wikibase and Wikidata. It implements items, properties, statements, snaks, references, sitelinks, lexemes, senses, forms and mediainfo along with value types such as time, quantity, globe coordinates, monolingual text and plain strings. The collection makes it easy for Perl programs to parse, construct, validate and serialize Wikibase-style data without reimplementing the underlying model. Utility modules for printing and structure serialization are also included. The project is maintained by Michal Josef Spacek, hosted on GitHub and released under the BSD 2-Clause license, so it is a convenient choice when building Perl tooling that reads or writes Wikibase/Wikidata content.

SimpleMock is a lightweight, extensible mocking framework for Perl designed to let you replace subroutines, database calls, HTTP requests and filesystem helpers with test doubles so your tests can run deterministically. It includes built-in models for SUBS, DBI, LWP::UserAgent and Path::Tiny and exposes simple APIs to register mocks globally or push temporary scoped overrides that are automatically removed at the end of a block. Mocks are looked up through a stacked set of layers so inner scoped mocks shadow outer ones and you can clear or merge mock sets as needed. The system is intentionally simple to extend so you can add models for other modules under the SimpleMock::Model namespace and share them via pull requests. There is no mock versioning built in so you should ensure mock definitions match the real module versions you are targeting and note that clearing mocks does not restore original subroutine code in place of delegation wrappers. The author flags possible limitations with some XS modules and with modules that override CORE::require but otherwise SimpleMock is a pragmatic choice for Perl developers who want straightforward, scope-aware mocking for unit tests.

Wikibase::Datatype::Print provides simple pretty-print helpers for objects from the Wikibase::Datatype family. Use the exported print function as print($obj, $opts_hr) to get a human-friendly string in scalar context or a list of formatted lines in list context. It handles main Wikibase types such as Item, Lexeme, Mediainfo and Property and relies on a collection of focused submodules to format values, statements, references, senses, sitelinks and common value types like time, quantity and globe coordinates. The function will raise an error for unsupported objects. This module is handy whenever you need readable, consistent textual representations of Wikibase datatypes for debugging, logging or basic display and it integrates with the rest of the Wikibase::Datatype toolkit.

App::GitKtti is a small Perl package that installs a set of command line helpers for managing Git branches using the git‑flow model. It provides tools like gitktti-checkout, gitktti-delete, gitktti-fix, gitktti-fixend, gitktti-move, gitktti-tag and gitktti-tests that perform common feature, hotfix and release operations with built in validation, optional colorized output and automatic cleanup to reduce mistakes and keep repositories consistent. If your team follows git‑flow or you want lightweight, scriptable safeguards around branch creation, deletion and tagging, these utilities make those tasks quicker and safer.

Numeric::Matrix brings fast, native 2D numeric arrays to Perl by combining SIMD-optimized kernels and optional BLAS-backed matrix multiply, making common numeric and machine learning tasks much faster without leaving Perl. It provides simple constructors for zeros, ones, random normal data and importing from Perl arrays, intuitive row/column access, element-wise and in-place arithmetic, scalar ops, reductions like sum and L2 norm, and matrix multiply that uses Accelerate or OpenBLAS when available with a scalar fallback otherwise. The module also includes useful fused operations for ML such as numerically stable row softmax, SiLU and GELU activations, transpose and easy serialization back to Perl arrays, plus a functional nmat_* interface for convenience, so it is a practical choice if you want compact, high-performance matrix work in Perl.

Graphics::Colourset is a Perl module for generating five-colour palettes suitable for UI themes and web styles, with each palette sharing a single hue while varying saturation and lightness to produce background, top shadow, bottom shadow, foreground and inactive foreground roles. You construct a colourset by giving a hue and a shade and can output colours as standard hex strings or X-style rgb strings. The module can produce alternate or multiple harmonised coloursets and applies a simple rule-of-thumb check to avoid combinations the author considers "ugly". If you ask for many distinct sets the generator may take longer and shades outside the documented 1 to 4 range are chosen at random. Use this when you want to automate consistent, contrasting colour schemes for X window managers or CSS without handcrafting every colour.

Text::NeatTemplate is a compact, speedy Perl template engine that fills the gap between simple variable substitution and heavyweight systems by offering formatted variables, simple conditionals with optional else branches, and the ability to call external functions from templates. It uses lightweight markup to insert values, apply predefined formatting directives such as dates, currency, casing, HTML and item splitting, and to show or hide template fragments based on whether a value exists, which makes it well suited for fast report generation or pages where performance matters more than advanced logic. The trade offs are intentional and include no escaping of braces, no nested variables, conditionals limited to presence tests and function arguments that cannot contain commas. The interface is straightforward with a constructor and a fill_in method and utilities to extract variable names and format values. A small recent fix addressed a munging complaint in the 0.1601 release.

Sah::SchemaBundle::CrockfordBase32 provides a ready-made Sah validation schema for strings encoded with Crockford's Base32, the human-friendly base32 alphabet that avoids ambiguous characters for easier transcription. It plugs into Data::Sah so Perl applications can validate, document, and enforce values that use Crockford Base32, such as compact identifiers, tokens, or binary-to-text encodings used in APIs and data storage. The distribution is tiny and focused, offering a single cfbase32_str schema, and is useful whenever you need a simple, reliable way to check that input or stored values conform to Crockford’s Base32 rules. This is the initial 0.001 release.

Graphics::Framebuffer is a Perl library for drawing directly into a Linux console framebuffer so you can plot pixels, draw lines, shapes, filled and textured primitives, render TrueType text and blit images without X. It exposes a simple, English-named API for common graphics operations and supports 32, 24 and 16 bit framebuffers with optional acceleration via Imager and optional Inline::C routines for much better performance. If no real framebuffer is available it provides an emulation mode so you can develop and test offscreen. This module is console-only and relies on framebuffer-capable drivers so it will not work inside X or with some proprietary GPU drivers, and 16 bit modes are slower and require conversions compared with 24/32 bit. The author keeps the manual current on GitHub and recent releases improved the documentation into a searchable Markdown manual and added robustness for VirtualBox and buffering, while continuing iterative performance and acceleration fixes.

Horus is a high-performance XS UUID/GUID generator for Perl that implements all RFC 9562 versions (v1-v8) plus NIL and MAX and offers ten output formats including hyphenated, hex, URN, base32/64, Crockford and raw binary. It provides both procedural functions and an OO interface for single or bulk generation, supports deterministic namespace UUIDs (v3 and v5), time-based and sortable variants (v1, v6, v7), and handy utilities for validation, parsing, comparison and format conversion. Written with no external C library dependencies and optimized with random buffering and precomputed tables, Horus is designed to generate millions of v4 UUIDs per second while minimizing Perl/C crossings. Recent releases tidy up internal XS/op handling and pp code and include platform fixes for clock_gettime and threaded Perls to improve stability. If you need a fast, flexible UUID generator with broad format and version support, Horus is a solid choice.

Physics::Ellipsometry::VASE is a Perl/PDL toolkit for fitting user-defined optical thin-film models to variable-angle spectroscopic ellipsometry (VASE) data using Levenberg-Marquardt optimization. It reads simple whitespace data and auto-detects the J.A. Woollam VASE file format, can use per-point uncertainty columns as fit weights, and handles the mapping between a compact user model interface and the optimizer while computing numerical Jacobians automatically. You supply a model sub that takes a PDL of parameters and an (n,2) matrix of wavelength and angle and returns predicted Psi and Delta, and the module returns optimized parameters along with covariance, model predictions and iteration information. It can also produce multi-angle plots when PDL::Graphics::Gnuplot is available. This module is useful for researchers or engineers who need to extract film thicknesses and optical constants from ellipsometry data and who are comfortable writing simple models in Perl with PDL.

JSON::Schema::AsType converts a JSON Schema into a Type::Tiny type so you can validate Perl data structures against JSON Schema rules, perform quick true/false checks, and get short or verbose explanations for validation failures. It supports multiple schema drafts with 2020-12 as the default and exposes methods to fetch or register remote schemas, resolve $ref references, validate a schema itself, and retrieve the compiled Type::Tiny type. You can customize type behavior such as treating strings and numbers in the usual Perl loose way by disabling strict_string, and you can add new vocabulary roles to implement custom keywords and constraints. The module passes most JSON Schema test suites but the author notes known limitations around numeric precision depending on the local Perl build, always-on Unicode regex mode for patterns, and some reference-related tests in newer drafts. If you want schema-driven validation integrated with Perl's Type::Tiny ecosystem and a way to extend schema capabilities, this module is a practical fit.

Shannon::Entropy::XS is a small, fast Perl extension that computes the Shannon entropy of a string and returns the result in bits via a simple entropy() function, making it handy for estimating randomness, scoring password strength, or analyzing data distributions. It provides a drop-in, C-backed alternative to the pure-Perl Shannon::Entropy module and is aimed at situations where you need to calculate entropy for many strings or inside tight loops. Benchmarks show it runs orders of magnitude faster than the pure-Perl implementation, and a recent release added a custom opcode that further increased throughput from about 5.95M/s to about 7.63M/s in microbenchmarks, so it is a good choice when performance matters.

Filesys::Fuse3 is a Perl interface to libfuse3 that lets you implement full filesystems in user space by writing simple callback functions and calling Filesys::Fuse3::main to mount them, making it easy to expose virtual files and directories, proxy real filesystems, or build networked mounts all from Perl. It exposes the usual FUSE operations such as getattr, open, read, write, readdir and many others, offers configurable mount and behavior options including single or multithreaded modes, and ships example scripts to get you started. The project was recently forked from the original Fuse module and updated for fuse3 compatibility, so it reflects libfuse3 API changes and no longer implements a few older callbacks like getdir, ftruncate and fgetattr. If you need to prototype or deploy custom filesystem logic in Perl and want to target modern FUSE, this module is directly relevant.

App::DBBrowser is a simple interactive command-line program for exploring SQLite, MySQL, and PostgreSQL databases. It gives you a quick, terminal-based way to connect to a database, browse schemas and tables, inspect rows and column definitions, and run ad hoc SQL without writing a script. It is handy for developers and administrators who need fast, hands-on access to data and structure on local or remote servers and works with standard Perl database drivers. The project is free software distributed under the same terms as Perl 5.10.0.

CPAN::Maker is a command-line toolchain for turning a Perl project into a CPAN-ready distribution. You drive it with make-cpan-dist.pl or its bash wrapper and a YAML buildspec, and it will discover module dependencies, generate a Makefile.PL, collect your modules, scripts, tests and extra files, and build a tarball ready for publishing. It supports automatic dependency resolution (scandeps or Module::ScanDeps::Static), optional recommended, build and test dependencies, and options to control versioning and which files are packaged, so it is handy for authors who want to automate packaging instead of handcrafting manifests. The author notes that dependency scanners are not perfectly reliable so you should review the generated requires lists. In the recent 1.7.2 release support for Module::CPANfile and Module::ScanDeps::Static was added and packaging was improved to include .pm and .pod files while skipping scanning of POD files.

Term::TablePrint is a small Perl utility for displaying an array-of-array table in a terminal and interactively browsing it with keyboard or mouse controls. It supports familiar navigation keys for scrolling and paging, a regex search prompt, an optional expanded single-row view that prints each column on its own line, and options to hide or choose columns when the table is wider than the terminal. The module automatically adjusts or truncates columns to fit the terminal, aligns numbers, can filter or hex-encode binary fields, optionally shows ANSI colors, and provides a progress indicator for very large tables. You can call it as a simple functional helper print_table or use it in an OO style, and the first row of your input is treated as column headers. Note that it expects decoded strings, a matching STDOUT encoding and a monospaced terminal, and it requires Perl 5.16 or newer. Recent updates improved the binary-to-hex conversion and fixed number fraction formatting.

Jacode is a lightweight Perl module that detects and converts Japanese character encodings so you can handle mixed or legacy text reliably in scripts and applications. It understands common encodings such as Shift_JIS, EUC-JP, JIS and UTF-8, offers helpers to detect a string's encoding and to convert in one call, and preserves compatibility with older jcode-style APIs for easy migration. The module targets Perl 5.00503 and later and is useful if you work with email, logs, legacy files or systems where multiple Japanese encodings appear. Recent maintenance focused on robustness and quality, with a refactor that split init routines for clarity, expanded test coverage and encoding checks, added a security policy, and removed dead code to make the converter more maintainable and trustworthy.

MARC::Convert::Wikidata is a conversion helper that turns MARC bibliographic records into Wikibase item objects you can load into Wikidata. It was developed for the National Library of the Czech Republic so many mapping rules are catalog-specific, but it exposes callback hooks for language, people, publisher, series and cover lookups so you can adapt mappings to other environments. You instantiate it with a MARC::Record and then ask it to detect record type (monograph, audiobook, periodical), extract external identifiers, or produce a Wikibase::Datatype::Item representing the bibliographic item. The module relies on a set of item-specific helper classes and is practical when you need automated, scriptable MARC-to-Wikidata conversion while retaining control over library-specific translations and lookups.

Geo::Address::Parser::Country is a small helper for normalising the trailing piece of a place string into a canonical country name, aimed at messy genealogy and imported address data where country names are abbreviated, historical, or inconsistent. You give it Locale::US, Locale::CA (English and French) and Locale::AU objects and optionally a Geo::GeoNames object, then call resolve with the last comma separated component and the full place string; it tries a direct lookup of common variants, recognises US states, Canadian provinces and Australian states and will append a country suffix when appropriate, falls back to Locale::Object::Country and GeoNames if available, and returns the resolved country plus the possibly modified place string, any warnings and an unknown flag. It is tolerant of poor data but currently expects the country or state to be the final comma separated component and a normalise_place helper for inserting missing commas is planned. Note two known caveats from the author: the direct lookup maps "NL" to the Netherlands which can conflict with Newfoundland and Labrador, and Geo::GeoNames objects may need a thin wrapper because of AUTOLOAD masking of can('search'). The most recent release made a CI fix.

Numeric::Vector is a Perl module that gives you fast, SIMD-accelerated one-dimensional numeric arrays for heavy numeric work by storing 64-bit floating point values and automatically using the best CPU instruction set available at compile time (AVX2, AVX, SSE2, NEON, or a scalar fallback). It supports both an object-oriented API and a functional style with nvec_* imports, lets you build vectors from arrays or generators like range and linspace, and convert back to Perl arrays. You get elementwise arithmetic, in-place variants, overloaded operators, common math and trig functions, reductions such as sum, mean, variance, dot, norm and cosine similarity, BLAS-style operations like axpy and fma, and utilities for sorting, masking, selection, cumulative ops and predicates like isnan and isfinite. Comparisons produce mask vectors and boolean reductions like any and all are provided, and importing installs true XS subroutine aliases to avoid wrapper overhead. The module is focused on dense double-precision numeric work and is presented as an initial public release.

Perl::Critic::PJCJ is a small set of Perl::Critic rules that help teams keep Perl code readable and consistent by enforcing quoting conventions and line length limits. It offers a policy to prefer simple and consistent string quoting and to avoid unnecessary quote operators, plus a policy to flag lines that exceed a configurable maximum length with a sensible default of 80 characters. The rules are configurable and easy to enable from a .perlcriticrc or the command line, and recent updates added per-file line length overrides via .gitattributes and a way to exempt specific long lines with regex patterns. The module also improves its suggestions for tricky quoting cases and fixes false positives for escaped backslashes, making the guidance more practical for real code. If you want lightweight, configurable checks for quoting style and line width as part of a Perl code quality workflow, this package is a good fit.

Data::ReqRep::Shared provides a high‑performance request/response channel for interprocess communication on Linux using a single shared‑memory file, letting multiple clients send requests and multiple workers reply without a broker or per‑connection sockets. It comes in two variants: Str for variable‑length byte payloads using a mutex‑protected circular arena, and Int for lock‑free int64 requests and responses that is roughly 1.5x faster in single‑process benchmarks. The API is simple: servers recv/recv_wait (including batch receives for Str) and reply by slot id, while clients use synchronous req/req_wait or asynchronous send/get with lightweight per‑request response slots and cancel support. The module integrates with event loops via optional eventfds, supports file‑backed, anonymous, and memfd shared memory, and includes crash recovery features such as PID‑based stale mutex detection, automatic reclamation of dead clients' slots, and generation counters to avoid ABA hazards. Tunables let you size the request ring, response slot pool, and fixed response payload size for Str workloads, and the author provides benchmarks showing competitive cross‑process throughput versus pipes and sockets. Note that this is Linux‑only and requires 64‑bit Perl; the initial 0.01 release implements both Str and Int paths, targeted per‑slot futex wakes, dual eventfd support, and memfd/anonymous creation modes.