[new release] raven (11 packages) (1.0.0~alpha3)

[tmattio]

Modern scientific computing for OCaml

• Project page: https://github.com/raven-ml/raven
• Documentation: https://raven-ml.dev/docs/

CHANGES:

This release reshapes raven's foundations. Every package received API
improvements, several were rewritten, and two new packages — nx-oxcaml and
kaun-board — were built as part of our Outreachy internships.

Highlights

• Unified tensor type — Nx.t and Rune.t are now the same type.
  Downstream packages no longer need to choose between them or convert at
  boundaries. Rune is now a pure transformation library (grad, vjp, vmap)
  over standard Nx tensors.
• nx-oxcaml (new, Outreachy) — Pure-OCaml tensor backend using OxCaml's
  unboxed types and SIMD intrinsics. Performance approaches the C backend —
  in pure OCaml.
• kaun-board (new, Outreachy) — TUI dashboard for monitoring training
  runs in the terminal. Live metrics, loss curves, and system stats.
• quill — Rewritten from the ground up with two interfaces: a terminal UI
  with syntax highlighting and code completion, and a web frontend via
  quill serve with a CodeMirror 6 editor, WebSocket-based execution,
  autocompletion, and diagnostics.
• brot — The tokenization library formerly known as saga. Complete rewrite
  with a cleaner API. 1.3-6x faster than HuggingFace Tokenizers
  on most benchmarks.
• nx — Redesigned backend interface, RNG with effect-based scoping.
  Einsum 8-20x faster, matmul dispatch at BLAS parity with NumPy.

Breaking changes

• nx: Redesigned backend interface with new Nx_buffer type. Removed
  nx.datasets library. Moved NN functions to Kaun (use Kaun.Fn). Renamed
  im2col/col2im to extract_patches/combine_patches. RNG uses
  effect-based implicit scoping instead of explicit key threading. Removed
  in-place mutation operations (ifill, iadd, isub, imul, idiv,
  ipow, imod, imaximum, iminimum and _s variants). Removed
  Symbolic_shape module; shapes are concrete int array throughout.
  Removed Instrumentation module.
• rune: Rune.t no longer exists — use Nx.t everywhere. Rune no
  longer re-exports tensor operations; use open Nx for tensor ops and
  Rune.grad, Rune.vjp, etc. for autodiff. Remove any Rune.to_nx /
  Rune.of_nx calls. Removed enable_debug, disable_debug, with_debug;
  use Rune.debug f x instead.
• rune: Removed JIT/LLVM backend. This will come back in a future
  release with a proper ML compiler.
• kaun: Rewritten core modules API, datasets, and HuggingFace integration.
  Removed kaun-models.
• brot: Renamed from saga. Rewritten API focused on tokenization.

Nx

• Unify Nx.t and Rune.t into a single tensor type. A new nx.effect library (Nx_effect) implements the backend interface with OCaml 5 effects: each operation raises an effect that autodiff/vmap/debug handlers can intercept, falling back to the C backend when unhandled. Nx.t is now Nx_effect.t everywhere — no more type conversions between Nx and Rune.
• Make transcendental, trigonometric, and hyperbolic operations (exp, log, sin, cos, tan, asin, acos, atan, atan2, sinh, cosh, tanh, asinh, acosh, atanh, erf, sigmoid) polymorphic over all numeric types including complex, matching the backend and effect definitions.
• Make isinf, isfinite, ceil, floor, round polymorphic (non-float dtypes return all-false/all-true or no-op as appropriate).
• Redesign backend interface with more granular operations (e.g. dedicated unary and binary kernels). This improves performance by letting backends optimize individual ops directly, and prepares for the JIT pipeline which will decompose composite operations at the compiler level instead of the frontend.
• Rewrite Nx_buffer module with new interface. The backend now returns Nx_buffer.t instead of raw bigarrays.
• Add new C kernels for unary, binary, and sort operations, and route new backend ops to C kernels.
• Add scipy-style correlate, convolve, and sliding window filters.
• Generalize unfold/fold to arbitrary leading dimensions.
• Remove neural-network functions from Nx (softmax, log_softmax, relu, gelu, silu, sigmoid, tanh). These now live in Kaun.Fn.
• Rename im2col/col2im to extract_patches/combine_patches.
• Remove nx.datasets module. Datasets are now in kaun.datasets.
• Simplify Nx_io interface. Inline vendor libraries (safetensors, and npy) directly into nx_io.
• Move the Rng module from Rune into Nx with effect-based implicit scoping. Random number generation uses Nx.Rng.run to scope RNG state instead of explicit key threading.
• Reduce matmul dispatch overhead to reach BLAS parity with NumPy.
• Fix Threefry2x32 to match the Random123 standard.
• Fix save_image crash on multi-dimensional genarray.
• Pre-reduce independent axes in einsum to avoid OOM on large contractions.
• Make Nx backends pluggable via Dune virtual libraries. The new nx.backend virtual library defines the backend interface, with the C backend (nx.c) as the default implementation. Alternative backends (e.g., nx-oxcaml) can be swapped in at link time. The Nx_c module is renamed to Nx_backend.
• Fix .top libraries failing to load in utop with "Reference to undefined compilation unit Parse".
• Fix OpenMP flag filtering in discover.ml: strip -Xpreprocessor -fopenmp as a pair on macOS to prevent dangling -Xpreprocessor from consuming subsequent flags and causing linker failures. (@Alizter)
• Add missing bool→low-precision cast support (f16/bf16/fp8) in the C backend.
• Add UInt32/UInt64 dtypes, rename complex dtypes to Complex64/Complex128, and drop Complex16/QInt8/QUInt8/Int/NativeInt as tensor element dtypes.
• Remove in-place mutation operations (ifill, iadd, isub, imul, idiv, ipow, imod, imaximum, iminimum and _s variants). Use functional operations instead.
• Remove Symbolic_shape module; shapes are now concrete int array throughout.
• Remove Instrumentation module. Nx no longer wraps operations in tracing spans. Debugging tensor operations is handled by Rune's effect-based debug handler.
• Fix critical correctness issue in fancy slicing (L) where permutations were ignored if the number of indices matched the dimension size (e.g., slice [L [1; 0]] x returned x unmodified).
• Rewrite slice implementation to use as_strided for contiguous operations, reducing overhead to O(1) for view-based slices and separating gather operations for better performance.
• Optimize set_slice by replacing scalar-loop index calculations with vectorized coordinate arithmetic, significantly improving performance for fancy index assignments.
• Improve einsum performance 8–20× with greedy contraction path optimizer (e.g., MatMul 100×100 f32 207.83 µs → 10.76 µs, 19×; BatchMatMul 200×200 f32 8.78 ms → 435.39 µs, 20×)
• Rewrite diagonal using flatten + gather approach instead of O(N²) eye matrix masking, reducing memory from O(N²) to O(N)
• Improve error messages for shape operations (broadcast, reshape, blit) with per-dimension detail and element counts.

nx-oxcaml (new)

New pure-OCaml tensor backend that can be swapped in at link time via Dune virtual libraries. Uses OxCaml's unboxed types for zero-cost tensor element access, SIMD intrinsics for vectorized kernels, and parallel matmul. Performance approaches the native C backend — in pure OCaml. Supports the full Nx operation set: elementwise, reductions, matmul, gather/scatter, sort/argsort, argmax/argmin, unfold/fold, pad, cat, associative scan, and threefry RNG. (@nirnayroy, @tmattio)

Rune

• Unify tensor types: Rune.t is now Nx.t. Rune no longer re-exports the Nx frontend — it is a pure transformation library exporting only grad, grads, value_and_grad, vjp, jvp, vmap, no_grad, detach, and debugging/gradcheck utilities. All tensor creation and manipulation uses Nx directly.
• Remove Tensor module and Nx_rune backend. Effect definitions moved to the new nx.effect library shared with Nx.
• Remove Rune.to_nx / Rune.of_nx (no longer needed — types are identical).
• Remove Rune.enable_debug, Rune.disable_debug, Rune.with_debug. Use Rune.debug f x to run a computation with debug logging enabled.
• Remove JIT compilation support from Rune. The Rune.Jit module and LLVM/Metal backends have been removed and will be re-introduced later as a standalone package.
• Update to new Nx_buffer.t type.
• Propagate new backend operations through effects and autodiff.
• Rewrite Autodiff module to fix critical JVP correctness issues, enable higher-order derivatives (nested gradients), and introduce vjp as a first-class primitive.
• Fix pointer-based hashing in autodiff, correcting nested JVP handler behavior.
• Add autodiff support for as_strided, enabling gradients through slicing and indexing operations
• Add autodiff support for cummax and cummin cumulative operations
• Add autodiff support for FFT operations
• Add autodiff support for some linear algebra operations: QR decomposition (qr), Cholesky decomposition (cholesky), and triangular solve (triangular_solve).

Kaun

• Simplify and redesign the core API for better discoverability and composability. Layers, optimizers, and training utilities now follow consistent patterns and compose more naturally.
• Add Fn module with conv1d, conv2d, max_pool, avg_pool — neural network operations that were previously in Nx now live here with a cleaner, more focused API.
• Redesign datasets and HuggingFace integration with simpler, more composable APIs.
• Remove kaun-models library. Pre-built models now live in examples.
• Reinitialize dataset each epoch to avoid iterator exhaustion (fix(training): reinitialize dataset each epoch to avoid iterator exhaustion  raven-ml/raven#147, @Shocker444, @tmattio)

kaun-board (new)

TUI dashboard for monitoring training runs in the terminal. Displays live metrics, loss curves, and system stats. Extracted from kaun's console module into a standalone package. (raven-ml/raven#166, raven-ml/raven#167, raven-ml/raven#170, @Arsalaan-Alam)

Brot

• Rename the library from saga to brot.
• Simplify brot to a tokenization-only library. Remove the sampler, n-gram models, and I/O utilities. The sampler is rewritten with nx tensors and moved to dev/mimir as the seed of an experimental inference engine.
• Merge brot.tokenizers sub-library into brot.
• Remove dependency on Nx.
• Use Buffer.add_substring instead of char-by-char loop in whitespace pre-tokenizer.
• Compact BPE symbols in-place after merges, avoiding an intermediate array allocation.
• Replace list cons + reverse with forward List.init in BPE word_to_tokens.
• Use pre-allocated arrays with Array.blit instead of Array.append in encoding merge and padding, halving per-field allocations.
• Avoid allocating an unused words array in post-processor encoding conversion.
• Reduce WordPiece substring allocations from O(n²) to O(n) per word by building the prefixed candidate string once per position.
• Add encode_ids fast path that bypasses Encoding.t construction entirely when only token IDs are needed.
• Add ASCII property table for O(1) character classification in pre-tokenizers, replacing O(log n) binary search for is_alphabetic (600 ranges), is_numeric (230 ranges), and is_whitespace (10 ranges). Yields 12-27% speedup on encode benchmarks with ~30% allocation reduction.
• Add inline ASCII fast paths in all pre-tokenizer loops, skipping UTF-8 decoding and using Buffer.add_char instead of String.sub for single-byte characters. Combined with the property table, yields 20-30% total speedup and 36-55% allocation reduction vs baseline.
• Parallelize batch encoding with OCaml 5 domains.
• Optimize BPE merge loop with open-addressing hash, flat arrays, and shift-based heap.
• Add trie-based WordPiece lookup and normalizer fast path.
• Remove dependency on str library.
• Generate unicode data offline, removing runtime dependency on uucp.
• Remove unused Grapheme module. Grapheme cluster segmentation is not needed for tokenization.
• Remove uutf dependency in favour of OCaml Stdlib unicode support.

Fehu

• Simplify and redesign the core API. Environments and training utilities now follow consistent functional patterns that are easier to use and compose.
• Remove fehu.algorithms — fehu now only depends on rune, and users bring their own algorithms. Examples provided for well-known RL algorithms like DQN and REINFORCE.

Sowilo

• Cleaner public API — internal implementation split into focused submodules while the public surface stays small.
• Faster grayscale conversion, edge detection, and gaussian blur.

Quill

Rewritten from the ground up. Terminal UI with syntax highlighting, code completion, and a compact single-line footer. Web frontend via quill serve with a CodeMirror 6 editor, WebSocket-based execution, autocompletion, and diagnostics. Markdown notebook format shared across both interfaces.

Hugin

• Fix potential bad memory access in rendering.
• Fix single-channel HWC image handling in float32_to_cairo_surface.

Talon

• Remove jsont, bytesrw, and csv dependencies from Talon. CSV support is now built-in via the talon.csv sub-library with a minimal RFC 4180 parser.
• Remove talon.json sub-library.

[tmattio]

Note: I'm opening a PR to identify blockers for the release early on - this is not intended for merge just yet, as we still have a couple items in scope for alpha3, but we're hoping to cut the final release in the next few days.

Question for opam-repository maintainers: is there a defined process for renaming packages? This release renames the "saga" package into "brot" as we rewrote the library to be focused on tokenization. If there's a well-defined process and it's not too much trouble, there are other packages that I'd like to rename.

On my end, I'd be happy to simply remove the previous raven packages from the opam-repository. There is no user that depend on raven for any serious project just yet, and the few users I know of would likely be happy to just migrate to the next version. Although we're still in alpha, the APIs are stabilising, so I would not expect this to happen again.