koharu-rs/koharu

Koharu is a cross-platform desktop application for processing and translating manga and comics, built on a Rust and TypeScript stack with Tauri and Next.js. It orchestrates a complex pipeline of machine learning tasks—including object detection, OCR, translation, and inpainting—by leveraging local inference engines like llama.cpp and PyTorch alongside remote API providers. The system features a GPU-accelerated WebGPU canvas for high-performance rendering and manages project persistence through a robust, content-addressed filesystem storage layer.

The \koharu-psd\ crate now provides a new feature that exports Koharu projects as classic PSD files. This implementation follows GIMP's PSD plug-in specifications to serialize scene layers, text metadata (including font, orientation, and justification), and raster images into a compatible Photoshop document structure, including support for editable text layers, removal masks, and source image inclusion via configurable export options.

crates/koharu-psd · high confidence

A new 'runtime' skill has been added to the \.agents\ directory to help coding agents keep Koharu's native runtimes up to date. This includes a \sync.sh\ script that fetches the latest releases for \llama.cpp\ and \stable-diffusion.cpp\, updates the vendored C/C++ headers in the \koharu-llama-sys\ and \koharu-diffusion-sys\ crates, and prints the current versions for manual review of generated bindings.

.agents · high confidence

The \koharu-ml\ crate now includes a comprehensive suite of Criterion benchmarks for its various ML models, covering AOT inpainting, Baberu OCR, comic layout and onomatopoeia detection, text bubble and font detection, FLUX.2 Klein inpainting, LaMa, Manga OCR, PaddleOCR-VL, PP-OCRv6, and YOLO-based segmentation. Additionally, the AOT inpainting capability itself has been implemented, providing a new \AotInpainting\ module that loads weights from the \mayocream/aot-inpainting\ repository and performs image inpainting with configurable max-side resizing and reflection padding.

crates/koharu-ml · high confidence

The build process for koharu-torch-sys now automatically generates Rust bindings for the underlying Torch C API. This ensures that the Rust interface stays synchronized with the C library headers, allowing the application to correctly interact with PyTorch backend functions.

crates/koharu-torch-sys · high confidence

This change establishes the foundational structure for the Koharu package, introducing a Next.js application configured for static export with transpilation support for internal dependencies (@koharu/bridge, @koharu/ui). It sets up a modern development environment using TypeScript, Tailwind CSS, and the Oxlint linter, while integrating Vitest for testing with jsdom and specific mocks for WASM modules. Additionally, it includes a reusable ClientOnly component to handle server-side rendering compatibility for client-specific React features.

packages/koharu · high confidence

The new @koharu/bridge package establishes the browser/native boundary by generating a Tauri command protocol (src/protocol.ts) and providing a WebGPU/WASM-based canvas adapter (src/canvas.ts) that wraps koharu-canvas for the browser. This enables the frontend to interact with native canvas operations, manage project state, and handle exports (including CBZ) through a unified interface, while the WASM output is built separately and ignored in version control.

packages/bridge · high confidence

This change introduces the \koharu-agent\ crate, providing an in-process agent that integrates with OpenAI's Codex API. It adds support for selecting specific reasoning levels (Low, Medium, High, Xhigh, Max, Ultra) for model interactions, normalizing aliases from the model catalog. The agent handles OAuth device-flow authentication, manages token storage and refresh, and exposes a structured event stream (text, reasoning, tool calls) for user-facing updates.

crates/koharu-agent · high confidence

The new \koharu-secrets\ crate provides a unified API for storing, retrieving, and deleting sensitive credentials. It utilizes the Linux Keyutils keyring on Linux systems and falls back to the standard \keyring\ crate on other platforms, ensuring secrets are handled securely by the operating system. The library exposes \SecretString\ types that automatically redact values during serialization and support zeroization to clear memory, while the \get\, \set\, and \delete\ functions abstract away the underlying platform-specific credential store initialization.

crates/koharu-secrets · high confidence

A new \koharu-bindgen\ crate has been added to generate Rust bindings for C libraries that automatically handle dynamic loading. The tool post-processes standard \bindgen\ output to replace direct static linking with runtime adapters that load libraries via \libloading\. It includes a CLI and library API that support specifying header files, library names, and standard bindgen filters (allowlists/blocklists for functions, types, and variables). The generated code implements platform-specific logic to locate bundled libraries (checking executable directories and macOS Frameworks) and attempts to reuse already-loaded libraries in the process before falling back to system paths.

crates/koharu-bindgen · high confidence

The new koharu-pipeline crate provides the core orchestration for the image processing workflow, managing the execution of detection, OCR, translation, and inpainting stages over a scene project. It introduces a fixed, explicit workflow where stages run in dependency order (detection → OCR → translation/inpainting) with page-level scheduling that respects accelerator constraints to avoid resource contention. The pipeline supports configurable model selection for each stage (including the new Hayai OCR model), handles model residency and lazy loading, and ensures durability by committing stage results immediately so that completed work is retained even if the run is stopped or a later stage fails.

crates/koharu-pipeline · high confidence

The new koharu-rasterizer crate provides a backend-neutral, GPU-accelerated rendering pipeline for Koharu. It manages a shared Vello/WGPU compositor that handles both vector batches and raster tiles, organizing them into versioned, content-addressed display lists (PreparedFrameManifest and PreparedResourcePacket) for efficient transport and caching. On native platforms, it exposes headless GPU readback and export supersampling (up to 4x with configurable filters like Lanczos3), allowing high-resolution rasterization and export without a display server. Browser transport is supported via lightweight, content-hashed resource packets that persist across frame and page changes.

crates/koharu-rasterizer · high confidence

The new koharu-storage crate provides the underlying persistence layer for projects, replacing previous storage mechanisms. It implements a filesystem-native format using alternating complete state snapshots (state-a.khr and state-b.khr) and immutable, content-addressed blobs identified by BLAKE3 hashes. This design ensures durability through atomic saves and automatic fallback to the previous valid state slot in case of corruption or missing blobs. The crate manages blob lifecycles via explicit garbage collection and supports large file handling through memory-mapped reads, while enforcing strict revision control to prevent stale overwrites.

crates/koharu-storage · high confidence

The new \koharu-metrics\ crate enables anonymous product analytics by converting \tracing\ spans and events into GA4-compatible payloads. It automatically collects device context (platform, architecture, locale) and user properties (app version, release channel) while managing session tracking and engagement timing. Data is sent to Google's \g/collect\ endpoint using a unique machine identifier derived from the OS (Linux machine-id, macOS UUID, or Windows MachineGuid) to ensure consistent, anonymous user identification.

crates/koharu-metrics · high confidence

The runtime now manages GPU and AI dependencies through a new modular package system in \crates/koharu-runtime/src/runtime/packages\. This adds explicit support for CUDA 13 libraries (runtime, cuBLAS, cuDNN 9.25, etc.) and ROCm 10.0, alongside bundled Torch v2.13.0.7 (CPU, CUDA, and ROCm variants). It also integrates native \llama.cpp\ and \stable-diffusion\ binaries for Windows, Linux (x86\_64 and ARM64), and macOS, automatically discovering the correct accelerator variant based on hardware capabilities and handling their installation and dynamic loading.

crates/koharu-runtime/src/runtime/packages · high confidence

The runtime now includes dedicated source modules to handle dependency acquisition: archive extraction (supporting ZIP/WHL and GZ/TAR with pattern filtering), Hugging Face model/dataset retrieval with pinned revisions, and PyPI wheel resolution for Windows x64, Linux x64, and Linux ARM64 platforms. These modules provide the underlying mechanisms for downloading and extracting external assets required by the application.

crates/koharu-runtime/src/source · high confidence

The runtime now uses a directed acyclic graph to manage dependencies between GPU packages (CUDA, ROCm, Torch, Llama, Diffusion). This ensures that packages are installed and activated in the correct order, with shared dependencies (like CUDA libraries) loaded only once. The system automatically detects compatible hardware and sequences the activation of features like Llama and Diffusion to avoid conflicts.

crates/koharu-runtime/src/runtime · high confidence

Adds a new \nn\ module to \koharu-torch\ providing core neural network components, including linear, convolutional (1D/2D/3D), transposed convolutional, batch/group/layer normalization, recurrent (LSTM), and embedding layers, alongside a sequential container for chaining modules. The update also introduces a variable store system for managing model parameters on specific devices, a variable initialization system supporting Kaiming, orthogonal, and uniform distributions, and gradient descent optimizers (SGD, Adam, AdamW, RMSprop) to facilitate model training.

crates/koharu-torch/src/nn · high confidence

The runtime now exposes a structured device model (device.rs) that identifies compute backends (CPU, CUDA, ROCm, Vulkan, Metal) and device types, enabling the application to select and report the correct hardware for ML workloads. Concurrently, a new download subsystem (download.rs) provides reliable, retry-aware file fetching with progress events, while a new package store (store.rs) manages local artifacts with atomic installation and file locking to prevent corruption. These components are wired together in the runtime library (lib.rs) and supported by a centralized HTTP client configuration (network.rs), forming the foundation for model loading and updates.

crates/koharu-runtime/src · high confidence

The application now includes two new crates to support machine learning capabilities: \koharu-llama-sys\ provides low-level dynamic bindings to llama.cpp, and \koharu-torch\ exposes a Rust interface to the PyTorch C++ API (libtorch). The \koharu-torch\ crate adds core tensor operations, neural network modules, vision utilities, and dataset iterators for batching and shuffling data, enabling the application to load and run models using these backends.

crates/koharu-llama-sys/src, crates/koharu-torch/src · high confidence

The \koharu-diffusion-sys\ crate now provides low-level dynamic bindings for the stable-diffusion.cpp library, exposing functions for image/video generation, upscaling, and adetailer processing, along with support for various sampling methods, schedulers, and quantization types. Additionally, the \koharu-llama-sys\ crate introduces bindings for the LLaMA, GGUF, and MTMD libraries, enabling access to core language model inference and multimodal text-to-image capabilities.

crates/koharu-diffusion-sys · high confidence

The \koharu-torch\ crate now includes a comprehensive set of Rust wrappers for PyTorch functionality. This adds support for managing compute devices (CPU, CUDA, MPS, Vulkan) and tensor data types (including Float8 variants), as well as image I/O and resizing. It introduces a JIT interface with \IValue\ handling for model execution, optimizers (Adam, SGD, RMSProp), and tensor operations via generated fallible and infallible APIs. Stream serialization is also restored to support custom read/write operations for model persistence.

crates/koharu-torch/src/wrappers · high confidence

The \koharu-diffusion\ crate now provides a safe Rust wrapper around the stable-diffusion.cpp C API, enabling users to generate images and videos directly from Rust code. This includes a \Context\ for managing model lifecycles, support for text-to-image and text-to-video generation with optional audio, and utilities for model conversion, Canny edge preprocessing, and upscaling. The library exposes progress and preview callbacks for real-time feedback, handles native memory safely, and supports various tensor types and sampling methods.

crates/koharu-diffusion · high confidence

The vision module now includes implementations for several standard neural network architectures, including AlexNet, ConvMixer, DenseNet (121, 161, 169, 201), DINOv2, EfficientNet (B0–B7), InceptionV3, MobileNet V2, and ResNet (18, 34, 50, 101, 152). It also adds utilities for loading and preprocessing images, along with dataset loaders for MNIST, CIFAR-10, and ImageNet, and helper scripts to export pre-trained weights in safetensors format.

crates/koharu-torch/src/vision · high confidence

This change introduces a suite of new UI control components in the Koharu application to enhance user interaction with colors, fonts, and translation settings. The new ColorSampling component and provider enable a centralized, context-aware color picker that temporarily switches the canvas tool, while the ColorWell component supports hex input, visual picking, and optional transparent color values. Font selection is handled by a new FontPicker featuring virtualized lists, search, and filtering by script, category, and source. Additionally, ModelPicker and OutputPicker components provide interfaces for selecting translation models (including quantization options and download status) and configuring output targets with instructions, ensuring state is preserved and changes are committed appropriately.

packages/koharu/components/controls · high confidence

The editor now features a redesigned layout with a new ActivityCenter that displays real-time status for background jobs and model downloads, and an AgentPanel that allows users to sign in, select AI models, and adjust reasoning levels for local or cloud-based translation tasks.

packages/koharu/components/editor · high confidence

The runtime now includes a new hardware detection module that automatically discovers available GPUs on Linux and Windows. It probes for NVIDIA CUDA devices (requiring driver version 13.3+ and compute capability 7.5+), AMD ROCm devices via the Linux KFD topology or Windows OpenCL ICD, and Vulkan support. The system prioritizes discrete GPUs over integrated ones and selects the best candidate based on backend preference, memory, and compute capability.

crates/koharu-runtime/src/hardware · high confidence

The \koharu-app\ crate has been introduced to manage the Tauri application state, command API, project lifecycle, processing jobs, typed channels, and the agent host. It uses \koharu-desktop\ to prepare and publish page frames for the browser canvas. Rust command signatures serve as the authoritative frontend contract, and a new \generate\ binary is available to export these bindings to TypeScript (\packages/bridge/src/protocol.ts\).

crates/koharu-app · high confidence

The \koharu-translator\ crate introduces a dedicated translation engine that supports both local GGUF models and hosted providers (OpenAI, Gemini, Claude, Grok, MiniMax, DeepL, LM Studio, and others). Users can now translate text segments using locally loaded models with configurable quantizations, or route requests to remote APIs. The engine preserves segment boundaries, supports multimodal image context for visual translation, and allows custom instructions. A CLI tool is included for direct translation testing, and the system handles API key management via the platform keychain.

crates/koharu-translator · high confidence

The renderer has been replaced with a new implementation that supports retained rendering, preserving unchanged layers across scene updates for better performance. It introduces comprehensive Unicode-aware text shaping, including language-aware line breaking, hyphenation, and support for vertical CJK writing modes. Font handling now includes system discovery, lazy loading, fallback resolution, and configurable typesetting options via a dynamic configuration file.

crates/koharu-renderer/src · high confidence

The \koharu-llama\ crate now provides a comprehensive safe wrapper around the llama.cpp library, introducing core types such as \LlamaContext\ for managing inference state, \LlamaBatch\ for token batching, and \LlamaModel\ for model handling. This update adds robust support for KV cache management (including sequence copying, clearing, and position adjustments), session state persistence, and GGUF metadata inspection. It also exposes context parameters for configuring batch sizes, thread counts, and attention types, along with error handling for decoding, encoding, and embeddings.

crates/koharu-llama · high confidence

The \packages/ui\ directory now includes a complete set of UI components (such as Accordion, AlertDialog, Button, Card, and Avatar) generated using the shadcn/ui CLI. This introduces a new \components.json\ configuration file that defines the project's style, aliases, and dependencies on \@base-ui/react\ and \lucide-react\. For users, this provides a standardized, accessible, and themeable component foundation that can be imported and used throughout the application.

packages/ui · high confidence

The tensor module now supports converting tensors to and from Rust standard collections (Vec, ndarray) and scalar types, enabling seamless data exchange with host code. It introduces a NumPy-style indexing API via the \i\ operator for selecting, narrowing, and inserting dimensions, along with iterator support for traversing tensor elements. Additionally, users can now read and write tensors using \.npy\/\.npz\ and \.safetensors\ formats, facilitating interoperability with Python-based ML workflows and model loading.

crates/koharu-torch/src/tensor · high confidence

The application now features a dedicated Settings page that consolidates configuration into Appearance, Pipeline, Providers, Translation, Typesetting, and Shortcuts tabs. Users can now manage provider credentials and base URLs, select specific models for detection, OCR, and inpainting stages (including Hayai OCR), and fine-tune generation parameters such as temperature, top-k, and reasoning/vision toggles. The interface also supports configuring translation target languages and instructions, as well as managing font fallback stacks for typesetting.

packages/koharu/components/preferences · high confidence

Added new TypeScript scripts to automate content downloading: \download\_bluearchive\_comics.ts\ fetches comic images from the Blue Archive CMS and saves them as JPEG or PNG files, while \kinde.ts\ downloads Kindle JP manga by rendering pages via the Amazon reader API, decrypting encrypted assets, and saving them locally. The \scripts\ directory also includes a \release.ts\ script to automate version bumping, changelog generation, and git tagging for the Rust workspace, along with supporting configuration files (\tsconfig.json\, \.gitattributes\).

scripts · high confidence

The repository has been initialized with a comprehensive documentation suite, including a detailed README covering features, hardware acceleration (CUDA, ROCm, Metal, Vulkan), supported ML models, and installation instructions. A formal changelog (CHANGELOG.md) is now maintained via git-cliff, and a contributing guide (CONTRING.md) outlines AI-assisted contribution policies. The project structure is standardized with an .editorconfig, a .gitignore for build artifacts and local data, and an oxfmt configuration for code formatting. The license has been updated to MIT.

(repo-wide) · high confidence

The scene crate has been rebuilt to use a new component-based data model where entities are composed of typed, serializable parts (such as Typography, Geometry, Assets, and OCR analysis) that are validated and stored with schema revisions. This change introduces a structured editing system that tracks granular changes to the scene hierarchy and component values, enabling precise patching and snapshotting of document state.

crates/koharu-scene/src · high confidence

The application's root layout and providers have been reorganized to establish a consistent visual and functional foundation. A new global CSS file defines a comprehensive design system with CSS variables for light and dark themes, including specific styling for CJK font variants and UI components. The root layout now integrates Next.js font loading for Noto Sans CJK and wraps the application in a ThemeProvider. The Providers component centralizes critical runtime logic, including React Query and i18next setup, Tauri event subscriptions for canvas and project state, and a fix to prevent viewport scaling during Ctrl+wheel interactions. A new global error page provides localized error messages, and the app entry point now renders the main KoharuApp component within a startup boundary that displays a loading view until initialization is complete.

packages/koharu/app · high confidence

The \crates/koharu\ package has been reorganized to serve as the native composition layer for the Tauri v3 application. This change introduces platform-specific configuration files (\tauri.macos.conf.json\, \tauri.windows.conf.json\, \tauri.linux.conf.json\) that define window behaviors, such as the macOS overlay titlebar style and Linux AppImage bundling targets. It also adds an \Entitlements.plist\ for macOS library validation and configures the Windows trusted signing command. The package now includes the \tch-rs\ (PyTorch) bindings with dual Apache-2.0/MIT licensing, enabling the runtime to dynamically load the \koharu-torch\ library for tensor operations.

crates/koharu · high confidence

The browser canvas rendering engine has been rebuilt to use WebGPU (via the Vello library) instead of the previous implementation. This change introduces a new \koharu-canvas\ crate that handles GPU-accelerated rendering, including a \SurfaceBlitter\ for drawing frames and a \ResourceUsage\ cache to manage GPU memory with least-recently-used eviction policies. The canvas now supports specific web interactions like inpainting, stroke/erase commits, and element transformation previews, all optimized for WASM environments.

crates/koharu-canvas/src · high confidence

The desktop application now uses a new \CanvasState\ struct to expose page and revision details, including element frame transformations with rotation angles, to the UI layer. This change introduces a dedicated \Desktop\ struct that manages rendering and rasterization, implementing a caching system for page frames to optimize presentation performance and ensure consistent state during export or browser preview.

crates/koharu-desktop/src · high confidence

This change introduces a new set of TypeScript modules in the \packages/koharu/lib\ directory that handle core client-side application logic. The \store.ts\ file establishes a new Zustand-based global state for managing canvas tools, brush settings, and processing scopes. \backend.ts\ provides a unified interface for dispatching and calling commands to the native backend, including preference synchronization. \queries.ts\ integrates React Query to manage data fetching for projects, pages, and fonts. Additionally, \document.ts\ and \geometry.ts\ implement new logic for layer hierarchy traversal, visibility calculation, and precise geometric frame calculations for the canvas, while \i18n.ts\ configures the internationalization setup with language detection.

packages/koharu/lib · high confidence

The application now includes a dedicated diagnostics module that enhances error reporting and log visibility. On Linux, a custom \mallinfo\ implementation prevents memory-diagnostic overflows in the CEF runtime when the in-process ML heap exceeds 2 GiB. The main entry point initializes Sentry for crash reporting and configures a structured tracing subscriber that integrates Sentry, custom timing layers, and native metrics, while explicitly excluding internal telemetry targets from standard logs. Additionally, a custom panic hook captures crash details, flushes Sentry data, and displays a user-friendly error dialog before exit.

crates/koharu/src · high confidence

The application's main interface has been rebuilt with a new \KoharuApp\ component that integrates a custom \TitleBar\ and \WindowChrome\. This change introduces native-feeling window controls (minimize, maximize, close) and custom resize handles for non-macOS platforms, replacing the previous system chrome. The update also adds an \AboutDialog\ to display version and author information, and an \Updater\ component that handles checking for, downloading, and installing application updates with progress tracking. A new \StartupView\ provides a dedicated loading state while the project initializes.

packages/koharu/components/app · high confidence

The start page has been redesigned to improve usability and safety. The layout now features a two-column grid with a dedicated panel for creating new projects and a scrollable list of existing projects. A key behavioral change is the addition of confirmation dialogs (AlertDialog) before deleting a project, preventing accidental data loss. The view also includes a settings button and improved handling of long project names to ensure UI elements remain visible.

packages/koharu/components/start · high confidence

The \koharu-torch-sys\ crate now includes a new \io\ module that registers C callbacks for reading and writing streams, effectively restoring the ability to serialize and deserialize Torch models via custom I/O streams. This change also adds new modules for CUDA device management (\cuda.rs\), type traits for list handling (\traits.rs\), and re-exports generated C bindings (\c\_generated.rs\), ensuring that the underlying native Torch library can correctly handle model loading and saving operations through Rust's \Read\ and \Write\ traits.

crates/koharu-torch-sys/src · high confidence

The \koharu-torch-sys\ bindings have been regenerated to support PyTorch 2.13, introducing new C API functions for advanced operations such as Flash Attention, efficient attention, and dynamic quantization. This update also restores stream serialization capabilities, ensuring that model saving and loading via custom streams functions correctly with the new backend.

crates/koharu-torch-sys/libtch · high confidence

The native FFI headers in crates/koharu-llama-sys/include have been updated to match the latest llama.cpp and ggml libraries. This brings in new tensor allocation and backend management APIs (ggml-alloc, ggml-backend), expanded CPU backend capabilities (ggml-cpu), model optimization interfaces (ggml-opt), and the GGUF file format reader (gguf.h). These changes enable the application to leverage improved memory management, asynchronous execution, and broader hardware support in the underlying ML runtime.

crates/koharu-llama-sys/include · high confidence

A fix in crates/koharu/icons — 3 commits (2 fixs), 17 files.

crates/koharu/icons · medium confidence · unverified

Add test setup for UI and store mocking; Added component tests for canvas, color sampling, editor UI, updater, and project management; Added integration tests for renderer frame generation and rasterization; Added mock for Koharu Canvas WASM module in tests; Added test coverage for canvas, geometry, i18n, runtime, and store modules.

The project has been restructured into a comprehensive Rust/TypeScript workspace, establishing the foundation for Koharu v3. The Rust backend now uses a multi-crate architecture (including koharu-app, koharu-ml, koharu-renderer, and koharu-runtime) and integrates Tauri 3 (via \@tauri-apps/api\ 3.0.0-alpha.2) for the desktop shell. The frontend has migrated to Next.js 16 with React 19, replacing previous setups. This change also introduces a new WASM-based canvas bridge (\@koharu/bridge\) and updates the build tooling to use Bun and Oxfmt.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 59 → 61 (+2.1)
• Rubric changed (rubric-2026.09.10 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 85 → 85 (-0.6)
• Architecture 100 → 96 (-3.8)
• Maturity 63 → 63 (-0.1)
• Readiness 81 → 80 (-1.0)
• Security 50 → 56 (+6.2)
• Event Sourcing 100 → 100 (+0.0)
• Accessibility 54 → 54 (+0.0)
• Performance 91 (new)

• Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (no pnpm-resolved versions to grade)
• Documentation: no installation or build instructions (README.md)
• Documentation: no installation or build instructions (crates/koharu-ml/benches/fixtures/inpaint/README.md)
• Documentation: no project overview (crates/koharu-ml/benches/fixtures/inpaint/README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (24 lines × 6) (crates/koharu-translator/src/remote/atlas_cloud.rs)
• Duplicated block (6 lines × 2) (crates/koharu-app/src/commands/project.rs)
• Duplicated block (9 lines × 4) (crates/koharu-pipeline/src/stages/inpainting.rs)
• FileTooLong: editor/PageRail.tsx (packages/koharu/components/editor/PageRail.tsx)
• Hotspot: crates/koharu-app/src/commands/agent/host.rs (crates/koharu-app/src/commands/agent/host.rs)
• Hotspot: crates/koharu-app/src/commands/project.rs (crates/koharu-app/src/commands/project.rs)
• Hotspot: crates/koharu-canvas/src/web.rs (crates/koharu-canvas/src/web.rs)
• Hotspot: crates/koharu-llama/src/context/params.rs (crates/koharu-llama/src/context/params.rs)
• Hotspot: crates/koharu-ml/src/bin/pp_doclayout_v3.rs (crates/koharu-ml/src/bin/pp_doclayout_v3.rs)
• Hotspot: crates/koharu-pipeline/src/stages/detection.rs (crates/koharu-pipeline/src/stages/detection.rs)
• Hotspot: crates/koharu-rasterizer/src/compositor.rs (crates/koharu-rasterizer/src/compositor.rs)
• Hotspot: crates/koharu-runtime/src/hardware/hip/linux.rs (crates/koharu-runtime/src/hardware/hip/linux.rs)
• Hotspot: crates/koharu-scene/src/change.rs (crates/koharu-scene/src/change.rs)
• Hotspot: crates/koharu-scene/src/patch.rs (crates/koharu-scene/src/patch.rs)
• Hotspot: crates/koharu-torch/src/tensor/npy.rs (crates/koharu-torch/src/tensor/npy.rs)
• …and 9 more

• Dependency source pinned to a moving git ref
• Duplicated block (24 lines × 5) (crates/koharu-translator/src/remote/deepseek.rs)
• Duplicated block (9 lines × 4) (crates/koharu-pipeline/src/stages/inpainting.rs)
• FileTooLong: src/bubble.rs (crates/koharu-renderer/src/bubble.rs)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• Hotspot: packages/koharu/components/controls/FontPicker.tsx (packages/koharu/components/controls/FontPicker.tsx)
• Hotspot: packages/koharu/components/controls/ModelPicker.tsx (packages/koharu/components/controls/ModelPicker.tsx)
• Hotspot: packages/koharu/components/controls/OutputPicker.tsx (packages/koharu/components/controls/OutputPicker.tsx)
• Hotspot: packages/koharu/components/editor/AgentPanel.tsx (packages/koharu/components/editor/AgentPanel.tsx)
• Hotspot: packages/koharu/components/editor/CanvasOverlay.tsx (packages/koharu/components/editor/CanvasOverlay.tsx)
• Hotspot: packages/koharu/components/editor/PageRail.tsx (packages/koharu/components/editor/PageRail.tsx)
• Medium CVE: [GHSA redacted] (bun.lock)
• Medium CVE: [GHSA redacted] (bun.lock)
• Medium vulnerability: RUSTSEC-2026-0285 (Cargo.lock)
• Members sharing a duplicated core (5 members, 50+ identical tokens) (crates/koharu-translator/src/remote/deepseek.rs)
• ModelPicker.ModelPicker (cognitive 24) (packages/koharu/components/controls/ModelPicker.tsx)
• ModelPicker.ModelPicker (cyclomatic 27) (packages/koharu/components/controls/ModelPicker.tsx)
• Off the main sequence: @koharu/ui
• …and 22 more

• 27 commits — 16 feature/other, 11 fixes

• (root) — 14 commits
• packages/koharu — 4 commits
• .github/workflows — 3 commits
• .github/sponsorkit — 2 commits
• crates/koharu-app — 2 commits
• crates/koharu-renderer — 1 commit
• crates/koharu-translator — 1 commit

• fix: Revert "fix(ci): recover incomplete release asset uploads"
• fix: chore(deps): use upstream Tauri plugins after updater fix
• fix: fix(app): skip Windows store configuration in debug builds
• fix: fix(canvas): preserve authored text rotation
• fix: fix(ci): install GTK 4 for Tauri v3
• fix: fix(ci): recover incomplete release asset uploads
• fix: fix(deps): align gpu-allocator Windows bindings
• fix: fix(deps): pin patched updater for macOS
• fix: fix(desktop): force X11 ozone platform for Linux CEF (#1110)
• fix: fix(renderer): preserve joined balloon text placement
• fix: fix(translator): cache model-listing client with five-second timeout (#1103)
• change: chore(deps): pin latest Tauri v3 and plugins commits
• change: chore(deps): track hf-hub main branch
• change: chore(deps): update Tauri CEF to 3.0.0-alpha.2
• change: chore(deps): upgrade Tauri to v3 alpha
• change: chore(deps-dev): bump @types/node from 26.4.0 to 26.5.0 (#1081)
• change: chore(release): 0.83.0
• change: chore(release): 0.83.1
• change: chore(release): 0.83.2
• change: chore(release): 0.83.3
• …and 7 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

koharu-rs/koharu was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.