CPANscan

Data::SortedSet::Shared provides a Redis-like sorted set for Perl that lives in shared memory so multiple processes can read and update the same ordered collection of 64-bit integer members with double scores. It supplies familiar operations such as add, increment, remove, rank, range queries, pop_min/pop_max and iteration, and it supports persistence via a backing file, anonymous mappings for forked children, or transferable memfd objects. The implementation uses an order-statistics B+tree plus a hash index to give constant-time score lookups and logarithmic-time rank, insert and pop operations, and range scans are efficient and sequential. Concurrency is handled by a futex-based read/write lock that recovers if a writer dies and there is an eventfd interface to wake readers after updates. Linux-only and 64-bit Perl are required and members must be integers, with a bundled string-keyed wrapper available for text keys. This module is a good fit when you need a fast, concurrent, shared ordered set across processes with low-latency queries and durable or fork-shared storage, but be aware the lock recovery does not detect PID reuse, which the author notes as a very unlikely limitation.

Data::HyperLogLog::Shared is a Linux-only Perl module that provides a compact, shared-memory HyperLogLog sketch for estimating the number of distinct items seen by one or more processes. Instead of storing items it maintains a fixed array of small registers (about 32 KB at the default precision) and uses a fast hash to update them, so it can count huge streams of values with very little memory and about 0.8% relative error at the default precision. Multiple processes can attach to the same backing file, inherit an anonymous mapping across fork, or share a memfd, and concurrent updates are protected by a futex-based lock that recovers from dead owners. The API supports adding items singly or in bulk, merging sketches of equal precision to get union counts, clearing, and basic introspection. It requires 64-bit Perl on Linux, backing files are created mode 0600 by default for better security but you can relax that when intentionally sharing across users, and the implementation notes that PID reuse is not detected though this is very unlikely to matter in practice.

Data::Histogram::Shared is a Linux-only, 64-bit-Perl implementation of an HdrHistogram that keeps a compact, fixed-size histogram in shared memory so multiple processes can efficiently record integer values and query percentiles, min, max, mean and counts with configurable significant-figure precision. You construct it by specifying the lowest and highest trackable values and the number of significant figures, then record individual values or batches, merge histograms with identical geometry, and share the same distribution across processes via a backing file, memfd, or forked mapping. Counts live in an mmap protected by a futex-based write-preferring rwlock with dead-process recovery, so updates are fast and crash-consistent to the last completed write and memory usage depends on the value range and precision rather than the number of samples. Keep in mind the module records integers only so you must scale floating values yourself, it requires Linux and 64-bit Perl, counts saturate at 64-bit limits, and PID reuse is not detected in the rare recovery path.

Data::DisjointSet::Shared provides a compact, shared-memory union-find (disjoint-set) implementation for Linux that lets multiple processes build and query a partition of a fixed universe of integer elements. It exposes the usual union, find and connected operations and uses path compression and union-by-size for near-constant amortized performance while storing about 8*N bytes of shared state plus a small cross-process table. The structure can be backed by a file, a memfd, or created anonymously and may be inherited across fork or reopened in other processes so everyone sees the same partition. All operations that compress paths or change sets acquire a write-preferring futex lock so concurrent updates serialize and dead-process holders are recovered, but be aware that find and connected are not read-only because they perform compression. The module is Linux-only and requires 64-bit Perl. The recent update hardens security by creating backing files with mode 0600 by default and lets you pass an explicit file mode when you need cross-user sharing. If you need a small, fast, cross-process data structure for grouping or connectivity tasks, this module is a practical and robust choice.

Data::CuckooFilter::Shared provides a compact, fixed-size cuckoo filter stored in shared memory for Linux and 64-bit Perl, letting multiple processes add, test, and remove items by their bytes while keeping memory proportional to capacity rather than item size. It answers membership queries as either definitely absent or probably present with no false negatives for stored items and a very low false positive rate using 16-bit fingerprints and four-slot buckets, and it supports counting duplicates up to a saturation of eight. The table is bounded by a capacity-derived geometry and can be shared via a backing file, an anonymous mapping inherited across fork, or a memfd, and mutations are protected by a futex write-preferring rwlock with dead-process recovery so operations remain crash-consistent. Be aware that removal operates on fingerprints only so deleting an item you never added can remove a colliding fingerprint and corrupt results, there is no merge operation, and wide-character strings must be encoded to bytes first. Use this module when you need fast, cross-process approximate set membership with deletions on Linux.

Data::CountMinSketch::Shared is a Linux-only, 64-bit Perl module that implements a shared-memory Count-Min sketch for fast, memory-efficient approximate frequency counting across processes. It stores a compact d-by-w matrix of 64-bit counters sized from your epsilon and delta parameters so estimates never undercount and overcounts are bounded by epsilon times the total with high probability. You can add single items or batches, read estimates, clear the sketch, merge two sketches of identical geometry to sum their streams exactly, and share the same sketch between processes via a backing file, memfd, or an anonymous mapping inherited across fork, with a futex-based rwlock that favors writers and recovers from dead owners. Items must be provided as byte strings so you need to encode wide characters first, and backing files default to owner-only permissions but can be created with broader modes for group sharing. This module is well suited for high-throughput stream processing and heavy-hitter detection when exact counting is too costly.

Data::BloomFilter::Shared provides a compact, shared-memory Bloom filter for Linux running 64-bit Perl, letting multiple processes efficiently share a probabilistic "seen before" set without storing the items themselves. You can add items, test membership, bulk-add or merge filters built with the same geometry, and tune the tradeoff between memory and false-positive rate so a negative test is exact while a positive test is "probably present". The bit array can be shared via a backing file, inherited across fork, or exported with a memfd descriptor, and concurrent mutation is protected by a futex rwlock with dead-process recovery so many processes can add and query safely. The module exposes convenience methods for construction, introspection, estimated cardinality, syncing and unlinking the backing file, and it enforces byte-oriented inputs so you should UTF-8 encode wide-character strings first. Note it is Linux-only, requires 64-bit Perl, and file-backed mappings default to owner-only permissions unless you override them.

Math::SigFigs is a Perl module that helps you count, format, and do basic arithmetic while respecting significant-figure rules used in scientific work. It provides routines to count significant figures in a given number and to format a number to a specified number of significant figures, and it offers add, subtract, multiply, and divide operations that attempt to preserve proper sig-fig rules in the results. The formatting functions return strings so you can preserve trailing zeros when needed and the arithmetic routines handle zero as a special case so values like 0.00 can be treated with their implied precision. Be aware of a few limitations: zeros are inherently ambiguous in how many significant figures they represent, perl numeric storage can lose trailing-significance so you should pass numbers as strings when precision of trailing zeros matters, and the module cannot unambiguously format some values when scientific notation is not used. Overall this is a practical tool if you need to present or compute numbers with correct significant-figure behavior in Perl.

Test::Inter is a Perl test framework designed for interactive debugging and for writing tests in a highly readable, data‑centric form. It provides Test::More style helpers such as ok, is and isnt and add-ons like use_ok and require_ok while also letting you run a single test or a range of tests by setting TI_START, TI_END or TI_TESTNUM and by exposing the current test number as $::TI_NUM so you can easily set debugger breakpoints. Tests can be declared as simple multi line strings or as data structures which keeps the test data separate from the surrounding script and makes large suites easy to scan and edit. You can mark tests todo, skip sets of tests, set features, run file based comparisons, and choose interactive human readable output or TAP compatible output for automated runs. Configuration options can be passed to new, set with environment variables, or as globals so you can tailor behavior without changing the test code. It is not a drop in replacement for Test::More but it aims to be familiar while adding more flexible test specification and interactive control and the author reports no known bugs.

Shell::Cmd is a Perl helper for building and running sequences of shell commands with robust, high-level features so you do not have to hand-craft wrapper scripts. You add commands with cmd then run them locally or on remote hosts with run or ssh, and the module automatically handles stdout/stderr capture and merging, command echoing and dry-runs, per-command retries and alternate fallbacks, simple working-directory and environment setup, basic flow constructs, and collection of output for post‑processing. It also supports copying and running generated scripts over SSH on many hosts with optional parallelism and staggered starts. The module is aimed at straightforward command workflows rather than arbitrarily complex shell functions and it documents limits such as only modest flow support and a 200-command error-mapping ceiling. Recent updates include safer handling of environment quoting and a change to flush stored output when options are changed.

Config::Model::Systemd supplies Config::Model and the cme tool with ready-made models to view, check and edit systemd unit files, letting you inspect or sanity‑check services, sockets and timers and create or update override drop‑in files in user and system locations. You can run a graphical editor, a shell UI or one-off checks from the command line, and there is an experimental cme() API for driving edits from Perl code. The module reads units from your user config directory or /etc/systemd/system, flags unknown or duplicate parameters and preserves layering and comments so it works well for both administrators and service developers. If you need support for other unit types you can file a wishlist, and the current release updates the model to match systemd 261 while shrinking the model size and requiring Config::Model 2.163 or later.

Net::Blossom::Server is the framework-neutral server core for the Blossom content protocol, providing the routing and logic for uploads, media uploads, mirrored downloads, blob retrieval, deletion and listing while leaving HTTP or telephony gateways to adapt requests and responses. It expects a pluggable storage backend that implements the Net::Blossom::Server::Storage interface and exposes high-level operations such as receive_blob which streams data into storage while computing and validating SHA-256, handles content-length checks and optional upload size limits, and returns structured upload results; there are also HEAD preflight handlers, GET/HEAD for serving blobs, DELETE for owner-based removal, GET /list for paged listings, and PUT /mirror which coordinates with a caller-supplied mirror_fetcher to stream origin data into the server. The core is intentionally agnostic about authorization and web frameworks so gateway adapters perform signature checks and convert between native requests and Net::Blossom::Server::Request/Response objects, and configurable options include chunk size, clock, maximum upload bytes and list page size. The distribution is a new CPAN release providing this reusable server core for building Blossom-compatible services.

Net::Blossom is a lightweight Perl implementation of the Blossom protocol that provides a client and supporting utilities for working with blob storage and CDN-style servers. It includes value objects for protocol data, helpers for Blossom URIs and server lists, a BUD-11 authorization token generator, and a simple HTTP client for retrieving blobs by SHA256 or other identifiers. The module intentionally exposes a small surface and the usual entry point is Net::Blossom->client which constructs a Net::Blossom::Client for interacting with servers. Use this when you want to integrate Blossom-based storage or CDNs into Perl applications without implementing the protocol yourself. This package is the initial CPAN release.

Algorithm::Classifier::IsolationForest is a Perl implementation of Isolation Forest and Extended Isolation Forest for unsupervised anomaly detection that builds an ensemble of random trees to score and flag outliers, returning per-sample anomaly scores in (0,1] and optional binary labels. It supports classic axis-aligned splits or oblique hyperplane splits for the extended variant, a majority-voting aggregation mode, learned thresholds from a contamination parameter, several strategies for handling missing values, and named-feature support for single-row scoring. The module offers persistence to JSON, a packed-data wrapper to speed repeated scoring in interactive workflows, reproducible fits via seeding, and multiple ways to speed up training and scoring with an optional Inline::C and OpenMP backend or by forking worker processes while keeping a pure-Perl fallback that produces identical results. Overall it is a practical, feature-rich choice for detecting anomalies in numeric datasets, especially when you want flexibility over aggregation, missing-data treatment, performance tuning, and easy model saving and reloading.

CLI::Simple is a minimalist object-oriented Perl base class for building modulino-style command line tools that need options, subcommands and positional arguments. It layers Getopt::Long parsing with automatic getter/setter creation, integrates with Log::Log4perl for logging, and provides handy features like built-in help and pager support, bash completion generation, and low-dependency scaffolding tools to migrate a single-module script into a role-based project driven by a YAML manifest. In role mode it composes Role::Tiny roles declared in the manifest so you can split commands into focused modules, and it includes commands such as -dump-spec, -scaffold and -migrate to bootstrap that workflow. The module deliberately keeps the surface small and non-prescriptive so you get a simple init/run lifecycle without a heavy framework, which makes it a good fit for internal utilities and straightforward CLIs while teams needing complex interactive command trees may prefer a fuller framework like App::Cmd.

Algorithm::EventsPerSecond is a compact sliding-window meter that tracks average events per second over the last N seconds by keeping per-second counts in a fixed-size ring buffer, so memory use stays constant and updating or reading the rate is effectively constant time. You create a meter with a window size, call mark() to record events, and read rate(), count(), or total() to get the current per-second rate, the number of events in the window, or the lifetime total. An optional XS C backend with SIMD optimizations (AVX2 or SSE4.2) is built automatically when a compiler is available for higher throughput and the module falls back to a pure-Perl implementation otherwise; you can query which backend and SIMD flavor are in use via backend() and simd(). The 0.1.0 release adds a unix-socket vizier daemon, iqbi-damiq, plus example FreeBSD and systemd startup scripts to simplify centralized tracking of many meters.

Algorithm::ToNumberMunger turns simple, declarative specs into fast reusable coderefs that convert raw values into single numeric features for machine learning and analytic pipelines. You describe each field in a JSON-like spec and the module builds validated closures so you can compile your munging logic once and apply it per row with no re-parsing. It provides a large set of built-in transforms for common needs: categorical enums and protocol-aware enums, frozen frequency and n-gram tables for rarity and gibberish detection, hashing for high-cardinality labels, datetime parsing with sin/cos cyclic outputs, string-shape features like entropy and character or run counts, numeric normalisers such as log, z-score, quantile and min-max scaling, bit and IP/CIDR classification, multi-input combiners and ratios, regex matching and counting, chains of string prefilters, and even an events-per-second client that consults an external daemon. The class validates specs at build time so configuration errors are caught early and the returned closures only fail on truly un-mungeable input. It is aimed at people building feature stores, anomaly detectors or CSV writers who want a stateless, auditable, and portable way to map raw log fields into numeric features, with practical notes such as frozen frequency tables bloating shipped JSON if they get very large and the EPS munger depending on an external daemon.

WWW::Session::Storage::Redis is a lightweight Redis backend for WWW::Session that stores serialized session objects in Redis via Cache::Redis. You create it with a hashref of Cache::Redis options and a required server address, then use simple methods to save session data with a TTL, retrieve the serialized string or undef if missing, and delete sessions. A save expiration of -1 is treated as never expiring and is implemented as a ten year TTL because Redis always uses a TTL. The module requires Cache::Redis to be installed and will croak if that dependency or the server option is missing, making it a straightforward choice when you need fast, centralized session persistence backed by Redis.

DBIx::QuickDB is a small Perl helper that makes it trivial to spin up throwaway database servers for testing and development, letting you create named or ad-hoc databases for drivers like PostgreSQL, MySQL/MariaDB and SQLite and optionally DuckDB, then connect to them with DBI as if they were normal servers. You can declare databases at compile time as constants or build them at run time, control automatic start/stop and cleanup, load schema SQL on creation, clone instances and use pools for faster reuse, and point it at an existing data directory when you need to. The module exposes a flexible spec hash for options such as autostart, autostop, bootstrap, cleanup and load_sql, and it will remove temporary data dirs by default so you should never enable cleanup on any important database. Recent work has focused on making teardown reliable and safe on slow or constrained hosts and on better driver detection; notably the MariaDB driver now refuses to use several known-broken server releases that can hang under --skip-grant-tables and offers an escape hatch via QDB_MARIADB_IGNORE_BROKEN if you need to override that check.

DateTime::Lite is a lightweight, low-dependency, drop-in replacement for DateTime that preserves the familiar API while trimming startup cost and installed footprint. It provides full calendar and clock arithmetic, nanosecond-aware timestamps, leap second handling, CLDR and BCP47 locale support including automatic timezone inference from locale tags, and accurate IANA timezone handling by reading TZif binaries and evaluating POSIX footer rules. Performance-critical paths are implemented in XS and the bundled DateTime::Lite::TimeZone uses a compact SQLite store with an optional process-level memory cache so you can get both small initial overhead for short-lived scripts and high throughput for long-running services when needed. Error handling follows a non-fatal, exception-object model by default and serialization, formatting, and duration semantics mirror DateTime closely so most existing DateTime code should work with minimal changes.

HTTP::Date is a small, reliable Perl utility for converting between epoch seconds and the many date string formats you encounter in HTTP headers, log files and system tools. Its commonly used functions are time2str to produce the RFC‑1123/GMT timestamp expected by HTTP and str2time to turn a wide range of human and machine date strings back into epoch seconds, with an optional default time zone and support for named zones when Time::Zone is installed. The module also exposes parse_date which returns numeric date components or an ISO‑like string and understands formats such as RFC1123/RFC850, ISO 8601, common logfile timestamps, ctime/asctime, Unix ls and Windows dir output, while treating numeric-only dates as day/month/year rather than US month/day/year. Helper routines time2iso and time2isoz format times in local or UTC ISO style. Note that parsing dates before your system epoch may not work on all platforms and that parse_date now rejects input longer than 64 characters to avoid pathological regex backtracking attacks, a security fix addressing CVE-2026-14741.

Backblaze::B2V4 is a Perl client for Backblaze B2 Cloud Storage that wraps the service's V4 API and makes it easy to authenticate, upload and download files, manage buckets, and query file metadata from Perl scripts. You create a client with your application key and key id and then call simple methods to upload single files or large files, download by file name or by Backblaze file id, list files in a bucket, create or delete buckets, and remove file versions. The module also exposes a generic send_request method for calls not covered by the helper methods and includes a b2_client command line utility for quick get and put operations. It defaults new buckets to server side encryption and notes that bucket names must be globally unique, and the installer can test your credentials by downloading a small file if you provide test environment variables. If you already use an S3 integration you might prefer Backblaze's S3-compatible API and S3 modules, but this package is a straightforward choice for Perl projects that want native B2 V4 support.

Dist::Zilla::PluginBundle::GEEKRUTH is an opinionated, ready-made Dist::Zilla configuration that bundles and preconfigures the collection of plugins D. Ruth Holloway uses to build, test, version and release Perl distributions. It automates common release work such as contributor tracking, metadata (MetaYAML/MetaJSON), POD weaving and README generation, compile and release tests, automatic prerequisite detection, changelog and semantic versioning, and the git commit/tag/push steps so you do not have to assemble all those pieces yourself. You can tweak a few arguments like authority (default cpan:GEEKRUTH), builder (default MakeMaker), development and release branch names, upstream remote, autoprereqs_skip and a remove_plugin option to drop parts you do not want. This bundle is most useful if you want a proven, full-featured release pipeline modeled on Ruthie’s workflow rather than a minimal or highly bespoke setup. Recent notable changes moved the workflow to Codeberg and added a SecurityPolicy plugin.

Data::PubSub::Shared provides a lightweight, high-performance publish/subscribe system built on Linux shared memory that lets multiple processes broadcast messages into a ring buffer while each subscriber reads independently from its own cursor. Publishers never remove messages and the ring overwrites old data when full, with automatic recovery for slow subscribers and per-subscriber overflow counters to track lost messages. The module offers several types: Int, Int32, and Int16 deliver lock-free multi-producer multi-consumer publishing for compact numeric payloads and are ideal for counters, timestamps, or small events, while Str handles variable-length byte or UTF-8 strings and is better for log lines, JSON, or serialized payloads at the cost of a mutex that serializes publishers. It supports file-backed or anonymous mappings, memfd-backed sharing, futex-based blocking polls with timeouts, eventfd integration for event loops, batch operations for very high throughput, and tools for cursor management and diagnostic status. Note that it is Linux-only and requires 64-bit Perl, Str-mode publishers are serialized and recover from a dead publisher within a short timeout, and certain operations such as clearing the ring must be used carefully when publishers are active. Overall it is a practical choice when you need very fast interprocess fan-out with low overhead and simple APIs for both numeric and string messages.

DateTime::TimeZone is the core Perl module that represents time zones for the DateTime ecosystem and provides a factory for creating zone objects by name, offset, or special types like UTC or a floating zone for calendar-local times. It gives you the current offset and DST status for a DateTime object, converts human-friendly offset strings to seconds and back, and exposes catalogs of valid zone names, categories, country mappings, and links so you can present or validate time zone choices. The module hides the complex historical and DST rules by using generated Olson/IANA data and includes platform-specific helpers for discovering the system "local" zone on Windows, HPUX, Android, and others. It also provides Storable hooks to avoid bloating serialized data and advises loading needed zones in a parent process for preforked servers to save memory. This release tracks the 2026c Olson updates and includes contemporary changes affecting Alberta, Canada and Morocco.

Data::NDArray::Shared provides a compact, typed N‑dimensional numeric array that lives in a Linux shared memory mapping so multiple processes can view and mutate the same dense tensor concurrently. You can create file-backed arrays, anonymous mappings inherited across fork, or transferable memfd-backed mappings and reopen them from a file descriptor; supported element types include double and float and a range of signed and unsigned integer widths and shapes of one to eight dimensions with row‑major layout. The module gives simple indexed and flat access, bulk fills and zeroing, reshape without copying, reductions like sum/mean/min/max, in-place scalar and elementwise arithmetic, and convenient conversion to and from PDL when available, including an optional zero-copy PDL alias that bypasses the module lock and therefore requires external synchronization. Concurrent mutation is serialized with a futex write‑preferring read/write lock that recovers from dead processes so readers see consistent headers and writers do not corrupt the buffer. Limitations worth noting are Linux-only operation, 64‑bit Perl required, a 1 TiB mapping cap and integer dtypes that wrap per C casting rules and float dtypes that lose precision relative to Perl NVs. Recent 0.02 hardens security and robustness by creating backing files with mode 0600 by default and adding an option to supply an explicit file mode for intentional cross-user sharing.

Data::HashMap::Shared is a high-performance, file-backed shared-memory hash map for 64-bit Linux Perl that makes it simple to share keyed data and counters between processes without a database. It offers type-specialized variants for integer and string keys and values, a lock-free fast read path with futex-backed write locking, atomic increment/decrement and compare-and-swap operations, optional LRU eviction and per-key TTLs for use as a cross-process cache, and an arena allocator for storing larger strings in shared mmap space. You can create anonymous or memfd-backed maps, shard a workload across multiple files for parallel writers, and use either a method API or very fast XS keyword calls. The module exposes batch ops, cursors, diagnostics and explicit sync/unlink controls and is tuned for low-latency lookups and very high throughput versus LMDB and BerkeleyDB in the author’s benchmarks. Important caveats are that it is Linux-only and requires 64-bit Perl, integer variants use fixed-width two’s-complement storage so keys and values can wrap or be truncated, string keys compare by raw bytes with UTF-8 flags preserved but not part of identity, and stale-lock recovery assumes a shared PID namespace so cross-container use is unsupported; after a writer crash a map may contain a partially-updated entry so critical systems should clear after recovery. Overall it is a practical choice when you need very fast, concurrent cross-process caches, counters, queues or other shared data structures without running a separate server.

Data::Graph::Shared provides a compact, high-performance directed weighted graph that multiple Linux processes can attach to via shared memory, letting you allocate a fixed pool of nodes and edges and mutate the structure safely from different processes. It supports fast node and edge insertion, neighbor iteration, node data storage, and counters for nodes and edges, with mutex-protected updates and PID-based recovery for stale locks so concurrent programs stay robust. The graph can be file-backed or use memfd, exposes an eventfd for integration with event loops, and includes diagnostic stats and sync/unlink lifecycle controls; backing files are created with restrictive permissions by default. One design tradeoff to note is that remove_node only clears outgoing edges in O(1) and leaves incoming destinations dangling unless you use remove_node_full, which does an O(N+E) cleanup. This module is Linux-only and requires 64-bit Perl, and bench tests in its documentation show very high operation throughput for single-process workloads.

Data::Deque::Shared provides a high-performance double-ended queue that multiple Linux processes can share via anonymous mappings, memfd or file-backed shared memory, offering lock-free push and pop operations at both ends with futex-based blocking when empty or full. It comes in integer and fixed-length string variants, is designed for 64-bit Perl and capacities up to 2^31, and is targeted at multi-producer multi-consumer workloads where it outperforms older shared-string queues under contention. The API is simple: push/pop (with optional timed waits), size and capacity queries, a concurrency-safe drain operation, eventfd integration and stats that include recoveries for crashed or stalled pushers. Backing files are created with secure owner-only permissions by default and the module validates on-attach headers so attachments are safer, but if you grant write access to other users you must trust those processes not to corrupt the mapping. Recent releases hardened security and robustness, moved to a file format v2 with per-slot control data for true MPMC safety, added bounded recovery of stuck slots, and preserved UTF-8 for the string variant.

Data::Buffer::Shared provides typed, fixed-capacity buffers that live in file-backed or anonymous mmap'd shared memory so multiple processes can read and update the same data directly on Linux using 64-bit Perl. Each type variant (integers, floats, fixed-length strings) exposes atomic, lock-free single-element get/set and rich integer atomics like incr/add/CAS plus seqlock-guarded bulk reads and writes, a futex-based read/write lock with stale-lock recovery, zero-copy mmap views and raw pointers for FFI, and both keyword and method APIs for convenience. Buffers are presized and available via on-disk files, memfd objects, or anonymous mappings, making this module a good fit for high-performance IPC tasks such as counters, shared arrays, and low-latency state sharing. Backing files are created with owner-only permissions (0600) by default for improved security and you can supply an explicit file mode to share across users. Recent releases focus on security and robustness, notably the 0600 default file mode and improved dead-reader recovery, and a header version bump in 0.04 means older maps from 0.03 must be recreated.