CPANscan

Data::RingBuffer::Shared implements a fixed-size circular buffer in shared memory for Linux running 64-bit Perl, letting multiple processes efficiently publish and read a rolling window of values. Writes never block and always succeed, overwriting the oldest entries when the buffer is full, while readers can fetch the latest values by relative index or by absolute sequence number, dump the whole buffer, or wait for new data with optional timeouts and eventfd notifications. Two typed variants are provided for 64-bit integers and doubles, and write() returns a sequence number for coordinated reads, making this well suited to metrics, sensor streams, debug traces and other rolling-window use cases. Be aware the underlying mmap is writable by any process that opens it, and this module is Linux-only.

Data::Queue::Shared is a Linux-only Perl library for fast, memory-mapped multi-producer, multi-consumer queues designed for 64-bit Perl. It provides lock-free integer queues (Int, Int32, Int16) using the Vyukov algorithm for extremely high throughput and a mutex-protected string queue that stores variable-length entries in a circular arena. Queues can be file-backed, anonymous for fork-inherited sharing, or backed by memfd for passing via file descriptors, and the API supports non-blocking and blocking push/pop with timeouts, batch operations, deque operations for strings, peeking, and basic management and statistics. Optional eventfd integration lets you wake event loops across processes with explicit notify calls to control batching. The Str variant includes futex-based waits and automatic recovery from dead-process locks, and benchmark numbers in the distribution show substantial performance gains versus common Perl IPC alternatives, making this module a good fit when you need low-latency, high-throughput interprocess queues on Linux.

Data::Heap::Shared provides a fast shared-memory binary min-heap (priority queue) for multiple processes on Linux using 64-bit Perl. It stores integer (priority, value) pairs and always pops the lowest priority first, and offers simple methods like push, pop, pop_wait for blocking pops with timeout, peek, size, capacity, clear, sync and unlink, plus constructors for memfd or an existing file descriptor and optional eventfd notification. Access is mutex-protected with futex-based waiting and PID-based stale-mutex recovery so it supports concurrent producers and consumers with good throughput. Note that if a process dies while holding the heap mutex the module can recover the lock but the heap contents may be partially sifted, so critical use cases should detect recovery and rebuild the heap after a crash. Benchmarks in the distribution show multi-million operations per second in single-process tests and strong aggregate performance across workers. Because the backing mmap region is writable by any process that opens it, do not share the heap with untrusted processes.

Data::HashMap::Shared implements very fast, file-backed hash maps that multiple processes can open and use concurrently on Linux with 64-bit Perl, making it easy to share caches, counters and small data stores between worker processes. It offers type-specialized variants for integer and string keys and values so operations avoid unnecessary boxing, and it uses mmap, a futex-based read/write lock and lock-free fast paths for reads and atomic counters for high throughput. Optional features include LRU eviction with a clock algorithm, per-key TTLs, sharding across multiple files for parallel writes, an arena for string storage, a keyword XS API for extra speed and cursors and batch ops for efficient iteration and bulk work. The module exposes a rich API for put/get/remove, atomic incr/decr and CAS, cursor-safe iteration, diagnostics and file management, and it detects and recovers stale write locks if a writer dies, though cross-container PID namespaces are not supported and a map may need clearing after recovery for safety-critical uses. If you need a low-latency, multiprocess shared hash with optional eviction and TTL semantics, this module is a strong choice.

Data::Graph::Shared provides a compact, fast directed weighted graph implementation that lives in shared memory so multiple Linux processes can access and mutate the same graph concurrently. Nodes are allocated from a bitmap pool and edges are stored as adjacency lists in a separate pool, with simple APIs for add_node, add_edge, neighbors, degree, node_data and stats, and mutex-protected mutations with PID-based stale-recovery to handle crashed processes. It is designed for performance and multi-process coordination, with benchmarks showing millions of ops per second for common operations, and it pairs well with other shared structures like a shared heap for Dijkstra or Prim algorithms. Note that remove_node only drops the node and its outgoing edges, not incoming edges, which is an intentional O(1) design choice, and that the module is Linux-only and requires 64-bit Perl. Also be careful with security because the mmap region is writable by any process that opens it, so do not share backing files with untrusted parties.

Data::Buffer::Shared provides fast, type-specific fixed-size buffers backed by file memory maps so multiple Perl processes can share numeric and string data with low overhead on Linux. It supplies variants for integer, floating and fixed-length string element types and gives lock-free atomic get/set operations and atomic counters for integer types, while seqlock-guarded bulk operations and a futex-based read/write lock handle larger or batched access patterns. The module supports file-backed, anonymous and memfd-backed buffers, offers both keyword and method APIs, exposes zero-copy aliased scalars and raw pointer access for advanced use, and intentionally keeps buffers presized rather than growing. Note that it is Linux-only and requires 64-bit Perl. The recent 0.02 release fixes object destruction ordering and adds cross-links to related shared-data modules.

XML::Sig is a Perl toolkit for creating and verifying XML Digital Signatures that follows the W3C XML Signature rules. It lets you embed cryptographic signatures into XML and verify incoming signed XML, which is useful for secure XML exchanges such as SAML messages. The module supports RSA, ECDSA, optional DSA, HMAC and embedding X.509 certificates, lets you choose digest and signature hash algorithms and canonicalization/transforms, and can sign elements by their ID or by an XPath selection. Verification returns a simple true or false and can return the embedded signer certificate for further validation. The module relies on standard XML and crypto libraries like XML::LibXML and Crypt::PK::RSA. Recent releases fixed a security issue that could allow unsigned XML to validate and made DSA and SHA1 usage optional to better match modern platform defaults.

Google::GeoCoder::Smart is a lightweight Perl wrapper around the Google Geocoding JSON API that makes it simple to turn structured addresses or place IDs into geographic coordinates. You create an object with your Google Maps API key and optional host, scheme and timeout, then call geocode_addr with address parts, place_id or extras like language, region, bounds and components. The module returns the API response as a Perl hashref that mirrors Google’s JSON and also includes the raw JSON for debugging. It relies on small, commonly used modules such as HTTP::Tiny and JSON::PP so it is easy to install and useful for scripts and small applications that need straightforward geocoding. There is a deprecated legacy geocode wrapper for backward compatibility.

Object::Proto::Sugar gives Perl developers a Moo-like declarative syntax for building classes and roles on top of Object::Proto. It provides compile-time keywords such as has, extends, with, requires, and method modifiers before, after, and around that compile down to the XS-backed Object::Proto implementation for minimal runtime overhead. Attribute declarations support read/write modes, type constraints, defaults and builders, coercions and triggers, predicates and clearers, named readers and writers, and optional function-style accessors with a configurable prefix. Type constants and shorthand sugar constants are opt-in so only the core keywords are imported by default. The module also supports roles, positional attribute syntax, accessor import helpers, and runtime consumption checks, and its included benchmarks show significantly higher throughput than Moo and Mouse for simple new/get/set workloads. Use this if you want concise, familiar declarative object syntax with high performance when building Object::Proto-based classes and roles.

Object::Proto is a high-performance alternative to Perl's traditional bless-based objects that stores instances as compact arrays and maps property names to slot indices at compile time. It gives you fast, generated accessors and supports both positional and named constructors while still blessing objects so isa and can work normally. You declare class properties with built-in or custom type constraints, defaults, lazy builders, triggers, weak references, readonly flags, and other modifiers, and the module also supports inheritance, multiple parents, prototype chains, roles, singletons, and method modifiers. There are convenience features for zero-overhead BUILD and DEMOLISH hooks, function-style imported accessors for even lower call overhead, and an XS API for registering C-level type checks when maximum speed matters. If you need compact, typed, and very fast objects in Perl for code that creates or manipulates many instances or hot inner loops, Object::Proto is likely relevant and worth evaluating.

Test::QuickGen is a lightweight Perl toolkit for creating random test data such as monotonic numeric ids, ASCII and UTF-8 strings, sanitized UTF-8 strings that keep only letters, numbers and whitespace, multiword strings, random integers in a range, optional (nullable) values and random picks from a list. The id generator yields a process‑local counter that increases from zero and the various generators let you control length and character sets while producing uniform randomness suitable for testing and fuzzing. The module is fast, has minimal dependencies, and exposes convenience import tags so you can pull just the helpers you need into test scripts. These generators are not cryptographically secure and are intended only for testing and data generation.

Travel::Routing::DE::HAFAS is a client for German HAFAS itinerary services that lets you look up public transport connections between named stops or EVA IDs using the mgate.exe interface. You create it with a service name plus origin and destination and can fine tune queries with date/time, arrival vs departure, intermediate stops, allowed or excluded transport modes, caching, and HTTP options. The module returns rich Connection objects and service messages for each itinerary and also provides an asynchronous promise-based constructor for non-blocking requests. It is useful when you need programmatic access to regional transit routing in Germany, but note that some HAFAS services are not well tested.

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::Deque::Shared provides a fast shared-memory double-ended queue for Perl on Linux, letting multiple processes push and pop items at both ends with non-blocking and blocking-with-timeout variants, and offering file-backed or memfd-backed mappings and reattachment from a file descriptor for persistent or handoff use. It is implemented as a ring buffer with careful concurrency handling and futex-based waits, exposes capacity, size and operation statistics, and includes eventfd support for integration with event loops or notification schemes, making it well suited to high-throughput producer/consumer and IPC scenarios. Be aware that clear() is not concurrency-safe and the mmap region is writable by any process that opens it, so do not share backing files with untrusted processes. This module is Linux-only and requires 64-bit Perl.

Data::Log::Shared is a Linux-only, 64-bit-Perl append-only log stored in shared memory that lets multiple processes efficiently append variable-length records and lets readers replay or tail the log from any byte offset. Writers use atomic tail updates so concurrent appends are safe and committed entries remain until you explicitly reset or truncate the log, which makes it suitable for audit trails, event sourcing, persistent debug logging, and other cases where you need an immutable history rather than a consumed queue or overwriting ring. The API supports append and read_entry calls, iteration and tailing with wait_for, file-backed or memfd-backed creation, eventfd notifications, msync/unlink, and runtime stats so you can monitor counts and capacity. Performance is high, with benchmarks showing millions of appends or reads per second on typical x86_64 hardware. Two important caveats are that reset is not concurrency-safe and the mmap region is writable by any process that opens it, so do not share backing files with untrusted processes.

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.