CPANscan

Markdown::Simple is a compact, high-performance XS module that converts Markdown to HTML with GitHub Flavored Markdown as the default but with options to select strict CommonMark or toggle individual features. You can use the simple functional API for one-offs or create a persistent renderer object to reuse the parser arena when converting many documents in a loop, which reduces allocation overhead and improves throughput. It supports GFM extras like tables, strikethrough, task lists and autolinks, offers a strip_markdown helper to produce plain text, and can optionally syntax-highlight fenced code blocks when Eshu is present. Recent releases added GitHub-style heading ids and a render_with_toc method that returns the document headings for building a table of contents, fixed several memory leaks and platform load issues, and include SIMD acceleration and a small C ABI for embedding in other code. Keep in mind the renderer is not safe to run concurrently in the same interpreter so use one session per thread or worker.

DBIx::Loop lets you run DBI database work without stalling an event loop by presenting a single future-based API that offloads blocking drivers to a worker pool or uses a native non-blocking path when available (DBD::Pg). You always provide the event loop adapter (IO::Async, Mojo::IOLoop, AnyEvent, Hyperman, etc.) and then use query and do to get immediate futures, use txn to run a block pinned to one connection, and call the async variants of DBI's select* helpers; results come back as simple data structures so you can compose continuations or bridge into your loop's await mechanism. This module is designed for concurrency and latency isolation in event-driven servers rather than micro-optimizing a single query, and it supports common needs like cached prepares, max-queue backpressure, and safe pool behavior across forks. Noteworthy in the recent 0.02 release are robustness and integration improvements: pool-worker death and fork-safety bugs were fixed, selectall_rowhash was added to preserve row ordering as hashrefs, and a public C ABI was introduced so XS code can efficiently drive DBIx::Loop futures. If you need non-blocking DBI behavior inside your evented application and are prepared to supply or adapt a loop, DBIx::Loop is a practical, production-minded choice.

Search::Trigram provides a compact, in-memory trigram inverted index that makes fuzzy text lookup fast and simple. You add UTF-8 documents and the module indexes overlapping three-character slices so queries are scored by the Dice coefficient over shared trigrams, with case-insensitive, byte-level UTF-8 matching. The search method returns a list of hits as {doc_id, score, text} sorted by score and accepts an optional result limit, and you can remove documents, run optimize to purge deletions and compact postings, and query document and trigram counts. The distribution also exposes a stable C ABI so XS modules or C code can drive the same index without a Perl frame. This module is a good fit when you need a lightweight, in-process fuzzy search layer for Perl applications or extensions.

EV::Redis is an asynchronous Redis client for Perl that plugs into the high-performance EV event loop and uses the native hiredis library for fast, nonblocking I/O. It is a drop-in successor to EV::Hiredis and adds practical features you will care about in real services such as automatic reconnection, command and connect timeouts, flow control for high-throughput workloads, TLS support, RESP3 push handling for server-initiated messages, and a fire-and-forget mode for very fast writes. The API is simple and callback-driven so you connect, send commands and receive replies without blocking your event loop, and it also works under AnyEvent when EV is used as the backend. Be aware that EV::Redis treats all strings as raw bytes and does not perform UTF-8 encoding or decoding for you, so encode and decode your text explicitly, and note a few protocol caveats such as monitor mode needing a dedicated connection and sharded pub/sub not being supported. This release updates the bundled hiredis to v1.4.1 to address security issues in deeply nested replies and related parsing limits, while preserving the module's focus on low-latency, evented Redis access.

Fetch is a modern, high-performance Perl HTTP client that makes both simple synchronous calls and large-scale concurrent requests easy. Its performance-critical networking, TLS and HTTP/2 framing are implemented in bundled C while the Perl API returns Fetch::Future objects so you can either await results with ->get or drive many requests concurrently on an event loop; a built-in standalone loop is used automatically if you do not supply one. It supports HTTP/1.1 and HTTP/2 with ALPN, keep-alive connection pooling, redirect following, per-request timeouts, cookie jars, JSON helpers and native WebSockets, and it provides streaming callbacks for headers and body chunks to handle large downloads or server-sent events without buffering everything. You can set default headers and per-request overrides, clone agents to share pools while isolating cookies, opt into a lean simple_response mode for extreme throughput, and even use a small C ABI so XS modules can issue requests with minimal Perl overhead. If you want a capable, efficient HTTP/2-ready client for both ad-hoc scripting and high-concurrency applications, Fetch is a strong choice.

Schedule::Activity generates randomized, time-based activity schedules by assembling activities from sequences of actions defined in a configuration graph. You declare named nodes with time specs (tmmin, tmavg, tmmax), messages, attributes and next-node links which may include cycles and weighted choices, and the scheduler grows each activity stepwise while using configurable slack and buffer tensions to bias how closely the result meets a target time. The module records per-event messages and a detailed attribute history, supports annotations that attach secondary messages or attributes around events, and can perform goal-oriented retries that score multiple candidate schedules by attribute averages. It also supports incremental construction so you can extend an earlier schedule, offers a simple markdown importer for quick configuration, and returns validation errors when configuration checks fail. This is a good fit when you need realistic, variable-duration schedules for simulation, testing, scenario generation or any situation where controlled randomness and attribute tracking matter rather than exact optimization. Note that it is a randomized opportunistic generator and not a path optimizer, schedules may fail if actions lack slack or buffer, and setting tmavg to zero can lead to infinite loops.

Net::MQTT::Simple is a tiny, dependency free Perl MQTT v3 client aimed at simple sensor scripts and embedded installs where you cannot pull in CPAN modules. It offers both a lightweight functional API for one off publishes and gets and a small object API that supports subscribing and an event loop, plus convenience features like last will and optional login. Connections are opened on demand and automatically reconnect with failures reported as warnings rather than exceptions so unattended scripts keep running. It intentionally implements only the basics so every message is fire and forget at QoS 0, large messages are rejected, and incoming packets are not exhaustively validated, so it is not suitable for heavy production brokers or advanced MQTT features. There are a few practical caveats such as a single reconnection attempt cadence, a requirement to handle message encoding yourself since messages are treated as binary, and optional IPv6 support if IO::Socket::IP is installed. If you need a minimal, easy to install MQTT client for simple telemetry or automation this module fits well and you can move to Net::MQTT or Net::MQTT::Simple::SSL when you need more features or encryption.

Data::TopK::Shared provides a compact, shared-memory implementation of the Space-Saving top-k heavy-hitters sketch for Perl, letting multiple processes track the most frequent keys in a stream without storing a counter per distinct key. You give it a fixed capacity of counters and call add to feed keys, and it returns estimated counts with a guaranteed error bound so the true frequency lies between count minus error and count; genuine heavy hitters above seen/capacity are guaranteed to be retained. The summary can be shared across processes via a backing file, memfd, or forked anonymous mapping and uses a futex-based rwlock with dead-owner recovery to make concurrent updates safe. There is also an optional time-decayed mode that weights recent observations more heavily via a configurable half-life and reports decayed floating-point counts, a feature introduced in a recent release, and the latest update improves recovery of files left by interrupted creation. Note that this module is Linux-only, requires 64-bit Perl, truncates keys to a configurable byte length and will croak on wide-character strings unless you supply bytes, and it documents a few practical caveats such as very unlikely PID-reuse issues and an extreme reader-slot exhaustion edge case.

Data::TimingWheel::Shared provides a compact, shared-memory timing wheel for O(1) scheduling and cancellation of large numbers of discrete-tick timers, making it useful for event loops, job schedulers, and network stacks where many timers must be managed efficiently. Timers are scheduled in integer ticks, carry an arbitrary 64-bit payload, and fire when the wheel advances; any process that opens the same backing file, inherits an anonymous mapping across fork, or reopens a memfd can schedule or cancel timers while typically a single process advances the clock and dispatches fired payloads. The module exposes simple operations to add, cancel, advance, inspect, clear, and persist the wheel, enforces fixed geometry for capacity and slot count for predictable memory usage, and uses a futex-based rwlock with dead-process recovery to keep the shared state consistent across crashes. It is Linux-only and requires 64-bit Perl, and the author documents a couple of rare caveats such as undetected PID reuse and the theoretical limit on concurrent reader slots that can make writer recovery difficult only in extreme cases. The recent 0.02 release improves robustness by recovering files left behind by interrupted creates and refines unlink behavior and documentation.

Data::Sync::Shared is a Linux-only Perl module that exposes five cross-process synchronization primitives stored in mmap'd shared memory and implemented with Linux futexes for efficient blocking. It gives you a counting Semaphore for resource limits, a Barrier for N-way rendezvous, a reader-writer RWLock that supports many readers or one writer, a Condvar with a built-in mutex for predicate waiting, and a Once gate for one-time initialization. Primitives can be file-backed, anonymous for fork inheritance, or created with memfd for passing file descriptors to peers, and most blocking operations accept timeouts and offer scope-based guard objects that auto-release on scope exit. The implementation focuses on crash safety by encoding holder PIDs so other processes can detect and recover stale locks and it secures backing files by default to owner-only permissions while allowing explicit modes for shared use. There is eventfd integration for hooking into event loops and utility methods for syncing, unlinking, and diagnostics. Recent updates improve robustness by recovering files left behind by interrupted creates and hardening guard behavior across forks. Be aware of an edge case described in the docs where if more than 1024 concurrent reader processes share one mapping and a reader crashes during its tiny lock window, writers may be unable to reclaim that contribution until the mapping is recreated.

Data::Stack::Shared implements a fast, lock-free LIFO stack that multiple processes can share via anonymous mappings, memfd or a file on Linux. It comes in two typed flavors for 64-bit Perl programs: a 64-bit integer variant and a fixed-length string variant. Push and pop operations are safe for multiple producers and consumers and support blocking waits with timeouts plus a non-destructive peek. The module exposes capacity and size queries, a drain operation that is concurrency-safe, eventfd notification hooks, memfd/file management and basic statistics, and it aims for high throughput in both single- and multi-process workloads. It is Linux-only and requires 64-bit Perl, the on-disk format was bumped to v2 so very old v1 files are not compatible, and drain includes a recovery path that can reclaim a stalled writer at the cost of silently dropping a late publish. File-backed stacks default to owner-only permissions and any process granted write access to a shared mapping must be trusted not to corrupt it.

Data::SpatialHash::Shared is a Linux-only, 64-bit Perl module that implements a fast, shared-memory spatial hash for concurrent processes to store and query 2D or 3D points and small values. It divides space into configurable grid cells so you can do radius, k-nearest, box, cell, and collision-broad-phase queries efficiently, and it supports bulk inserts/moves to amortize locking for high-throughput use such as game ticks or simulation steps. You can create a seamless toroidal world for wraparound metrics or enable a spherical mode that accepts lat/lon/alt and offers true 3D distance queries plus cube-sphere cell ids for chunking and LOD. The API returns opaque handles for mutating entries, offers read- and write-locking across processes with futex-based crash recovery, and provides an option to freeze a file-backed map for lock-free read-only distribution across machines of the same architecture. It also supports memfd-based anonymous mappings, eventfd notifications, and various introspection and tuning knobs like cell size and bucket count. The implementation is robust in practice but notes two edge cases to consider during extreme failure scenarios, namely possible PID-reuse interference with lock recovery and limits around 1024 reader slots that could complicate recovery if many readers crash while holding locks.

Data::SortedSet::Shared provides a Redis-style sorted set that lives in shared memory so multiple processes can read and write the same ordered collection of 64-bit integer members with double scores on Linux under 64-bit Perl. It stores members in a B+tree with a fast member-to-score index so lookups like score and exists are constant time while rank, insert, delete and popping extremes are logarithmic, and range scans walk linked leaves efficiently. You can back the set with a file, an anonymous mapping inherited across fork, or a transferable memfd, and there is a string-keyed variant that interns keys if you need text members. The module supports bulk inserts, incremental score updates, iteration, an eventfd-based notify mechanism for waking other processes, and a freeze mode that seals a file for lock-free, read-only distribution to other machines of the same architecture. It is Linux-only and requires 64-bit Perl. Note the documented crash-safety caveats: a writer killed mid-mutation can leave the tree structurally corrupt, PID reuse is not detected, and extremely large numbers of concurrent readers can exhaust a limited reader-slot table, so plan deployment and backups accordingly.

Data::SegmentTree::Shared provides a fast, shared-memory segment tree for a fixed array of signed 64-bit integers so multiple processes can efficiently perform range updates and queries on the same data. You can set or add to single positions, add to or assign an entire inclusive range in O(log n), and query range sums, minima, and maxima in O(log n); it also optionally maintains gcd and product aggregates but those are only valid while you use assign/set updates and are permanently disabled once any range_add or add runs. The structure lives in a memory mapping backed by a file, an inherited anonymous mapping, or a memfd and uses a futex-based read/write lock that lets many readers run concurrently while guarding writers and recovering dead owners; it is Linux-only and requires 64-bit Perl. Be aware that arithmetic is native 64-bit so sums wrap on overflow, a mid-update crash can leave the tree in an inconsistent state and require rebuilding for full crash safety, and on-disk layouts have changed between releases so older files may be rejected. Recent releases improved robustness by recovering files left by interrupted creates and tightened reader-slot locking and security around attachment and locking.

Data::RoaringBitmap::Shared provides a Linux-only, 64-bit-Perl shared-memory Roaring bitmap for storing large sets of 32-bit unsigned integers that multiple processes can read and mutate concurrently via a backing file, a transferable memfd, or an anonymous mapping inherited across fork. It keeps values grouped by their high 16 bits and stores the low 16 bits in either compact uint16 arrays for sparse buckets or full 65k-bit bitmaps for dense buckets so the structure stays memory-efficient across sparse, clustered, and dense data. The module exposes simple set operations and queries including add, bulk add, remove, membership tests, cardinality, min/max, to_array, and in-place union and intersection with another shared bitmap. Mutations are serialized with a write-preferring futex-based rwlock that includes dead-process recovery, so concurrent access is safe, and you can freeze a file-backed bitmap to create an immutable, lock-free read-only view that can be shipped to other machines of the same architecture. Note the v1 limitations: no run containers, no xor/andnot operations, no automatic down-conversion of bitmap containers back to arrays, and a fixed container-pool capacity chosen at creation; frozen files use native-endian binary format so they are portable only between identical architectures.

JSON::Schema::Fast compiles JSON Schema draft 2020-12 into a compact in-memory validator so you can validate Perl data extremely quickly. You compile a schema once and then call is_valid for a cheap boolean check or validate to collect detailed error hashes with instanceLocation, schemaLocation, keyword and message. The module implements the full 2020-12 feature set including $ref, dynamic and remote references (with a pluggable resolver), applicators, vocabularies and all the usual type, number, string, array and object keywords. Options let you coerce numeric and boolean strings and inject defaults into caller data when desired. It exposes a small C ABI so other XS modules can compile once and validate entirely in C for maximum throughput. The distribution runs the official conformance suite and reports 100 percent coverage. The recent 0.07 release fixes a build issue with certain LTO toolchains and corrects a bug that could mutate numeric flags on Perl scalars during validation so validating no longer alters the caller's data.

Data::RingBuffer::Shared provides a compact, high-performance fixed-size circular buffer mapped into shared memory for 64-bit Perl on Linux, letting multiple processes read and write a rolling window of values without locks. Writes always succeed and overwrite the oldest entries when full, readers can fetch the latest values by relative index or by absolute sequence number, and typed variants exist for 64-bit integers and doubles. The implementation is lock-free and designed to avoid torn or half-written reads, to survive crashed writers without stalling other users, and to support efficient waiting/notification via futexes and eventfds, so it is well suited for metrics, sensor streams, debug traces, and other rolling-window use cases. Backing storage may be a regular file or memfd, files are created with restrictive permissions by default, and the module exposes lifecycle and diagnostic helpers such as clear, sync, unlink, and stats. Recent updates improved robustness around interrupted creates so abandoned zeroed files are now safely recovered and hardened file-creation behavior and argument handling for safer multi-process use.

Data::Reservoir::Shared provides a compact, shared-memory reservoir sampler for Perl that keeps a uniform random sample of k items from an unbounded stream using fixed memory. You feed items with add or add_many and read the current sample with sample or get while count and seen report how many items are retained and observed. The reservoir can be shared across processes via a backing file, an anonymous mapping inherited across fork, or a memfd passed between processes, and a shared xorshift64 RNG in the header ensures concurrent producers sample the same reservoir consistently. There is also weighted sampling via new_weighted which implements the Efraimidis-Spirakis A-Res algorithm so heavier items are retained more often. Mutation is protected by a futex-based write-preferring rwlock with dead-process recovery so crashes leave the reservoir consistent up to the last completed operation. Items are stored inline and truncated to item_size bytes and wide-character strings must be encoded to bytes first. The module is Linux-only and requires 64-bit Perl. Recent updates add recovery for files left by interrupted creation and improve unlink reporting.

Data::ReqRep::Shared is a Linux-only, 64-bit Perl module that implements a fast shared-memory request/response channel so multiple client processes can send requests and multiple worker processes can reply without a broker or per-connection sockets. It offers two flavors: a Str variant for variable-length byte-string requests and responses using a mutex-protected arena and fixed-size response slots, and an Int variant for single int64 values with a lock-free request queue for higher throughput. Clients can use simple synchronous req()/req_wait() calls or do fully asynchronous send/get with per-request slots, and both sides can integrate with event loops via optional eventfd notification. The implementation includes crash-recovery features such as PID-based stale-lock handling, automatic reclamation of abandoned response slots, and generation counters to avoid ABA reuse bugs. You can choose file-backed, memfd, or anonymous mappings and tune capacity, slot count, and response size for your workload. Recent releases fix a serious race that could deliver another client’s reply by ensuring a reply claims its slot before writing, improve recovery of interrupted channel creation, and add robustness and security hardening.

Data::RadixTree::Shared implements a compact, compressed radix (PATRICIA) trie stored in a shared memory mapping so multiple processes can insert and query the same key/value set. It maps arbitrary byte-string keys to 64-bit unsigned integer values and gives exact lookup plus efficient longest-prefix matching, which makes it useful for routing tables, dispatch tables and autocomplete back ends. The structure is edge-compressed so operations run in time proportional to key length and the design supports sharing via a backing file, an inherited anonymous mapping after fork, or a transferable Linux memfd. Mutations are serialized with a futex-based write-preferring rwlock and reads take a shared lock so many readers can query concurrently. Capacity for nodes and label bytes is fixed at creation and deletes are lazy until you call clear. Keys must be raw bytes and the module requires 64-bit Perl on Linux. Recent changes add recovery for files left by interrupted creates and a freeze/read-only mode so a sealed tree can be shipped and mapped O_RDONLY without locking.

Data::Queue::Shared provides fast, bounded multi-producer multi-consumer queues built on file-backed or memfd shared memory for Linux and 64-bit Perl, letting multiple processes exchange integers or byte strings with very low overhead. Integer variants use a lock-free Vyukov algorithm for extreme throughput and low latency, making them ideal for passing job IDs, counters, or indices, while the string variant stores variable-length payloads in a circular arena protected by a futex mutex and supports deque operations for requeueing or work stealing. The API offers non-blocking and blocking push/pop with timeouts, batch operations, peek, stats, optional eventfd notifications for event-loop integration, anonymous mappings for forked children, and memfd support so you can pass the backing descriptor between processes. Note that the Str queue is memory efficient for mixed-length messages but will serialize producers under heavy contention, and the module is Linux-only and requires 64-bit Perl. Recent changes include security and robustness hardening that now creates backing files as owner-only (mode 0600) by default and several fixes to avoid missed wakeups and potential deadlocks in batch operations.

Data::PubSub::Shared is a Linux-only, 64-bit Perl module that provides a very fast interprocess publish/subscribe mechanism by mapping a ring buffer into shared memory so multiple publishers and subscribers can exchange messages without copying. It offers several variants: lock-free integer types (Int, Int32, Int16) for ultra-low-latency numeric events and a Str variant for variable-length byte strings where publishers are serialized but subscribers remain lock-free. Features include file-backed, anonymous, or memfd-backed mappings, futex-based blocking polls with timeouts, eventfd integration for event loops, batch APIs and per-subscriber overflow tracking, and automatic recovery when subscribers fall behind. Use it when you need high-throughput, low-latency fan-out between processes on the same host and want fine control over memory backing and notification integration. Recent releases improve robustness and safety, notably an atomic publish fix in 0.08 that prevents a preempted publisher from reverting a slot and stalling subscribers, and a security hardening that defaults backing files to mode 0600.

Dancer2::Plugin::Auth::Extensible is a Dancer2 plugin that provides a flexible authentication and authorization framework for web applications. It lets you protect routes with simple decorators like require_login and require_role and offers helpers such as logged_in_user, authenticate_user and user_roles so your app can check credentials and permissions easily. Authentication is pluggable by realm so you can use providers that read users from a config file, the system, a database, IMAP or LDAP or write your own provider. The plugin includes secure password handling helpers, built in support for password resets and welcome emails, and configurable default login and denied pages that you can replace with your own handlers. It requires sessions and exposes hooks around authentication events so you can integrate custom behavior. Configuration is done in your Dancer2 config with per realm settings and there are ready made provider modules on CPAN. The module is designed to be extensible and practical but the author notes this is an early version and you may encounter bugs or missing features.

Sim::OPT is a Perl toolkit for steering and automating parametric optimization and exploration workflows that drive text‑based simulation models. It helps you generate and morph input files, run batches of simulations, and search a multidimensional parameter space using overlapping block searches that mix sequential and parallel update strategies, with options for factorial, star, face‑centered composite designs and metamodel‑based searches. The framework can operate by launching simulations or by mining precomputed results, records clear instance naming and mapping for traceability, and includes utility modules for model morphing and specialized tasks such as ESP‑r shading tweaks, creating AutoCAD 3D plots from parallel coordinates, and building sparse-data metamodels. The distribution provides an "opt" entry command, example workflows for ESP‑r and EnergyPlus, and runs on Linux. Sim::OPT is dual licensed with the open source copy available on CPAN under GPL v3 and additional proprietary components offered by the author, and the changelog in this release contains the original packaging metadata.

Data::Pool::Shared implements a fixed-size object pool in shared memory for Linux and 64-bit Perl, letting multiple processes allocate and free numbered slots much like a memory allocator. It offers raw byte pools plus typed variants for int32, int64, double and fixed-length strings with built-in atomic operations such as CAS, exchange and add, and it uses a lock-free bitmap for fast allocations that block efficiently on a futex when the pool is full. The module supports zero-copy reads via an SV tied to slot memory, raw C pointers for FFI or OpenGL use, batch alloc/free for better throughput, scope guards that auto-free on scope exit, anonymous or memfd-backed mappings, and a recover_stale facility that reclaims slots held by dead PIDs for crash recovery. Backing files are created with owner-only permissions by default and the constructor has rules to avoid reinitializing files that may contain real data. If you need fast, low-level shared-memory storage with atomic primitives and optional zero-copy access across processes, this module provides a practical, high-performance solution.

Data::PerfectHash::Shared builds a compact, immutable on-disk set of keys that you can memory-map read-only from many processes for extremely fast, lock-free membership tests. You create the set once from a list of integers or byte strings and it computes a CHD minimal perfect hash plus stores each key verbatim so "has" is exact with zero false positives. A built .phs file is mmap-ed by readers and gives O(1) worst-case, scalable lookups across processes with very small index overhead (around four bits per key) while the file size is dominated by the stored keys. The image is immutable and stores keys only, not values, and must be loaded on a host with the same byte order as the builder; building is the expensive step but queries are very fast. The 0.02 release clarifies the byte-order portability in the README and hardens edge cases such as re-entrancy with tied or overloaded arguments and certain DESTROY invocations.

Data::NDArray::Shared provides a typed, row-major N-dimensional numeric array living in shared memory on Linux so multiple processes can read and write the same dense numeric tensor. It supports common numeric dtypes (f64, f32, signed and unsigned integers) and 1 to 8 dimensions, and can be backed by a file, an anonymous mapping inherited across fork, or a memfd handed between processes. You get element and flat-index access, bulk fills and zeroing, reshape without copying, reductions like sum and mean, in-place scalar and element-wise arithmetic, and conversion to and from PDL including an optional zero-copy piddle alias with caveats. Mutations are serialized by a write-preferring futex rwlock with dead-process recovery so concurrent writers behave predictably, and a freeze/new_readonly feature seals a file so consumers can open a read-only, lock-free view that can be shipped to other machines of the same architecture. Note that integer types wrap on overflow, frozen files are native-endian only, PDL aliases bypass locking so you must coordinate access yourself, and the module requires Linux and 64-bit Perl. The recent 0.04 release added automatic recovery for files left by interrupted creates and formalized the frozen read-only mode.

Data::MinHash::Shared provides a compact, fixed‑size MinHash sketch for estimating Jaccard similarity between large sets and lets multiple processes share and update the same sketch via shared memory or a file. You add elements once and the module keeps k 64‑bit minimum registers so that the fraction of matching registers between two sketches estimates their intersection over union; larger k improves accuracy (k=256 gives roughly 6% standard error, k=1024 about 3%). Sketches can be merged incrementally across processes, frozen to a read‑only file that can be copied and queried lock‑free on other machines of the same architecture, or exported as tiny b‑bit signatures for very compact storage and fast comparison. The implementation is Linux‑only and requires 64‑bit Perl, it rejects wide character strings (you must supply bytes), and frozen files are native‑endian so they must be copied between like architectures; the module also documents practical crash‑recovery behavior and a conservative reader‑slot limit that makes pathological concurrent reader crashes unlikely but possible.

Data::Log::Shared provides a fast, append-only write-ahead log in shared memory for 64-bit Linux Perl programs, letting multiple writers append variable-length entries while readers replay from any position and block-wait for new data. It supports file-backed, memfd, or existing-file-descriptor storage and exposes simple operations like append, read_entry/each_entry for replay, wait_for to tail the log, and truncate/reset/sync/unlink for lifecycle control. The log retains committed entries until you explicitly truncate or reset it, with truncate marking old entries logically invalid in a concurrency-safe way and reset reclaiming space only when no other process is active. It also provides eventfd integration and basic stats and is designed for use cases such as audit trails, event sourcing, and debug logging where a durable, shared append-only history is needed. Backing files are created with owner-only permissions by default and you can pass an explicit file mode to share across users. Recent updates recover backing files left by interrupted creates and include robustness and re-entrancy hardening, making the module more resilient in real-world failure scenarios.

Data::KDTree::Shared provides a concurrent, shared-memory k-d tree for indexing points in up to 16 dimensions and supports fast nearest-neighbour, k-NN, axis-aligned box and radius queries without scanning every point. You append points with a 64-bit id and the module builds a balanced tree on first query so lookups stay fast regardless of insertion order. The index can be shared across processes via a backing file, a memfd or an inherited anonymous mapping and it uses lightweight locking so many readers can query concurrently while writers perform safe updates. It also supports freezing a file-backed index so you can ship a sealed, immutable file that consumers open read-only and query lock-free. The recent release adds recovery for files left by interrupted creation and introduces the frozen read-only mode to make distribution and lock-free consumption easier. Linux only and requires 64-bit Perl.