google/magika
62.0
Adequate · 27 October 2026
17.3k
lines of production code
Rust
with Python, TypeScript
4
measurements over time
What this system is
Magika is a high-performance file content-type identification system that leverages machine learning models and rule-based engines to classify files. It provides a unified API across multiple languages—including Python, Rust, Go, and JavaScript—allowing applications to infer file types from byte streams or paths with configurable confidence thresholds. The system supports various inference backends, including CPU and GPU acceleration, and offers both command-line and library interfaces for integration into diverse software environments.
How it got here
2024 — Multi-language engine migration and restructuring
31 changes.
This period focused on migrating the core inference engine from Python/ONNX to native Rust via PyO3, introducing dedicated Go and JavaScript libraries, and modernizing the Rust CLI with a Tract runtime. The work involved significant internal restructuring, including API overhauls, dependency initialization, and the addition of new model variants and comprehensive test suites across all language bindings.
2025–2026 — Runtime expansion and documentation overhaul
15 changes.
This period focused on expanding Magika's execution environments by introducing a high-performance Tract inference runtime, C API bindings, and Python wrappers, alongside a pure-Rust rule-based detection engine. Concurrently, the project modernized its public presence with a new Astro-based documentation website and automated the maintenance of its content type knowledge base.
Features
Add standard\_v2\_0 file detection model
Introduces the 'standard\_v2\_0' model for file type detection, including its configuration, metadata, and a comprehensive list of supported content types (such as PDF, DOCX, ZIP, and various code formats) in the documentation.
_assets/models/standard\_v2\0 · high confidence
Add standard\_v2\_1 file identification model
A new file identification model named 'standard\_v2\_1' has been added to the assets directory. This model supports a comprehensive list of content types, including code files (C, C++, Java, Python, etc.), documents (PDF, Office formats), archives, and media files. The configuration specifies a block size of 4096, a medium confidence threshold of 0.5, and specific high-confidence thresholds for 'latex' and 'pascal' types. Metadata and a README documenting the supported content types are also included.
_assets/models/standard\_v2\1 · high confidence
Add standard\_v3\_1 model assets
Added the standard\_v3\_1 model configuration, including its documentation, minimal configuration file (config.min.json), and metadata. The configuration defines a target label space of 181 file types, sets specific confidence thresholds for certain labels (e.g., 0.95 for ignorefile and pascal), and maps random inputs to 'unknown' or 'txt'.
_assets/models/standard\_v3\1 · high confidence
Added JavaScript usage examples for browser and Node.js environments
New example projects have been added to demonstrate how to integrate Magika in different JavaScript environments. This includes a browser-based example using ES modules with Playwright for testing, Node.js examples using both CommonJS and ES module syntax, and a TypeScript ES module example. These examples show how to initialize the Magika model and identify file types from byte data in each context.
_js/simple\examples · high confidence
Added begonly\_v2\_1 and fast\_v2\_1 model variants
New model configuration files have been added for the 'begonly\_v2\_1' and 'fast\_v2\_1' variants. The 'begonly\_v2\_1' model is configured with a 2048-byte beginning context and no mid/end context, while the 'fast\_v2\_1' model uses a 512-byte beginning and 512-byte ending context. Both variants share the same extensive target label space (covering file types like code, documents, and archives) and specific confidence thresholds for LaTeX and Pascal, providing users with additional options for file type detection based on different context window sizes.
_assets/models/begonly\_v2\_1, assets/models/fast\_v2\1 · high confidence
Added standard\_v3\_3 model configuration and documentation
A new model version, standard\_v3\_3, has been introduced in the assets/models directory. This update includes the model's configuration file (config.min.json), which defines parameters such as input sizes, block size, and a comprehensive list of target file types and confidence thresholds, along with its associated documentation (README.md) and metadata (metadata.json).
_assets/models/standard\_v3\3 · high confidence
Automated generation of content types knowledge base
A new Python script (scripts/sync\_kb.py) has been added to generate the content types knowledge base (assets/content\_types\_kb.min.json) from a human-editable YAML source (assets/content\_types.yaml). This script validates the YAML structure, derives rule coverage and ML model inclusion flags from YARA rulesets and model configuration, and outputs the final JSON artifact consumed by bindings, ensuring the knowledge base stays synchronized with source definitions.
scripts · high confidence
Initial release of the Magika Rust CLI
Introduces the \magika-cli\ binary, a command-line interface for file content type detection using AI. The CLI supports recursive directory traversal, symbolic link handling, and multiple output formats including text, JSON, JSONL, and custom formats. It features true color support, configurable inference backends (CPU/GPU), and robust error handling for non-regular files, permission errors, and directory cycles. The tool is built with a standalone inference runtime (replacing ONNX Runtime) and includes comprehensive tests for stability.
rust/cli · high confidence
Introduce Go library for Magika content-type inference
Adds a new Go module (\github.com/google/magika/go/magika\) that allows Go applications to infer file content types using the Magika ONNX model. The library handles feature extraction and delegates inference to the ONNX Runtime via cgo, exposing a \Scanner\ API for scanning byte streams. A CLI tool and example code are included to demonstrate usage, along with a Dockerfile for building a containerized environment with the required ONNX Runtime dependencies.
go · high confidence
Introduce PyO3 wrapper for Magika Python library
Adds a new PyO3-based Python binding for the Magika file-type identification library. This wrapper exposes a global runtime singleton and provides Python-accessible classes for content type information and detection results, enabling Python applications to leverage Magika's inference capabilities directly.
rust/pyo3 · high confidence
Introduce new Astro-based documentation website
The website-ng directory now contains a complete, new static site built with Astro, Starlight, and Svelte. This replaces previous deployment configurations with a modern stack that includes Tailwind CSS for styling and shadcn-svelte for UI components. The site is configured to deploy to Google App Engine (Node.js 22 runtime) and includes a structured documentation sidebar covering introduction, installation, core concepts, CLI bindings, and contributing guidelines.
website-ng · high confidence
Introduce standard\_v3\_0 model with updated configuration and documentation
A new file-type detection model, standard\_v3\_0, is now available, featuring a comprehensive list of supported content types (including code, archives, documents, and media) and specific confidence thresholds for labels such as LaTeX, Markdown, and SQL. The model configuration defines input parameters like block size and padding, maps ambiguous inputs like random bytes to 'unknown', and is identified as major version 3 with 100 training epochs.
_assets/models/standard\_v3\0 · high confidence
Introduce standard\_v3\_2 model configuration and documentation
Added the standard\_v3\_2 model assets, including a configuration file (config.min.json) that defines model parameters such as input sizes, block size, and a comprehensive list of target file types, along with specific confidence thresholds and an overwrite map for unknown types. The update also includes a metadata file recording the model epoch and a README documenting the full list of supported content type labels.
_assets/models/standard\_v3\2 · high confidence
Introducing magika-rules: a pure-Rust file-type detection engine
The new magika-rules crate provides a bounded file-type detection engine implemented in pure Rust, evaluating a YARA-like rule subset over the first 4 KiB of an input. It ships with precompiled, enforced rules for identifying formats like APK, DOCX, XLSX, and PE executables, as well as facts about ZIP and PE structures. The engine is designed for safety and performance, containing no unsafe code, no native dependencies, and no global state, and it allows callers to map internal rule labels to their own content types.
rust/rules · high confidence
Major documentation overhaul and release infrastructure updates
The project has significantly expanded its documentation, replacing the minimal README with a comprehensive guide covering installation methods (Homebrew, pipx, cargo, npm), usage examples, and links to the research paper and web demo. A CITATION.cff file has been added to facilitate proper academic referencing. Additionally, the release process for the Rust CLI has been modernized by adopting cargo-dist for generating installers and managing CI, while a new Dockerfile provides a secure, non-root containerized environment for the Python package.
(repo-wide) · high confidence
New C API bindings for the Magika library
The Magika Rust library is now exposed as a C library, providing static and dynamic binaries along with a C99/C++ compatible header. This enables C and C++ applications to integrate Magika's file identification capabilities directly, supporting both file path and in-memory buffer analysis with configurable options for rules, model inference, and hardware backends. Also in this area: Added option to enable or disable resolvers in Magika; Introduce shared fast pipeline for parallel file identification; Refined file type identification returns specific regular file metadata; Fix incorrect metadata for AVIF, Fortran, OneNote, SWF, and Tcl.
rust/ffi · high confidence
New Python development and release tooling scripts
Added a suite of scripts in python/scripts to support the new PyO3-based Python package. This includes build\_and\_stage\_cli.sh and build\_wheel.sh for compiling and bundling the native Rust CLI binary into the wheel, sync.py for generating content-type labels, and various testing utilities (run\_quick\_test\_magika\_cli.py, run\_quick\_test\_magika\_module.py, test\_magika\_model.py) for validating predictions and performance. It also introduces pre\_release\_check.py for version consistency verification, check\_copyright.py for license header enforcement, and check\_changelog.sh for release documentation checks.
python/scripts · high confidence
New Rust code generator for library and CLI assets
A new \rust/gen\ crate has been introduced to automate the generation of Rust source files for the library and CLI. This tool reads the model configuration and content-type knowledge base to produce \content.rs\ and \model.rs\, ensuring that the generated code stays synchronized with the underlying model (currently linked to \standard\_v3\_3\). The generator also creates FFI bindings and headers, and includes a test script to verify that the generated code is up-to-date and passes linting checks.
rust/gen · high confidence
New TypeScript type definitions and model configuration classes for Magika JS
The \js/src\ directory now includes a comprehensive set of TypeScript interfaces and classes that define the core data structures and configuration loading for the Magika JavaScript library. This adds explicit type definitions for content types (\ContentTypeLabel\, \ContentTypeInfo\), prediction results (\MagikaPrediction\, \MagikaResult\), and operational states (\Status\, \PredictionMode\, \OverwriteReason\). It also introduces the \ModelConfig\ and \ModelFeatures\ classes, which handle the parsing of model configuration files and the preparation of input data for the TensorFlow.js model, enabling the JS implementation to correctly interpret and execute the underlying machine learning model.
js/src · high confidence
Rust CLI and library infrastructure and release tooling
This change introduces the foundational structure and tooling for the Rust implementation of Magika. It adds the \cli\, \lib\, \tract-runtime\, and \gen\ crate directories, along with shell scripts (\publish.sh\, \sync.sh\, \test.sh\, \latest.sh\, \changelog.sh\) to automate publishing to crates.io, synchronizing generated files and models, running tests, and managing the \cli-latest\ release. It also includes the \tract-bench\ crate with utilities to convert ONNX models to NNEF, verify model accuracy, and benchmark inference throughput, alongside configuration files for formatting and linting.
rust · high confidence
Removals
Removal of the legacy CLI entry point
The main CLI script at magika/cli/magika.py has been deleted. This removes the command-line interface that previously allowed users to identify file types via arguments for options like JSON output, MIME types, labels, and model directory selection.
magika-python-package/magika/cli · high confidence
Behavioural changes
1 commit (0 fixes) modifying tests\_data/previous\_missdetections
A change to existing behaviour in tests\_data/previous\_missdetections — 1 commit, 1 file.
_tests\_data/previous\missdetections · low confidence · unverified
Installer scripts now redirect to the latest release versions
The website now serves dynamic redirect pages for the shell and PowerShell installer scripts. Visiting the install.sh or install.ps1 endpoints will no longer serve a static file; instead, users are immediately redirected (302) to the latest versions of the installer scripts hosted in the GitHub releases (cli-latest). This ensures users always download the most recent installer without needing to update their bookmarks or scripts.
website-ng/src/pages · high confidence
Introduce embedded Tract inference runtime for Magika
The Magika library and CLI now use a new embedded Tract inference runtime instead of ONNX Runtime. This runtime loads the model from a pre-parsed graph (model.graph.json) rather than parsing an NNEF archive at startup, reducing load time from approximately 14 ms to 3 ms. It supports fixed batch sizes (1, 4, 8, 16, 32, 64) and prepares target-specific execution plans once at startup, allowing inference threads to spawn private mutable state from those shared plans. The runtime supports automatic, CPU, or GPU device selection (with Metal on macOS and optional CUDA support), and includes a startup health check on GPU devices to verify plan correctness against CPU references.
rust/tract-runtime · high confidence
Legacy website redirects to new site while preserving model URL compatibility
The legacy website now redirects users to the new Magika website, but continues to serve the \standard\_v3\_2\ TensorFlow.js model files (including \config.min.json\, \metadata.json\, and \model.json\) from the \public/models/standard\_v3\_2\ directory. This ensures that existing integrations relying on the old model URLs remain functional for backwards compatibility with early Magika versions, even though the main site experience has moved.
website · high confidence
Magika Python library restructured with PyO3 backend and new API types
The Magika Python library has been restructured to use a PyO3-based Rust backend, introducing a new \Magika\ class with methods like \identify\_path\, \identify\_paths\, and \identify\_bytes\. The public API now exposes new types such as \MagikaPrediction\, \MagikaResult\, \OverwriteReason\, and \PredictionMode\, replacing previous output structures. The default model has been updated to \standard\_v3\_3\, and the library now supports a \no\_dereference\ option to avoid following symlinks. Internal logging has been simplified to use a custom \SimpleLogger\ writing to stderr, and the package is now marked as typed with \py.typed\.
python/src/magika · high confidence
MagikaJS 1.1.0: Node.js 20+ requirement and dual CJS/ESM module support
The Magika JavaScript library has been updated to version 1.1.0, which now requires Node.js 20 or later due to the end-of-life of Node 18. This release also introduces dual CommonJS (CJS) and ECMAScript Module (ESM) support, allowing the library to be imported correctly in both module systems. The package structure now includes separate \dist/cjs\ and \dist/mjs\ directories with corresponding \package.json\ files to facilitate this, alongside a TypeScript refactoring that organizes the codebase into \src/\ and exposes \Magika\ for browser use and \MagikaNode\ for Node.js environments.
js · high confidence
New global styles and list rendering fixes for the website
The website now uses a new global stylesheet that imports Tailwind CSS, Shadcn UI, and Animate.css, establishing a consistent design system with light and dark mode color variables. Additionally, list items within the \.sl-container\ class are now styled with standard bullet and decimal markers, while the table of contents navigation list remains unstyled to prevent visual clutter.
website-ng/src/styles · high confidence
New website (\#1169)
The website-ng public assets have been updated to include a new SVG favicon and a new file-type detection model (standard\_v3\_2). The model, converted to TensorFlow.js, introduces updated configuration parameters (such as block\_size and confidence thresholds) and a revised set of supported file extensions, which will change how the browser-based detection engine classifies files.
(repo-wide) · high confidence
Python API: Deprecation warnings and new prediction fields
The Python bindings now emit standard DeprecationWarning instances for legacy properties on ContentTypeInfo (ct\_label, magic) and raise AttributeError for the removed score field, guiding users to the updated API surface. Additionally, the MagikaPrediction dataclass now includes an overwrite\_reason field (OverwriteReason) to explain why the final output prediction may differ from the raw deep learning result.
magika · high confidence
Python package replaces ONNX Runtime with native Rust bindings via PyO3
The Python package now uses native Rust bindings (via PyO3) for inference, replacing the previous pure-Python ONNX Runtime implementation. This change removes runtime dependencies on \onnxruntime\, \click\, and \numpy\, resulting in significantly faster startup and inference speeds. The public API remains compatible, but the underlying engine is now the optimized Rust \magika\ crate.
python · high confidence
RAR MIME type corrected and model confidence thresholds tightened
The standard\_v1 model now correctly identifies RAR archives using the official \application/vnd.rar\ MIME type instead of the legacy \application/x-rar\. Additionally, the model's detection thresholds have been significantly raised for numerous file types (such as APK, HTML, PHP, and various Office formats), requiring higher confidence scores for positive identification, which generally reduces false positives at the cost of potentially lower recall for ambiguous files.
_assets/models/standard\v1 · high confidence
Refactored Python API types and models
The Python API's data models have been restructured into a dedicated \magika.types\ package, introducing new classes such as \MagikaResult\, \MagikaPrediction\, and \ContentTypeInfo\ to better represent scan outcomes and prediction details. This change includes the addition of an \OverwriteReason\ field to \MagikaPrediction\ to explain why the final output may differ from the raw deep learning result, and provides an \asdict()\ method on \MagikaResult\ for easy serialization. Additionally, several legacy properties on \ContentTypeInfo\ (such as \.ct\_label\, \.magic\, and \.score\) are now deprecated or removed, with users directed to use the updated model structure.
python/src/magika/types · high confidence
Removal of legacy model configuration and content type definitions
The \content\_types.py\ module, which defined the \ContentType\ and \ContentTypesManager\ classes along with the \content\_types\_config.json\ path, has been removed. The main \magika.py\ class no longer imports or instantiates \ContentTypesManager\, and the \model\_output\_overwrite\_map.json\ file (which previously mapped 'odex' to 'elf') has also been deleted. This indicates a significant internal restructuring where the previous content type mapping and model output override logic has been stripped out or moved to a different location not visible in this diff.
magika-python-package/magika · medium confidence
Reorganized test data files into the mitra\_candidates directory
Test data files, including mini.protobuf, html.htm, and mini.plist, have been moved or added to the tests\_data/mitra\_candidates directory. This reorganization groups these specific file types (protobuf, HTML, plist) together for candidate testing purposes.
_tests\_data/mitra\candidates · high confidence
Reorganized test data structure for Mitra
The test data directory for Mitra has been reorganized to group files by their expected content type (e.g., pdf, php, svg) within subdirectories. This change introduces new sample files for PDF, PHP, and SVG formats, replacing the previous flat structure to better align with content-type-based testing.
_tests\data/mitra · medium confidence
Rust library major version 2.0.0 with runtime and API overhaul
The Rust library has been updated to version 2.0.0, introducing significant breaking changes and new capabilities. The underlying inference engine has switched from ONNX Runtime to an embedded Tract runtime, removing the ONNX dependency and enabling GPU inference via a new \cuda\ feature. The public API has been simplified: the \Session\ type is replaced by a \Runtime\ for model preparation and per-thread session creation, async support is removed, and the \Builder\ now constructs a \Runtime\. New features include \ContentType::from\_label()\ for lookups by label, configurable inference backends (CPU/GPU), and batch processing that accepts an iterator of features. Small file reading during feature extraction has also been optimized to occur in a single pass.
rust/lib · high confidence
Rust library now uses Tract inference runtime and standard\_v3\_3 model
The Rust library has replaced the previous ONNX Runtime with an embedded Tract inference runtime, enabling CPU and GPU acceleration via the new \Backend\ and \Builder\ APIs. The underlying AI model has been updated to \standard\_v3\_3\, which includes new content type definitions, updated confidence thresholds, and an overwrite map to refine classification results.
rust/lib/src · high confidence
Updated PGP test samples in missdetection data
The PGP test samples previously located in the basic directory (key.pem and key.pub) have been moved to the current\_missdetections/pgp directory and renamed to doc.pem and doc.pub. This reorganization aligns the test data with the new prediction mode support, ensuring that these specific PGP files are correctly categorized for missdetection testing scenarios.
_tests\_data/current\missdetections · medium confidence
Test coverage
Added comprehensive test suite for Magika JS; Added comprehensive test suite for the Python module; Added custom YARA rule for PNG identification in test data; Expanded test dataset with new file format samples; Removal of Python CLI and module test suite; Removed test symlinks to internal package.
Dependencies
Initial dependency manifests for Go, Python, and Rust components
This change introduces the foundational dependency manifests for the Go, Python, and Rust parts of the project. The Go module (\go/go.mod\) is initialized with Go 1.22.3 and the \go-cmp\ library. The Python package (\python/pyproject.toml\) is configured for version 2.0.0.dev0, specifying support for Python 3.8 through 3.14 and defining development dependencies for testing and linting (mypy, pytest, ruff, etc.). The Rust components (CLI, library, FFI, rules, etc.) are initialized with their respective \Cargo.toml\ files and lock files, establishing the core dependencies for the AI-based content type detection engine.
(dependencies) · high confidence
Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.
Score
- CAI 61 → 62 (+1.1)
Lenses
- Code Health 74 → 74 (+0.4)
- Architecture 93 → 93 (+0.0)
- Maturity 56 → 67 (+10.5)
- Readiness 62 → 62 (+0.6)
- Security 63 → 68 (+4.5)
- Accessibility 64 → 56 (-8.3)
- Performance 100 (new)
Resolved (14)
- Both FileType and InferredType expose a method content_type() returning ContentType. While these are distinct types, the naming is identical despite potentially different semantic origins (FileType might be a parsed result, InferredType a model output). More critically, InferredType also has a property inferred_type: ContentType, which duplicates the return type of its method content_type(). This creates ambiguity: is inferred_type the same as content_type()?
- Documentation: no project overview (rust/gen/model/README.md)
- FileTooLong: src/main.rs (rust/cli/src/main.rs)
- FunctionTooLong: magika_cli::main (rust/cli/src/main.rs)
- High CVE: [GHSA redacted] (js/yarn.lock)
- InferredType exposes both a public property content_type of type String and a method content_type() returning ContentType. This is confusing: the property name shadows the method name, and the types differ (String vs ContentType), suggesting a legacy field or a mismatch in API design.
- Medium CVE: [GHSA redacted] (js/yarn.lock)
- Off-boarding risk: anonymized user #1
- PR-triggered workflow grants a write-scoped token
- The method names identify_file and identify_content are semantically overlapping. identify_content takes an Input trait object, which can represent a file. The distinction is not clear from the names alone. A user might wonder if identify_file is a specialized, faster path or if identify_content can also handle files. The naming suggests a file/content dichotomy that may not be strictly enforced or clear.
- magika_cli::main (cognitive 18) (rust/cli/src/main.rs)
- magika_cli::main (cyclomatic 20) (rust/cli/src/main.rs)
- magika_cli::print (cognitive 19) (rust/cli/src/main.rs)
- magika_cli::process_path (cognitive 18) (rust/cli/src/main.rs)
New (15)
- Duplicated block (7 lines × 2) (rust/lib/src/cached_input.rs)
- High CVE: [GHSA redacted] (website-ng/package-lock.json)
- High CVE: [GHSA redacted] (website-ng/package-lock.json)
- High CVE: [GHSA redacted] (website-ng/package-lock.json)
- High: security finding (details withheld)
- Medium CVE: RUSTSEC-2026-0383 (rust/tract-bench/Cargo.lock)
- Medium: security finding (details withheld)
- Off-boarding risk: anonymized user #1
- Off-boarding risk: anonymized user #2
- Orphaned file (go/magika/features.go)
- Orphaned file (go/magika/scanner.go)
- PR-triggered workflow grants a write-scoped token (.github/workflows/cli-release.yml)
- TodoComment (rust/lib/src/file.rs)
- Workflow token grant is wider than its jobs use (.github/workflows/js-docs-builder.yml)
- magika::pipeline::paths::process_path (cognitive 19) (rust/lib/src/pipeline/paths.rs)
Changes since last survey
- 27 commits — 24 feature/other, 3 fixes
By area
- (repo) — 10 commits
- rust/lib — 5 commits
- .github/workflows — 3 commits
- .github/CODEOWNERS — 2 commits
- assets/content_types.yaml — 2 commits
- rust/cli — 2 commits
- website-ng/src — 2 commits
- python/scripts — 1 commit
Notable commits
- fix: Merge pull request #1545 from shivamtiwari3/kb-fix-metadata-followup
- fix: kb: fix incorrect MIME types for asf and xlsb, and a dxf description typo
- fix: kb: fix incorrect group and description metadata (avif, fortran, one, swf, tcl)
- change: Add CachedInput to never read twice the same byte (#1550)
- change: Add back OverwriteReason (#1549)
- change: Add stubs for resolvers (#1557)
- change: Control each component individually from the CLI (#1559)
- change: Identify files with custom rules before the built-in rules (#1530)
- change: Merge pull request #1542 from google/gh-1451-ai-policy
- change: Merge pull request #1543 from shivamtiwari3/kb-fix-xlsb-asf-mime-dxf-typo
- change: Merge pull request #1546 from ia0/owner
- change: Merge pull request #1547 from google/adhoc-website-looks-good-but-bullet
- change: Merge pull request #1552 from ia0/features
- change: Merge pull request #1554 from ia0/owner
- change: Merge pull request #1555 from google/adhoc-check-this-out
- change: Merge pull request #1556 from google/adhoc-it-seems-we-don-t
- change: Merge pull request #1558 from google/adhoc-uv-lock-check
- change: Remove ia0 from owners of knowledge base
- change: Return more accurate type for identify_content
- change: Share the CLI's fast pipeline with Python and C through the library (#1531)
- …and 7 more
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
google/magika 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.
About this page
- The score is its most recent published measurement, taken on 27 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 8d3d3b9b9452a65a6aa7752e061a67bf4a6b3c9b — the exact code this score is about.
- Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
- Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.34+preprod-c12eef3a1477.