En plattform, 1 930 algoritmer, alla backends: så byggde vi den kompletta stacken för diskret AI
Fragmenteringsproblemet
Din AI-utvecklingsmiljö är fragmenterad.
Du prototypar i PyTorch eftersom forskare föredrar det. Du distribuerar med TensorFlow eftersom produktions team vill ha Googles verktyg. Du skriver CUDA-kärnor för NVIDIA GPU:er. Du porterar till ROCm för AMD-hårdvara. Du skriver om allt för mobilt med TensorFlow Lite eller Core ML. Du använder ONNX för att konvertera mellan ramverk, i hopp om att inget går sönder. Du underhåller separata kodbaser för moln, edge och webbläsardistribution.
Tio olika verktyg. Tusentals beroenden. Mardrömmar med versionskompatibilitet. Brytande ändringar varje releasecykel.
Uppdatera PyTorch? Hoppas att din CUDA-version matchar. Vill du distribuera på AMD? Skriv om dina kärnor. Behöver du inferens i webbläsaren? Börja om med WebAssembly. Byter du från NVIDIA till AMD GPU:er? Lycka till med att portera den kodbasen. Distribuerar du på FPGA:er? Lär dig en helt annan verktygskedja.
Denna fragmentering är ingen olycka. Det är det naturliga resultatet av att varje ramverk optimerar för sitt specifika användningsfall samtidigt som interoperabilitet ignoreras. PyTorch utmärker sig inom forskning men behandlar distribution som en eftertanke. TensorFlow riktar in sig på produktion, men forskningsupplevelsen är plågsam. CUDA låser in dig i NVIDIA-hårdvara. Varje verktyg löser ett problem samtidigt som det skapar tre till.
Det finns ett bättre sätt.
Dweve Core: Den kompletta plattformen för diskret AI
Dweve Core är en enhetlig plattform för att bygga diskreta neurala nätverk från binär till 8-bitars precision. Det är inte ännu ett ramverk. Det är en komplett ersättning för din fragmenterade stack.
En installation. Ett API. En kodbas. Automatisk distribution till CPU, GPU, FPGA, WebAssembly, var du än behöver köra.
Så här betyder komplett:
1 930 algoritmer som täcker varje operation du behöver:
- 415 primitiver: Atomära operationer som XNOR, popcount, bitmanipulering, kvantisering, konvertering mellan format
- 500 kärnor: Optimerade sammansatta operationer för vanliga mönster
- 191 lager: Kompletta byggstenar för neurala nätverk (konvolution, täta, normalisering, aktivering, attention)
- 674 algoritmer: Hög nivå metoder inklusive transformeringar, träningsprocedurer, evolutionär sökning, kunskapsdestillering
- 30 interoperabilitetsverktyg: Valfria flyttalsbryggor för hybridmetoder
- 120 modellarkitekturer: Föroptimerade nätverksmallar från ResNets till Transformers
Detta är inte en delmängd. Det är matematisk fullständighet. Vi analyserade varje större neural nätverksarkitektur och byggde varje operation de kräver, optimerad för diskret beräkning från första principerna.
6 backendar med automatisk kompilering:
- SIMD CPU: Handoptimerade kärnor för x86 och ARM med automatisk ISA-detektering (SSE2, AVX2, AVX-512, NEON, SVE/SVE2)
- CUDA: NVIDIA GPU-optimering med warp-nivå primitiver och Tensor Core-utnyttjande
- Rust-HDL: Direkt FPGA- och ASIC-syntes från algoritmbeskrivningar
- WebAssembly: Inferens i webbläsaren med SIMD128-stöd för GDPR-kompatibel bearbetning på enheten
- ROCm: AMD GPU-optimering med wavefront-nivå operationer
- Metal: Apple Silicon-optimering med enhetlig minnesarkitektur
6 bitbredder med adaptiv precision:
- Binary (1-bit): Maximum efficiency with 16× compression versus FP16
- Ternary: {-1, 0, +1} with explicit sparsity
- 2-bit: Four levels for balanced compression
- 3-bit: Eight levels for quality-sensitive layers
- 4-bit: Sixteen levels approaching FP16 quality
- 8-bit: Near-full-precision for critical operations
The platform learns optimal bit-width per layer during training through gradient-based selection. Not heuristics. Not guesswork. Actual optimization based on how accuracy improves with added precision.
Write once, deploy everywhere
The platform uses a declarative Rust API. You describe what you want, the compiler figures out how to run it optimally on your target hardware.
Example network definition:
let model = NetworkBuilder::new()
.input(BinaryTensor::new([1024, 784]))
.dense(784, 512, activation=BinaryActivation::Sign)
.dense(512, 256, activation=BinaryActivation::Sign)
.output(256, 10)
.build();That's it. Write this once, and the compiler automatically generates optimized implementations for every backend.
The compilation pipeline works through four levels:
Level 1: Neural Network IR - Your high-level network description gets parsed into a computational graph with operations, data flow, and hyperparameters.
Level 2: Graph Optimization - Standard compiler passes eliminate dead code, fold constants, deduplicate expressions, and fuse sequential operations. A dense layer followed by batch normalization and activation becomes a single fused kernel that loads input once and produces final output.
Level 3: BitOps Dialect - The graph lowers to bit-level operations explicitly typed with precision. This intermediate representation is hardware-agnostic but close to actual machine operations. Built on MLIR (Multi-Level Intermediate Representation) infrastructure for industrial-strength optimization.
Level 4: Hardware Lowering - Final code generation produces platform-specific implementations. For AVX-512, bit operations become VPXORQ and VPOPCNTQ instructions. For CUDA, they become warp-level intrinsics with coalesced memory access. For FPGA, they become XNOR gates and adder trees synthesized to Verilog.
The same source code runs on your laptop CPU during development, deploys to cloud GPUs in production, and compiles to FPGAs for deterministic real-time inference. No translation. No porting. No platform-specific code.
Built for customers to build with
Dweve Core powers Dweve Loom, our constraint-based reasoning system. But it's not just for us. It's a complete platform for anyone building discrete neural networks.
You can build:
- Custom architectures using the 191 layer types and 674 algorithms
- Domain-specific models optimized for your exact requirements
- Hybrid approaches mixing discrete and continuous computation via the 30 interop utilities
- Novel training methods using evolutionary search, knowledge distillation, or custom gradient estimators
The platform provides:
Complete training infrastructure: Six straight-through estimator variants for binary/ternary gradient flow. Binary-aware optimizers that maintain full-precision weights internally while binarizing for forward passes. Automatic bit-width selection through gradient-based optimization. Progressive multi-stage distillation from FP32 through INT8, INT4, ternary, to binary.
Automatic hardware optimization: Runtime detection of CPU capabilities (CPUID on x86, system registers on ARM) and automatic dispatch to fastest available SIMD implementation. GPU kernel variants selected based on warp size, shared memory, and register count. FPGA synthesis with automatic pipeline register insertion based on timing constraints.
Flexible quantization: Symmetric and asymmetric quantization with per-tensor, per-channel, or per-group scales. Dynamic quantization with runtime range detection or static quantization with pre-computed scales from calibration data. MSE-optimal and KL-divergence-based scale computation for minimal accuracy loss.
Why discrete computation matters
Traditional neural networks compute everything in 16-bit or 32-bit floating point, then make discrete decisions at the end. We operate directly in discrete space from binary to 8-bit, eliminating intermediate continuous computation.
This isn't simple quantization of existing models. The framework is architected from first principles around discrete operations:
Hardware reality: Modern processors consist of billions of transistors in two states. An XNOR gate requires 6 transistors. A 32-bit floating-point multiplier requires thousands and consumes orders of magnitude more energy. Discrete operations align with hardware fundamentals.
Memory efficiency: Binary weights pack 64 values per 64-bit word. A ResNet-50 with 25.6 million parameters occupies 3.1MB in binary versus 50MB in FP16. The entire model fits in CPU L3 cache (typical: 36-64MB). You become compute-bound instead of memory-bound.
Deployment flexibility: Small models enable on-device inference. No cloud dependency. No network latency. No data privacy concerns. Process sensitive information entirely on user devices without ever transmitting to servers.
The complete algorithm matrix
The platform provides comprehensive coverage across three dimensions: algorithms, backends, and bit-widths.
Fundamental operations (415 primitives):
- 46 bitoperationer: logiska grindar, manipulation, skift, räkning, sökning
- 16 fältoperationer: extrahera, deponera, packa, strö, samla, maskgenerering
- 25 reduktioner: logisk AND/ELLER/XOR, aritmetisk summa/produkt, röstning och konsensus
- 17 distansmått: Hamming, Jaccard, Dice, Tanimoto, cosinus, Manhattan, euklidiskt
- 12 interfolieringsoperationer: 2-vägs till 4-vägs interfoliering, Morton- och Hilbert-rymdfyllnadskurvor
- 44 aritmetik: addition, subtraktion, multiplikation, division, fixed-point-operationer
- 39 transformeringar: Walsh-Hadamard, FFT, DCT, NTT, wavelets (Haar, Daubechies, CDF97)
- 11 hashning: SHA-256, Blake3, xxHash, MinHash, SimHash, lokalitetskänslig hashning
- 22 slumpgenerering: LFSR, Mersenne Twister, ChaCha20, Sobol-sekvenser
- 15 kvantisering: symmetrisk, asymmetrisk, per-tensor, per-kanal, skalberäkning
- 30 binärmatematik: XNOR-popcount, ternär kodning, viktuppdateringar, gradientoperationer
- 48 formatkonverteringar: FP32/FP16/FP8/INT8/INT4/INT2-konverteringar i alla riktningar
- 42 fixed-point-operationer: aritmetik, transcendenta funktioner, mättnad över alla bitbredder
Sammansatta operationer (500 kärnor):
Optimerade kärnor som kombinerar primitiver för vanliga mönster. Matrismultiplikationsvarianter (standard, transponerad, blockerad). Konvolutionstyper (2D, 3D, depthwise, grupperad, dilaterad). Normalisering (batch, lager, grupp, instans). Aktiveringsfunktioner (sign, hard tanh, styckvis linjär). Attention-mekanismer (self-attention, cross-attention, multi-head). Pooling (max, genomsnitt, stokastisk).
Nätverkslager (191 lager):
Kompletta byggstenar för att konstruera nätverk. Dense-lager med binära, ternära och multi-bit-vikter. Konvolutionslager med alla vanliga varianter. Recurrent-lager (LSTM, GRU med binära grindar). Attention-lager (skalad punktprodukt, multi-head, relativ position). Normaliseringslager med batchstatistik och inlärda parametrar. Residualkopplingar med dimensionsmatchning.
Högnivåalgoritmer (674 algoritmer):
Kompletta metoder för träning, inferens och optimering. Kunskapsdestillering med progressiv flerstegsförfining. Evolutionär begränsningsupptäckt med genetisk programmering. Neural arkitektursökning för diskreta nätverk. Gradientestimatorer (straight-through, klippt, adaptiv, momentum, hypernetwork). Optimerare (BinaryAdam, TernaryAdam, adaptiv kvantisering). Distribuerad träning med bysantinsk robust aggregering.
Djup i backendimplementeringen
Varje algoritm finns i flera optimerade varianter per backend. Inte generiska implementationer. Hårdvaruspecifik kod som utnyttjar varje arkitektonisk funktion.
CPU-SIMD: SSE2 ger universell x86-64-kompatibilitet (varje processor sedan 2001). AVX2 ger 4-8× snabbare prestanda på Haswell och nyare (2013+). AVX-512 når 10-16× med maskregister för predikation och VPTERNLOG för valfri 3-ingångars boolesk funktion. NEON ger 3-4× snabbare prestanda på alla ARMv8-processorer, inklusive mobila enheter och Apple Silicon. SVE/SVE2 ger vektorlängdsagnostisk kod som automatiskt utnyttjar bredare vektorer på nyare hårdvara.
CUDA: Warp-level primitives organize 32 threads executing in lockstep. Each thread processes 32 binary values packed in uint32. Full warp processes 1,024 binary values in parallel. Hardware intrinsics include __popc for population count, __ballot_sync for warp voting, __shfl_sync for fast communication without shared memory. Coalesced memory access ensures bandwidth utilization. Tensor Core utilization for matrix operations even with binary data.
Rust-HDL: Direct hardware synthesis from annotated Rust code. The framework generates Verilog/VHDL automatically. Binary XNOR-popcount operations map to XNOR gates (combinatorial logic, zero propagation delay) plus adder trees. Pipeline registers inserted automatically based on timing constraints. Synthesizes to both FPGAs (Xilinx, Intel) and ASICs.
WebAssembly: SIMD128 provides 128-bit vector operations in all modern browsers (Chrome 91+, Firefox 89+, Safari 16.4+). Operations include v128.and/or/xor for bitwise logic and i8x16.popcnt for population counting. Combined with Web Workers for multi-threading and SharedArrayBuffer for shared memory, achieves 60-80% of native CPU performance. On-device browser inference enables GDPR-compliant processing without server uploads.
ROCm: Wavefront-level optimization for AMD architectures with 64 threads per wavefront (double NVIDIA's 32). Each thread processes 32 binary values for 2,048 values per wavefront. Similar intrinsics to CUDA with __builtin_popcount, __ballot, and ds_swizzle. Programming model close enough that CUDA developers can write ROCm code immediately.
Metal: Apple Silicon optimization using unified memory architecture where CPU and GPU share physical RAM with cache coherency. Eliminates data copying overhead. Binary operations leverage Apple's custom matrix engines. M3 Max Neural Engine delivers 50-80 TOPS on binary inference using dedicated accelerators built into the SoC.
What we don't do (and why focus matters)
Important to clarify: we don't do everything. Focus enables excellence.
No floating-point inference: Discrete computation only from binary to 8-bit. If you need FP32/FP16/BFloat16 for deployment, use PyTorch or JAX instead. We optimize exclusively for discrete operations, enabling specializations impossible with mixed-precision floating-point. You can't be excellent at everything. We chose discrete AI and optimized ruthlessly.
No dynamic inference graphs: Models compile to static graphs for deployment. Training supports dynamic computation (necessary for research flexibility), but production inference is static. This enables ahead-of-time optimization: kernel fusion across entire network, memory layout optimization with known tensor shapes, prefetch instruction insertion with predictable access patterns.
Focused data preprocessing: We provide 8 specialized algorithms for neural network input preparation (normalization, adaptive scaling, learned quantization, binary augmentation), not general-purpose ETL. For feature engineering pipelines and data loading, use existing tools (Pandas, Polars, DuckDB). We're excellent at discrete neural network inference from binary to 8-bit. We're not replacing your entire data stack.
These aren't limitations. They're focus. By constraining scope to discrete neural networks with static inference graphs, we achieve optimization depth that comprehensive frameworks can't match.
Building on Dweve Core
The platform is ready to use. You can start building discrete neural networks today.
Complete toolchain:
- Deklarativt API: Rust-DSL med NetworkBuilder för modelldefinition
- Kompilatorinfrastruktur: MLIR-baserad optimeringspipeline med fyra IR-nivåer
- Träningsramverk: Sex STE-varianter, binärmedvetna optimerare, automatisk bitbreddsväljare
- Backend-kodgeneratorer: C med intrinsics för CPU, CUDA/HIP-kärnor för GPU, Verilog för FPGA
- Distributionsverktyg: Export till ONNX, Core ML, TensorFlow Lite eller fristående binärfiler
Exempel på arbetsflöde:
1. Definiera ditt nätverk med NetworkBuilder
2. Träna med binärmedvetna optimerare och adaptiv bitbreddsväljare
3. Kompilera till målmaskinvara med automatisk backend-väljare
4. Distribuera som optimerad binärfil eller exportera till standardformat
5. Kör var som helst: molnservrar, edge-enheter, webbläsare, FPGA:er
En plattform. En kodbas. Alla backends. Komplett diskret AI.
Sluta jonglera med tio ramverk. Sluta skriva om kod för varje distributionsmål. Sluta kämpa med versionskompatibilitet. Bygg en gång på Dweve Core och distribuera överallt.
Dweve Core driver Dweve Loom, vårt begränsningsbaserade resonemangssystem som lanseras 2026. Ramverket implementerar hela stacken med 1 930 algoritmer över 6 backends med adaptiv multibitkvantisering från binär till 8 bitar. Byggt av ett nederländskt ingenjörsteam under tre års utveckling.