TinyML Compiler Platform & Consulting
1. Model Ingestion
Upload a model file to compile, or configure synthetic weight simulation parameters below.
2. Interactive Weight Map
Hover over weights to inspect values. High-variance outlier rows are isolated into INT8 channels; the remaining channels are quantized into packed 4-bit blocks.
Serialization Layer (2xINT4 → 1xByte)
3. Generated C++ Assets
Direct compilation output (`model_assets.h`) aligned at `alignas(4)` for bare-metal XIP execution.
// Click "Run Quantization Compiler" to generate C++ code...
Competitive Performance Benchmark
Quantitative analysis comparing MicroQuant vs. standard Google TensorFlow Lite for Microcontrollers (TFLu) across identical network operators.
Empirical Benchmark Table
| Metric | Google TFLite Micro | MicroQuant Profile A | Divergence / Savings |
|---|---|---|---|
| Static Flash Footprint | 8.00 KB | 5.46 KB | -31.69% Reduction |
| Dynamic Heap Allocation | Variable Arena | 0.0 KB (Zero-Alloc) | 100% Heap Saved |
| Latency (Inference Time) | 2.00 us | 1.40 us | 1.43x Speedup |
| Accuracy Baseline | 94.2% | 93.9% | -0.3% (Outlier Shielded) |
__SMUAD intrinsics to execute two 16-bit multiply-accumulate actions in a single clock cycle, achieving maximum speedup.
Footprint & Execution Graphs
Static Flash Weight Size (KB)
Inference Speedup Factor (Higher is Better)
Micro-Architectural Highlights & Hardening
- Dynamic Block-Wise Radix Scaling: Adapts scale shift n_b dynamically for each 32-element block to shield outlier variables without accumulator overflow.
- SWAR INT4 Unpacking: Employs Sub-Word Parallelism (SWAR) to load and unpack adjacent INT4 parameters into registers in parallel.
- Cortex-M SIMD MACs: Compiles into optimized parallel multiply-accumulates utilizing __SMUAD instructions.
- Padding Hardening: Zero interior struct padding bytes, with buffers padded to 64-byte lines for cache coherency.
HIL Cycle-Accurate Execution Trace
Open-Core Dual-Licensing Compliance Model
Understanding the interplay between Copyleft GNU AGPLv3 protection and Commercial enterprise exemptions.
Open-Source Copyleft Enforcement
The open-source C++ runtime engine is licensed under the Affero General Public License (AGPLv3).
- Source Code Reciprocity: If a developer incorporates the runtime engine into a product, they are legally required to open-source their entire product stack under the AGPLv3.
- Network Interaction Trigger: Even if executed on a server or remote network environment, access to modified source code must be provided to remote users.
- The Corporate Firewall: Corporate legal departments block AGPLv3 libraries in production systems, acting as a highly effective filter to funnel commercial licenses.
Commercial Licensing & Exemptions
For enterprise clients seeking to bypass the copyleft requirements, we offer a clean proprietary alternative.
- Copyleft Waiver: Removes all source code release requirements, enabling integration into proprietary closed-source firmware.
- Intellectual Property Shield: Strictly forbids reverse engineering of the compiler unpacking structures, securing your optimization algorithms.
- Indemnity & Support: Offers commercial grade guarantees and custom hardware target adaptation (DSP/SIMD).
Request Technical Architecture Evaluation
Need custom microcontroller optimizations, RISC-V/DSP assembly acceleration, or proprietary licensing? Schedule a deep-dive consulting review.
Enterprise Core Competencies
We convert edge-computing optimization from an engineering hurdle into a massive competitive advantage.
Assembly-Layer Custom Kernels
We write optimized vector wrappers using ARM CMSIS, RISC-V RVV, and custom Tensilica DSP intrinsics to maximize execution frequency.
Advanced PTQ & Outlier Balancing
We customize quantization channels based on activation outlier distributions, securing high classification precision under extreme integer scaling.
EULA Dual-Licensing Architecture
Seamlessly integrate our zero-allocation compiler pipeline into your commercial products without triggering copyleft requirements.