CPANscan

Params::Validate::Strict is a Perl library for declaratively validating and coercing named parameters against a detailed schema so your code gets well-formed input instead of you having to hand-parse and check everything. You define types and constraints for each field including strings, integers, numbers, refs and objects, and you can nest schemas for hashrefs and arrayrefs, supply default values, mark fields optional or nullable, apply transforms and callbacks, reuse custom types, and run cross-field and relationship checks like mutually exclusive or dependent parameters. The function returns a new hash of validated and coerced values or croaks with a clear message, and it can be configured to warn, die, or ignore unknown parameters and to use a logger. It is useful for input sanitization, building a WAF, auto-generating black box tests, and improving API documentation. Note that the module does not untaint values for Perl taint mode, caller-supplied regexes can cause pathological backtracking on hostile input, and error messages may include submitted values so you should still perform any required output encoding.

SPVM is a compact statically typed language with Perl-like syntax that targets high performance and easy integration with C/C++ and Perl. It gives you familiar Perl-style source files and one-liners while adding static typing, ahead-of-time and just-in-time compilation, native and precompiled class support, lightweight threading and goroutine features, and a builder toolchain that can produce executables or shared libraries. You can call SPVM methods from Perl and bind C/C++ libraries into SPVM programs, and the project provides a growing standard library, examples and build helpers (spvm, spvmcc, spvmdist and SPVM::Builder). Note that SPVM is still pre-1.0 and the author does not guarantee long-term backward compatibility. The recent updates fix a temporary-variable initialization bug and expand the build tooling with richer Makefile.PL options (for include and lib directories) plus a class_search_dir option and new native APIs such as no_close and set_no_close, while tightening some syntax and renaming a few compiler APIs.

Genealogy::Wills provides a simple Perl interface for searching a local SQLite copy of the Kent Wills Transcript so you can look up historical last wills and testaments offline. You create an object with new and then call search to find records by last name and optional first, middle, town, or year filters. Each result is returned as a hash reference with first, middle, last, town, year, and a full https URL back to the original transcript entry. The search is exact match only and the last name argument is strictly validated so punctuation such as apostrophes is rejected and names like O'Brien must be passed as OBrien. Be careful that context matters in Perl: list context returns all matches while scalar context returns only the first match. The module ships a bundled Kent database built via perl bin/create_db.PL and you may point new at a different data directory or a config file if needed. The author documents known limits and safety measures, noting that the data covers Kent only, there is no fuzzy full text search, and inputs are validated and bound to parameterized SQL to reduce injection risk.

Data::HashMap::Shared implements high-performance, file-backed shared-memory hash maps for Linux that let multiple processes share counters, caches, and arbitrary key-value data via mmap. It provides lock-free fast-path reads, futex-based locking for writers, atomic integer operations and compare-and-swap, optional LRU eviction and per-key TTLs, and specialized variants for different integer and string key/value types to avoid conversion overhead. You can back maps with regular files, memfd descriptors, or anonymous shared mappings, shard them across files for parallelism, freeze a map into a read-only snapshot for shipping, and use cursors or batch ops for iteration and bulk work. The module is engineered for throughput and low latency and includes crash-recovery and stale-lock handling, but it is Linux-only and requires 64-bit Perl, TTLs are monotonic and do not expire across reboots so you should rebuild or flush expiries if you move files between boots, and extreme setups with more than 1024 concurrent reader processes or cross-container PID namespaces can interfere with its reader-recovery guarantees.

Data::Graph::Shared provides a fast, Linux-only shared-memory directed weighted graph that multiple processes can attach to and query or mutate concurrently via a single futex-based mutex. You allocate a fixed capacity of nodes and edge slots up front and then use simple methods like add_node, add_edge, neighbors and degree to build and traverse adjacency lists that live in an mmaped pool, with add/remove operations serialized and an eventfd API for integrating with event loops. The module is designed for high throughput and low overhead and includes a choice of O(1) node removal that leaves incoming edges dangling or a heavier remove_node_full that splices them out in O(N+E). It also supports freezing a file-backed graph and opening it on other machines as a read-only, lock-free view for shipping immutable graph artifacts. Note that it requires 64-bit Perl, trusts any process given write access not to corrupt the mapping, and while the mutex can recover from dead owners it cannot automatically undo a writer that crashed mid-update. Recent work added recovery for interrupted creates, the freeze/new_readonly read-only mode, and various robustness and security hardenings.

Data::Fenwick2D::Shared implements a Linux-only, 64-bit Perl shared-memory two-dimensional Fenwick tree that lets multiple processes maintain and query a fixed rows-by-cols grid of signed 64-bit integers with very fast point updates and rectangle-sum queries in O(log rows * log cols) time. It is ideal for running heatmaps, cumulative-frequency tables, or any application that needs incremental updates and fast area-sum queries over a grid. The grid can be shared via a backing file, an anonymous mapping across fork, or a memfd passed between processes, and a futex-based write-preferring rwlock lets many readers query concurrently while writers mutate safely. You can also "freeze" a file-backed grid to produce an immutable, read-only artifact that other machines can memory-map and query lock-free, with the caveat that frozen files are native-endian 64-bit blobs and only portable between identical architectures. Cells and sums are 64-bit signed integers and wrap on overflow, memory usage is roughly (rows+1)*(cols+1)*8 bytes plus a header, and the module enforces sensible bounds and crash-recovery behavior while noting small limitations such as lack of PID-reuse detection and a remote corner case where more than 1024 concurrent readers plus a crash could impede writer recovery.

Data::Fenwick::Shared provides a Linux-only, 64-bit-Perl implementation of a Fenwick (binary indexed) tree that lives in shared memory so multiple processes can update and query a single compact array of 64-bit counters. It offers O(log n) point updates and prefix-sum queries, a find operation for weighted sampling and rank queries, and a merge operation for combining two point-mode trees. For workloads that need range updates it features a range mode that implements range_add and range queries using the two-BIT technique at the cost of double the memory and without support for find or merge. Trees can be anonymous, backed by a file, or created on a transferable memfd, and a file can be frozen to produce a read-only, lock-free snapshot that can be shipped to other machines of the same architecture. Concurrency is handled with a futex-based rwlock and the design includes crash-recovery measures, but values wrap on 64-bit overflow and frozen files are native-endian so they are not portable across different architectures.

Data::DisjointSet::Shared implements a classic union-find or disjoint-set data structure in shared memory on Linux so multiple processes can cooperate on a fixed universe of numbered elements. It exposes the usual operations such as union, find, connected and set_size, plus num_sets and capacity, and supports batching many unions under a single lock for efficiency. The implementation uses path compression and union by size for near-constant amortized performance and stores parent and size as compact 32-bit arrays so the footprint is predictable at about 8 bytes per element plus a small reader table. Sharing is flexible: you can use a backing file, a memfd that you pass between processes, or an anonymous mapping inherited across fork, and reopening an existing backing file preserves the partition. Mutations are serialized by a write-preferring futex rwlock with dead-process recovery, and note that find and connected perform path compression so they also take the write lock. The module includes crash-safety measures so the structure stays consistent up to the last completed union, but it documents two practical limits to be aware of which are PID reuse edge cases and a 1024-entry reader-slot table that can make writer recovery awkward only in extremely high concurrency crash scenarios. Backing files are created securely by default with owner-only permissions and O_NOFOLLOW to avoid symlink attacks, and you can request a different file mode when you need multiuser sharing. This module is Linux-only and requires 64-bit Perl.

Data::Deque::Shared provides a high-performance double-ended queue that lives in shared memory on Linux and is designed for multi-producer, multi-consumer workloads. It comes in two concrete flavors, one for 64-bit integers and one for fixed-size strings, and supports both anonymous memfd mappings and file-backed mappings you can attach from multiple processes. Operations are lock-free and use atomic updates for push and pop, with futex-based blocking variants and optional timeouts for waitable semantics, plus an eventfd hook for notifications. The implementation is crash-aware and can recover interrupted creates and stalled publishers while reporting recoveries and other statistics, and the module exposes convenience methods for draining, querying size and capacity, and exporting or reattaching via file descriptors. Note that it requires 64-bit Perl on Linux, capacity is limited to 2^31, and the string variant uses fixed per-slot storage so memory usage is capacity times max length.

App::Device::Chip::sensor is a small async base class for building Perl applications that periodically poll Device::Chip sensors and do something with the readings. You subclass it, implement an output_readings method and optionally override hooks such as after_sensors, on_sensor_ok and on_sensor_fail, then call run to start an evented loop that fetches sensor values on a configurable interval and hands them to your code. The base class supplies command line parsing, chip and sensor construction helpers, a print_readings convenience, support for adding chips programmatically, and simple filtering options for noisy gauges such as midN and recursive averages, plus a best-effort mode that treats read failures as transient and invokes failure hooks rather than aborting. It is written to work with Object::Pad and Future::AsyncAwait for async control flow and is suitable for small exporters, data-loggers or monitoring tools that talk to Device::Chip drivers. The recent release updates async I/O to use Future::IO v0.18 and ensures chip power is applied before attempting configuration changes.

Sys::OsRelease is a small helper for reading an operating system's standard /etc/os-release file and exposing its fields in Perl so programs can detect OS and distribution details without heavyweight dependencies. It provides a singleton object with convenient auto-generated read-only methods for standard attributes like ID, NAME and VERSION_ID, plus generic get/has_attr/found_attrs accessors and a platform() helper that prefers common ID_LIKE values for determining distro families. The module keeps prerequisites minimal so it is suitable for scripts running in containers or bare system installs, and a parallel Sys::OsRelease::Lite package preserves compatibility with older Perl versions. The latest 0.4.6 release tidies documentation and exports metadata so the Lite build can fill gaps previously handled by Dist::Zilla, improving packaging and test cleanliness.

RT::Extension::AwayMode is a lightweight extension for RT that lets users mark themselves as away and automatically unassigns their tickets to Nobody when someone else replies or comments, preventing requests from being silently stuck with absent owners. The extension shows a clear banner while away mode is active, lets administrators set or clear away status for other users, and offers configuration options to control which transaction types trigger the handoff and whether privileged internal comments are ignored. It works with RT 6.0.3 and recent updates added comment handling and configurability for which transactions cause a handoff, with Catalan and Spanish translations included in the latest release.

App::Easer is a small framework for quickly building hierarchical command line applications in Perl, letting you describe a main command and nested subcommands with options, environment-variable bindings, defaults and execute callbacks so you can get a usable CLI and automatic help out of very little code. The project concentrates development on a V2 interface while keeping a legacy V1 available, and it supports features such as option parsing, residual arguments, merging option values through a command hierarchy, automatic help generation and splitting an app into modules, plus a helper App::Easer::ConfigHash for configuration handling. The author describes the software as late alpha but usable and the minimum Perl requirement is 5.24, bugs are tracked on GitHub, and recent updates have focused on improving help and environment‑variable handling and fixing documentation for options implemented as a method.

Data::DDSketch::Shared provides a compact, shared-memory quantile sketch that tracks streaming numeric data with a guaranteed relative error, making it ideal for latency and other wide-range, long-tailed measurements. It uses logarithmic buckets to give any requested quantile within a configurable relative accuracy (1% by default) while using a fixed amount of memory, and it also keeps exact counts and extremes plus a running sum for mean calculations. Multiple processes can update and read a single sketch via a backing file, memfd, or inherited anonymous mapping and the module supports freezing a file to produce a lock-free, read-only artifact that can be copied to other machines for safe querying. The implementation is Linux-only and requires 64-bit Perl, frozen files are native-binary so they must be used on the same architecture, and a bounded number of buckets means extremely small or large magnitudes collapse into edge buckets unless you increase the bucket count. The library uses futex-based locking with dead-process recovery so it is robust in practice, but rare corner cases such as PID reuse, reader-slot exhaustion, or filesystem allocation failures can affect writers or produce SIGBUS on some systems, so you should size storage appropriately and call sync when you need durable writes.

Data::CuckooFilter::Shared provides a compact, fixed-size cuckoo filter implemented in shared memory for Linux that lets multiple processes efficiently track approximate set membership with support for deletion. You add byte strings and the filter stores 16-bit fingerprints, so membership queries are either "definitely not present" or "probably present" with a very low false positive rate, and items you have added will not be reported absent except in the unlikely event of a writer crash during an eviction. The structure is sized by a capacity you choose and is safe for concurrent use from forked processes or via a memfd or file-backed mapping, guarded by a futex-based rwlock with dead-process recovery. The API includes add, add_many for batching under one write lock, contains, remove, count_of which reports occurrences up to 8, and clear, plus introspection and lifecycle operations such as sync and unlink. A recent enhancement adds a freeze() operation to seal a file-backed filter and new_readonly() to open that sealed file read-only and query it lock-free, enabling you to build and ship a read-only artifact. Note the removal caveat that deletes rely only on fingerprints so you must only remove items you actually added, the file format is native to the host architecture, and this module requires Linux and 64-bit Perl.

Data::CountingBloomFilter::Shared implements a compact, shared-memory counting Bloom filter for Linux on 64-bit Perl, letting multiple processes record and query approximate set membership and lightweight occurrence counts without storing the items themselves. It replaces each Bloom bit with a 4-bit counter so you can increment, decrement, and ask "count_of" for an item, which makes deletes possible and yields an occurrence estimate, but the counters saturate at 15 so very frequent items may be capped and saturated items cannot be fully removed. The structure is fixed-size and tuned from an expected capacity and false-positive rate, supports batch adds, merging of filters with the same geometry, and safe concurrent use via a futex-based rwlock with dead-process recovery. Filters can be shared by a backing file, memfd, or inherited across fork, and the latest release adds a freeze/read-only mode that seals a file so other processes can open it read-only and query it lock-free for safe shipping to other machines of the same architecture. Be aware of the usual Bloom-filter tradeoffs: membership is one-sided and false positives remain possible, only remove items you actually added to avoid creating false negatives for others, and this module is Linux-only and requires 64-bit Perl.

Data::CountMinSketch::Shared provides a compact, fixed-size Count-Min sketch implemented in shared memory so several processes can record and query approximate frequencies from the same stream without storing the items themselves. You increment items with add or add_many and read estimates that never undercount and are, with configurable error parameters, bounded above by epsilon times the total with high probability, which makes the module well suited to finding heavy hitters and tracking large streams that are too big to count exactly. The sketch can be backed by an mmap file, an inherited anonymous mapping, or a memfd and identical sketches can be merged to combine streams, and the recent 0.04 release adds freeze plus new_readonly so you can seal a file-backed sketch and ship a lock-free read-only snapshot to other machines. Note that it is Linux-only and requires 64-bit Perl, items are treated as bytes so wide characters must be encoded first, and counters are 64-bit and will wrap only in extreme cases; the module also provides sane defaults, permissions, and crash-recovery behavior for practical multi-process use.

Data::Buffer::Shared provides compact, type-specific arrays backed by file-backed or anonymous shared memory so multiple processes on Linux can read and update values with very low overhead. It offers 11 variants including signed/unsigned integers, floats and a fixed-width string slot type, and supports fast lock-free single-element get/set and atomic integer operations like incr/add/cas, seqlock-guarded bulk reads and write-locked bulk writes, explicit futex-based read/write locking with dead-process recovery, optional eventfd notifications, zero-copy mmap access and memfd support. Buffers are presized and do not grow, the Str variant stores fixed byte slots and trims trailing NULs, and constructors let you create or reopen file-backed, anonymous or memfd-backed mappings. The module is Linux-only and needs 64-bit Perl, and users should be aware of filesystem semantics because sparse backing files can cause late failures or SIGBUS on out-of-space writes unless you size the filesystem appropriately and call sync to surface errors. Recent changes fixed a reader-lock leak and an unbalanced read-unlock that could block writers and otherwise improve robustness around initialization and file handling.

Data::BloomFilter::Shared is a Linux-only, 64-bit Perl module that implements a compact, shared-memory Bloom filter for fast, probabilistic "have I seen this before" checks across processes. You configure an expected capacity and a target false-positive rate and the module derives a fixed-size bit array and hash count; items are hashed to set or test a small number of bits so membership queries are either "definitely not" or "probably yes". The bit array can be shared by processes via a backing file, an anonymous mapping inherited across fork, or a transferable memfd, and concurrent adds, batch adds, and read queries are guarded by a futex-based rwlock that includes dead-process recovery. Filters of identical geometry can be merged by bitwise OR to form unions, and you can estimate distinct counts and other stats without storing the items themselves. New in the latest release is a freeze-and-ship workflow where a producer can seal a file-backed filter with freeze, then consumers open it with new_readonly and query lock-free on the same architecture, making it easy to build a read-only artifact for distribution. Note the module requires byte strings (wide characters must be encoded), frozen files are native-endian so not portable across architectures, backing files are created owner-only by default and sync should be used to detect disk write failures.

Net::CIDR::Set is a Perl module for representing and manipulating collections of IP addresses and ranges. It accepts CIDR blocks, explicit start-end ranges or single addresses and supports standard set operations such as union, intersection, complement, difference and exclusive-or, plus membership tests and subset/superset checks. The module works with both IPv4 and IPv6 but you cannot mix them in the same set and it will automatically coalesce overlapping ranges into the most compact representation. It provides iterators and convenience methods to enumerate addresses, CIDR blocks or ranges and to produce compact string output with several formatting options, though expanding a set into every individual address can use very large amounts of memory for big ranges or IPv6. You can create, copy, invert and merge sets programmatically, and the module requires Perl 5.14 or later with its source maintained on GitHub.

Device::Chip is a framework for building and using Perl drivers that talk to real hardware chips and modules, providing a consistent, high-level interface so drivers can focus on device behavior while delegating port access to an adapter. A driver instance is "mounted" to an adapter that implements the Device::Chip::Adapter interface, enabling communications over common protocols such as I2C, SPI, UART and GPIO, and the API supports both asynchronous operation via Future objects and simple synchronous use via Future->get. The module supplies conveniences for script-style option parsing with mount_from_paramstr, a base for registered I2C devices and a sensor abstraction used by many subclasses, and it includes test helpers to simplify unit testing of chip drivers. The distribution is actively developed and documented for driver users and authors, and the latest notable change merges sensor declarations from superclasses to make sensor definitions more composable.

ClickHouse::Encoder provides a fast XS-backed toolkit for producing and consuming ClickHouse Native and RowBinary payloads from Perl. It turns Perl rows or column arrays into ClickHouse-native columnar blocks that you can POST over HTTP, pipe into clickhouse-client, or send over the native protocol, and it can also decode query responses block by block or stream them with bounded memory. The module includes high-level features for schema discovery and diffs, create table rendering and parsing, bulk inserters with auto-flush and retries, streaming writers and compressors, helpers for decimals and WKT geometries, and good support for ClickHouse types including Arrays, Tuples, LowCardinality, Variant, JSON typed paths, DateTime variants, and high precision Decimals. It is optimized for throughput by doing type parsing up front and heavy work in XS so you can reuse one encoder per schema, and it fails loudly on malformed inputs to surface data issues early. Note the practical caveats that a 64 bit Perl is required and encode builds a whole Native block in memory, and that JSON array edge cases are an interoperability limitation.

DBIx::QuickDB is a developer-focused utility that makes it easy to spin up temporary database servers for testing and short-lived development tasks, supporting PostgreSQL, MySQL/MariaDB, SQLite and optional DuckDB drivers. You can declare reusable named databases at compile time or create instances on the fly, configure behavior like auto-start, auto-stop, bootstrap, cleanup and data directory location, and preload schema SQL so tests run against a ready database. The module exposes a simple build_db API and a driver-check helper that picks or validates a driver and returns why a driver might not be usable, and environment variables let you tune locations, verbosity and start/stop timeouts. Recent releases have focused on cross-platform robustness and cleaner teardown behavior so instances are less likely to leak files or processes, and test-time behavior and logging have been improved to make it reliable on CI and Windows. If you need a lightweight way to provision disposable or pooled databases for automated tests or local development, DBIx::QuickDB is a convenient option.

This module is only a tiny placeholder used to ensure the distribution is indexed by CPAN and carries no runtime functionality; it exists for package authors rather than for end users and is not normally installed on a user system, so ordinary users can safely ignore it while authors include it to satisfy CPAN indexing requirements.

JSON::YY is a high-performance Perl JSON module built on the yyjson C library that gives you three ways to work with JSON: a lightweight functional/keyword API for the fastest encode and decode calls, an object-oriented API compatible with JSON::XS for configurable encoding and decoding, and a Doc API that exposes yyjson's mutable document tree so you can read or surgically edit JSON using JSON Pointer paths without fully materializing the data as Perl structures. It supports a zero-copy read-only decode mode for large inputs, compiles common operations to custom ops for speed, and shines on large payloads and targeted modifications where the Doc API can be several times faster than decode-modify-encode. Be aware that canonical key ordering is not implemented, JSON booleans decode to Perl 1 and 0 rather than overloaded boolean objects, NaN and Infinity cannot be encoded, and nesting depth is bounded by max_depth to avoid stack exhaustion. The release series has continued stability and safety improvements with the recent 0.07 update addressing an encoder heap overflow, crash and double-free fixes, and various correctness fixes including Latin-1 handling and better scalar/Doc behavior.

StreamFinder is a Perl library that extracts actual raw streamable URLs and metadata from radio station, podcast and video pages so you can play them in your own media player instead of a browser. You give it a page URL and it selects a site-specific handler to return one or more playable stream URLs along with title, description, artist/channel, cover art or banner images, duration and other fields where available, and it can fetch image data for local use. It is designed to be embedded in other Perl programs rather than used as a standalone app and is already used by the Fauxdacious media player to avoid browser JavaScript, ads and trackers. Many video handlers use yt-dlp or similar tools and there are configuration files and options to control behavior such as forcing HTTPS-only streams, limiting HLS bandwidth, omitting handlers, and logging. Supported sites cover YouTube, Vimeo, Apple Podcasts, TuneIn, Rumble, Bitchute and many podcast and radio sources plus a generic Anystream fallback, with some modules marked deprecated or removed when sites became heavily JavaScripted or cookie-locked. A recent notable improvement adds DASH support in the YouTube handler so the module can return paired audio and video URLs for higher-quality playback by players that can consume both streams simultaneously.

Math::NLopt is a Perl binding to the NLopt nonlinear optimization library that lets Perl programs run a wide range of local and global optimizers for functions with or without gradient information. It provides a Perlish, object-oriented API using native Perl arrays and relies on Alien::NLopt to locate or install the underlying C library. You create an optimizer by choosing an NLopt algorithm and the number of parameters, supply objective functions and optional constraints or preconditioners, set bounds, tolerances and other options, and call optimize to obtain the best parameter vector and objective value. The module exposes the NLopt algorithms and result codes as importable constants, returns results directly from methods, and by default throws exceptions on errors while offering an option to disable exceptions for optimize so you can inspect the last recorded parameters. Use Math::NLopt when you need proven, flexible nonlinear optimization from Perl with support for constrained problems and both gradient and derivative-free methods.

Compression::Util is a function-based Perl library that collects a broad set of compression primitives and ready-made compressors so you can build, experiment with or use common formats entirely in Perl. It includes high-level compressors and decompressors for bzip2, gzip, zlib, LZ4, LZ77/LZSS and LZW and supplies the building blocks behind them such as Burrows-Wheeler, move-to-front, Huffman and arithmetic coding, run-length and Elias/Fibonacci coders, DEFLATE helpers, CRC/Adler checksums and bit and byte I O utilities. The API is modular and designed to be combined into pipelines or used piecewise, with tunable package variables for LZ parsing like LZ_MIN_LEN, LZ_MAX_LEN and LZ_MAX_CHAIN_LEN and optional exports so you only pull in what you need. Recent changes add a fast LZSS hash routine for LZ4-style parsing and a new LZ chain width parameter, improve match selection for some inputs and fix a hang in the symbolic BWT sorter, making the module faster and more robust. This module is a good fit for developers building custom compressors, researchers or students studying compression algorithms, and anyone who needs pure‑Perl implementations and flexible components without external dependencies.

Astro::SpaceTrack is a Perl module and command-line shell for retrieving satellite orbital elements and related catalogs from Space-Track.org and several public providers such as CelesTrak and selected third-party mirrors. It provides high-level methods to search by name, date, launch ID or NORAD catalog number, to retrieve batches of TLEs in multiple formats (including JSON), and to call CelesTrak supplemental catalogs, with most retrievals returning an HTTP::Response object annotated with pragmas that indicate data type and source. Some functions require a registered Space Track username and password and the module can optionally read credentials from a Config::Identity file for unattended use, while other sources (CelesTrak, some mccants endpoints) do not need an account. The distribution includes a SpaceTrack wrapper script and an interactive shell for ad hoc queries and file updates, plus an update() helper to refresh JSON TLE files locally. Be aware that parts of the code are a web-scraper and depend on the stability of upstream web pages, and several legacy features have been deprecated or removed over recent releases so some historical Iridium and favorites functionality is no longer available; recent updates also added the CelesTrak SAR catalog and now throw an exception if you attempt to fetch the removed “canned favorites.”

DB::Handy is a self-contained, pure-Perl relational database engine that stores tables as fixed-length binary files and gives you a familiar DBI-like API — connect, prepare, execute, fetchrow_hashref, selectall_arrayref and friends — without any external server or non-core modules. It implements a surprisingly large slice of SQL‑92, including SELECT with JOINs and subqueries, aggregates, set operations, ORDER BY, LIMIT/OFFSET and single-column indexes to speed equality and range lookups, and it also exposes a lower-level engine API for direct file and schema operations. It is designed for portability and simplicity rather than full RDBMS fidelity, so it is not a DBI driver, it always runs in AutoCommit mode with no transaction support, it has no BLOB/CLOB or multi-column indexes, VARCHAR fields always occupy 255 bytes on disk and FLOAT values in .dat files are machine-native and therefore not portable across different architectures. The 1.10 release adds an important portability and integrity fix on Windows by rejecting reserved device names like con, prn and nul so tables and indexes cannot be accidentally written to the bit bucket, along with a raft of hardening and test-suite fixes. Use DB::Handy when you want an easy, dependency-free embedded SQL engine for modest datasets and simple queries and you can live with the documented limitations.