#102
Laya is a multilingual, non-autoregressive "System 1" decision engine that makes typed decisions over 100+ languages in a single forward pass, reported at roughly 33 ms per question (7.2 ms/question when batched) on an NVIDIA T4. Rather than generating text, Laya evaluates typed questions—of types `choice`, `score`, and `noul`—against any state such as plain text, email, support tickets, or JSON documents, which means there is nothing to parse and nothing to hallucinate. The models are trained with reinforcement learning against strictly proper scoring rules, an approach the project calls RLCD, and a built-in Router selects the appropriate checkpoint per request based on detected script and language. The project ships three checkpoints: `laya` (ModernBERT-large encoder, 421M params, 512 context) for English; `laya-multilingual` (mmBERT-base encoder, 322M params, 1024 context extendable up to 8,192 tokens, roughly 2x faster) for 100+ languages; and `laya-typed-decisions` (ModernBERT-large, 421M, 1024 context) specialized for typed-decision workflows. The Router automatically routes non-English text to the multilingual checkpoint, while English requests go to the English checkpoint; users can also force a checkpoint via the `model` argument. Installation is straightforward via `pip install laya` (or uv), requiring Python 3.10 or newer, with numerous optional extras for serving (HTTP server), MCP, LangChain/LangGraph, LlamaIndex, CrewAI, Agno, ONNX Runtime, a TileLang GPU fast path, and pydantic-based structured decisions. A TypeScript/Node.js/browser SDK (`laya-ts`) is published separately via npm.
Calibration is a notable part of Laya's design and recent development, directly relevant to the query. The fine-tuning loop explicitly includes a step to "calibrate temperatures" alongside building the dataset, training with RLCD, evaluating, and exporting, so that predicted probabilities (for example `answerConfidence` and the yes-probability returned for `noul` questions) are well-calibrated. The new Rust SDK (`laya-rust`), an ONNX Runtime port of the Python SDK, reimplements calibration and typed answers among other components, validated by 210 offline tests checked against goldens generated from the Python implementation. A recent bug fix (#731) addressed an issue where an ONNX agent's versioned calibration file always warned about a checkpoint mismatch because `ONNXAgent` never stored the identity that `apply_calibration_payload` compares against—now an ONNX agent's calibration file can correctly match its own checkpoint. Calibration quality is also benchmarked in head-to-head comparisons against "TypeSafe Jev" across shared public datasets, all 51 languages, accuracy, speed, and calibration.
On maturity, Laya appears actively developed and reasonably polished: it is at version 0.4.11, published on PyPI and Hugging Face (models and a demo Space), with online documentation, a Colab notebook, and an Apache 2.0 license. Fine-tuning substantially boosts accuracy: on the typed-decisions benchmark of 2,000 decisions across four workflows, the fine-tuned `laya-typed-decisions` checkpoint scores 0.766 accuracy versus 0.362 for the base English checkpoint. Documentation is extensive, including guides for prediction hooks, schema-driven decisions, Docker, and framework integrations, plus a full API reference, 41 runnable examples organized as an eight-stage learning path, consolidated benchmarks across 51 languages, local setup instructions, and research harnesses to reproduce reported numbers. Version 0.4.11 highlights include the Rust SDK, an ONNX exporter that proves its graph is batch-dynamic by running it at batches 1–3 and comparing against PyTorch (agreeing to 1.2e-06), two new MCP tools (`laya_predict_long` for scanning past the
ModelsServingMCPmultimodalon-devicelocal-first
★ 33,434 total+1,042 this week
#118
Baidu's **Unlimited-OCR** is an advanced OCR system designed to push the boundaries of document parsing through "one-shot long-horizon parsing," building directly on DeepSeek-OCR. Released in late June 2026, the project introduces a multimodal model capable of handling single images, multi-page documents, and PDFs in a unified pipeline. It supports two inference configurations — "gundam" (crop-mode, optimized for single images) and "base" (full-resolution, for multi-page/PDF) — with context lengths up to 32,768 tokens. The model is deployable via Hugging Face Transformers, vLLM, and SGLang, with Docker images and an OpenAI-compatible streaming API provided for production use. Training support is available through ms-swift, and the model is hosted on both Hugging Face and ModelScope, as well as Baidu Cloud. A live demo is accessible on Hugging Face Spaces. The project is trending on GitHub and Trendshift, reflecting strong community interest in high-quality, scalable OCR. It acknowledges DeepSeek-OCR, DeepSeek-OCR-2, and PaddleOCR as foundational inspirations, and an accompanying arXiv paper (2606.23050) details the methodology. Its breadth of deployment options and long-document capability make it a notable advancement in open-source OCR.
ModelsServingAppsmultimodalvision
★ 27,827 total+868 this week
#128NEWPartial week
RE:Dox is a high-performance, token-based structured data engine for .NET, developed by CAPCOM as a core component of their "REX" technology stack for a next-generation game engine. Rather than functioning as a conventional JSON serializer, RE:Dox parses structured data into a compact, fixed-size 64-bit token DOM (Intermediate Representation), which then serves as a unified structural layer for reading, editing, format conversion, serialization, deserialization, and automatic parallel deserialization across a wide range of formats. Supported formats include JSON, JSON5, CBOR, MessagePack, INI, and DOX at stable integration level, with TOML, XML, HTML, and CSV available as preview components.
The engine's central architectural innovation is a dual-mode 64-bit token: an extension bit determines whether the payload is interpreted by the document/format layer (source-backed) or by RE:Dox itself (editable DOM mode). This design enables a mutable tape DOM — normally read-only — by adding indirection through container views (DArray, DObject, DMap), a free list for reusing emptied token slots, and control tokens carrying edit state, preserving cache-friendly sequential memory layout while supporting node-like insert, remove, and replace operations. Serialization uses a single-pass write path directly to the output buffer with no intermediate object tree, while deserialization builds a compact token DOM first, enabling random access, out-of-order constructor binding, pre-sized collections, position-independent $type/$id/$ref resolution, and automatic parallel deserialization.
Performance benchmarks run on .NET 10 with BenchmarkDotNet on an AMD Ryzen Threadripper PRO 5975WX show RE:Dox achieving up to ~1.8x faster sequential deserialization, ~2.84x faster parallel deserialization, and ~1.6x faster serialization compared to System.Text.Json, while also dramatically reducing allocations — for example, deserializing canada.json allocates roughly 2.56 MB versus 8.53 MB for System.Text.Json. A unified converter model (DataConverter<T>) targets format-agnostic DataReader/DataWriter abstractions, allowing a single converter implementation to work across all supported formats and laying groundwork for future AOT and source-generator support. Additional notable features include trivia-preserving JSON5 editing (comments survive edits and re-encoding), lazy string/number decoding, compatibility layers for System.Text.Json, Newtonsoft.Json, and DataContractJsonSerializer, and dynamic access to the token DOM. The project is Apache-2.0 licensed and distributed via NuGet under the CAPCOM.REDox.* package prefix. Its trending
ModelsServingDatalocal-first
★ 1,648 total+614 this week