Sofia Engine

Scientific signal intelligence, on-device learning and an open model ecosystem.

Trained models · Architecture · Installation · Quickstart · Documentation

Developed by Rootcastle Engineering & Innovation

Explore the runtime ecosystem, integrations and packages

Model registry · Storage bucket · Wiki · npm package · REI SignalLab

---

Trained models · Sofia Distilled

Two downloadable research checkpoints now accompany the Sofia ecosystem. Sofia Distilled provides the training code, original data, model cards, measured baselines and public-download audits. These models are a separate companion package; they are not automatically registered as backends in this runtime.

	Sofia Edge	Sofia Chat
Model	Synthetic vibration classifier	Experimental English technical chat
Architecture	14 → 16 → 5 ReLU MLP	18-layer Qwen-derived transformer
Parameters	325	404,558,464
Distillation	Verified product-kernel ridge teacher → small MLP	Teacher-token KL + reference CE + product-kernel alignment
Published weights	NumPy .npz, approximately 2.86 kB	Merged FP16 .safetensors, approximately 809 MB
Download	Edge checkpoint ↗	Chat checkpoint ↗
Documentation	Edge model card	Chat model card

Important

Experimental checkpoints. Edge has no field diagnostic validation. Chat generates factual errors and inherits Qwen pretraining; it is not a foundation model pretrained from random initialization. The companion CLI exposes no machinery control interface. These release results do not establish industrial readiness or quantum computational advantage.

Measured results and evidence

Release measurement	Result	Scope
Edge test accuracy / balanced accuracy	99.933%	1,500 balanced synthetic vibration examples
Edge supervised-only control	100.000%	Same initialization, data and optimization budget; no distillation quality advantage claimed
Chat parameter reduction	18.11%	404,558,464 student versus 494,032,768 teacher parameters
Chat test reference perplexity	10,327.21 → 84.14	Pruned baseline versus distilled checkpoint on a narrow reference bank; not a factuality benchmark
Companion local test suite at v0.1.0	25 passed	Sofia Distilled tests; separate from this runtime's test suite
Kernel experiment rerun	810 arrays exactly equal	Independent same-environment rerun
Public release download audits	14 Edge + 22 Chat files	Downloaded bytes matched their SHA-256 digests, including full Chat weights

Browse the v0.1.0 release · Inspect experiment records · Read actual Chat test answers

Verifiable kernel principle

The companion experiments follow Quantum Artificial Intelligence with Verifiable Kernels, by Batuhan Ayribas (2026). Their product-rotation kernel has an efficient exact classical expression:

$$K_s(x,z)=\prod_{j=1}^{d}\cos^2\left(\frac{s(x_j-z_j)}{2}\right).$$

Edge uses this geometry in its ridge teacher. Chat adds a kernel representation-alignment penalty to token distillation. The numerical audits check classical/state-overlap equivalence, terminal-unitary invariance, global depolarization and matched ridge predictions; finite-shot SWAP estimates are evaluated separately. All computations use ordinary CPU/GPU hardware. The Chat alignment term is an engineering adaptation, not a transformer-quality result proved by the manuscript.

Scientific protocol and limitations →

flowchart LR
    E["Sofia Engine: signal intelligence runtime"] -.-> D["Sofia Distilled: separate training and inference package"]
    D --> M["Sofia Edge: synthetic signal evidence"]
    D --> C["Sofia Chat: experimental technical prose"]
    M --> A["Companion CLI: structured evidence + unverified explanation"]
    C --> A
    style E fill:#101e32,stroke:#64ead3,color:#e6edf7
    style D fill:#101e32,stroke:#60a5fa,color:#e6edf7
    style A fill:#17243a,stroke:#f1b971,color:#e6edf7

Loading

Try the companion models

git clone https://github.com/rootcastleco/sofia-distilled.git
cd sofia-distilled
pip install -e '.[hub]'
sofia-distilled edge --demo-class 3

For Chat dependencies, Hugging Face inference, the combined CLI and full training commands, follow the Sofia Distilled quick start.

---

Executive Overview

Sofia Engine is an engineering-grade, offline-first General Scientific AI & Edge Intelligence Runtime developed by Rootcastle Engineering & Innovation. Engineered for demanding scientific research and mission-critical assets—power distribution grids, particle physics instrumentation, high-speed turbomachinery, chemical plants, and autonomous robotics—Sofia provides a unified mathematical foundation that bridges raw physical telemetry, digital signal processing, quantum computing emulation, low-level assembly neural self-training, and automated LLM fine-tuning.

Sofia Engine is far beyond an industrial vibration monitor. Powered by algorithms from Rootcastle REI SignalLab and our high-performance computing labs, it integrates:

1. General Scientific AI & In-Situ Assembly Neural Self-Training (sofia_ai.learning.asm):
   • Register-Based Assembly Virtual Machine (SofiaAsmVM): 64-bit floating-point registers, fixed memory buffers, and vectorized SIMD instructions (VEC_DOT, VEC_FMA, VEC_SUB, ACT_RELU, UPDATE_SGD, COMPUTE_MSE).
   • Self-Training Neural Model (AssemblyNeuralNetwork): Compiles forward inference, loss calculation, backpropagation, and SGD parameter updates directly into virtual bytecode executed on-device without external ML frameworks.
   • Native Hardware Assembly Emitters: Emits optimized raw x86_64 AVX2, ARM Cortex-M Thumb-2, and WebAssembly (WAT) code for bare-metal microcontrollers and browser runtimes.
2. Automated LLM Fine-Tuning Pipeline (sofia_ai.learning.finetune):
   • Autonomous Dataset Curation (DatasetCurator): Curates edge telemetry, diagnostic events, and physical sensor traces into structured JSONL chat pairs with token estimation and validation.
   • Zero-Dependency Cloud/Edge Tuner (AutoFineTuner): Automated fine-tuning job submission, tracking, and checkpoint registration with NVIDIA NIM, OpenAI, and OpenRouter endpoints using Python standard library urllib.request.
3. Multi-Domain Industrial & Scientific Signal Processing (sofia_ai.signal):
   • Mechanical Vibration: ISO 10816/20816 severity, Welch PSD (Parseval energy-conserving), Hilbert analytic envelope, rotating machinery kinematics (BPFO, BPFI, BSF, FTF, Gear Mesh).
   • Electrical Power Quality (IEEE 519 / IEC 61000-4-30): Active/Reactive/Apparent Power ($P, Q, S$), Power Factor ($PF$), Total Harmonic Distortion ($\text{THD}_V, \text{THD}_I$ up to 50th harmonic), Fortescue 3-Phase Symmetrical Components ($V_0, V_1, V_2, VUF$), and Sag/Swell/Interruption event detection.
   • Acoustic Emission & Ultrasound (ASTM E1316): High-frequency transient energy, counts, duration, rise time, and cavitation intensity indexing for pumps and valves.
   • Thermal & Fluid Process Telemetry: Dynamic rate of change ($dT/dt$), thermal gradient, pressure pulsations, and water hammer transients.
   • Multi-Axis Inertial Dynamics (IMU): 3-axis acceleration vector magnitude ($|\mathbf{a}|$), dynamic tilt (pitch, roll), and dynamic jerk ($d\mathbf{a}/dt$).
4. Advanced Quantum Computing Emulation (sofia_ai.quantum):
   • Complex statevector simulation in $\mathbb{C}^{2^n}$ with unitary evolution.
   • Universal gate library: Hadamard ($H$), Pauli ($X, Y, Z$), Phase ($S, T$), Parametric Rotations ($R_x, R_y, R_z$), and Entangling Gates ($CX, CZ$).
   • Quantum Feature Maps (Angle & Amplitude encoding) and Quantum Kernel Estimation ($K(x, y) = |\langle \psi(x) | \psi(y) \rangle|^2$) for quantum-enhanced machine learning.
5. AI Copilot & Technical Decision Support (sofia_ai.copilot):
   • Multi-provider AI reasoning engine supporting NVIDIA NIM (api.nvidia.com), OpenRouter (openrouter.ai), and deterministic offline fallback.
6. Deterministic Safety Gate (PolicyEngine):
   • Strict default DENY state machine. Inference and RL models cannot actuate machinery without passing allowlists, operator authorization, interlocks, and Nonce/TTL replay defense.
7. Universal Multi-Language Runtime:
   • Python Core: Zero runtime dependencies beyond NumPy (numpy>=1.24).
   • TypeScript / Node.js SDK: Published on npm as @rootcastle/sofia-engine with zero runtime dependencies.
   • Embedded C99 Runtime: Microcontroller engine (embedded/) with Q16.16 fixed-point math and Python-verified golden vectors.

---

The Rootcastle Engineering Pillars

+---------------------------------------------------------------------------------------+
|                                ROOTCASTLE PILLARS                                     |
+---------------------------------------------------------------------------------------+
|  1. GENERAL SCIENTIFIC AI      Unifies physics, DSP, quantum emulation, and ML into   |
|                                a rigorous, reproducible scientific framework.         |
|  2. ASSEMBLY-LEVEL AUTONOMY    Self-training neural models running on virtual/native   |
|                                assembly with zero framework overhead.                 |
|  3. AUTOMATED FINE-TUNING      Curates telemetry into JSONL datasets and triggers      |
|                                fine-tuning via NVIDIA NIM and OpenRouter APIs.        |
|  4. MULTI-DOMAIN INTELLIGENCE  Vibration, electrical power, acoustic, thermal, and    |
|                                process signals unified in a single edge runtime.      |
|  5. QUANTUM-INSPIRED SPEED     Statevector emulation, quantum kernels, and VQC.       |
|  6. DEFAULT "DENY" SAFETY      Zero control path bypass. All control decisions pass   |
|                                through physical interlocks and operator gates.        |
|  7. AIR-GAPPED BY DESIGN       Zero network or broker dependency in the core. Runs on |
|                                bare metal, isolated gateways, and microcontrollers.   |
+---------------------------------------------------------------------------------------+

---

System Architecture

flowchart TD
    subgraph INGEST ["1. Multi-Domain Scientific & Physical Telemetry"]
        S_VIB["Vibration (Acc / Vel / Disp)"] --> TS["TelemetrySource (ABC)"]
        S_ELEC["Electrical (V, I 3-Phase)"] --> TS
        S_AC["Acoustic / Ultrasound"] --> TS
        S_PROC["Process (Temp, Press, Flow)"] --> TS
        S_IMU["3-Axis IMU (Motion, Tilt)"] --> TS
        S_BUS["MQTT / Modbus / Serial / CSV"] -.-> TS
        TS --> RB["Bounded Ring Buffer\n(Ceiling: N samples, Drop-Oldest)"]
    end

    subgraph DSP ["2. Multi-Domain Signal & Feature Pipeline (NumPy / Pure TS)"]
        RB --> WN["Sliding Window & Quality Tagging\n(GOOD, STALE, MISSING, INVALID)"]
        WN --> SIG_VIB["Vibration DSP\n- Welch PSD (Parseval)\n- Hilbert Envelope\n- Kinematics (BPFO/BPFI)"]
        WN --> SIG_ELE["Electrical Engine (IEEE 519)\n- Power (P, Q, S, PF)\n- THD (1-50 Harmonics)\n- Fortescue 3-Phase (V0, V1, V2, VUF)"]
        WN --> SIG_AC["Acoustic Engine (ASTM E1316)\n- AE Energy, Counts, Rise Time\n- Cavitation Index"]
        WN --> SIG_PROC["Process & Motion\n- dT/dt, Pressure Pulsation\n- Tilt (Pitch, Roll), Jerk"]
        SIG_VIB & SIG_ELE & SIG_AC & SIG_PROC --> FEAT["Unified FeatureVector\n(Named, Ordered, Versioned)"]
    end

    subgraph LEARNING ["3. Assembly Self-Training & Automated Fine-Tuning"]
        FEAT --> ASM_VM["SofiaAsmVM / AssemblyNeuralNetwork\n- Register-level Execution (R0-R7, ACC, LR, ERR)\n- On-Device MSE Loss & SGD Backprop\n- Native Emitters (x86_64 AVX2, ARM Thumb-2, WASM)"]
        FEAT --> CURATOR["DatasetCurator\n- Curate Telemetry to JSONL Chat Pairs\n- Token Validation & Formatting"]
        CURATOR --> AUTO_FT["AutoFineTuner\n- NVIDIA NIM / OpenAI / OpenRouter APIs\n- Automated Checkpoint Registry (models/registry.json)"]
    end

    subgraph QUANTUM ["4. Quantum Emulation & Inference Layer"]
        FEAT --> Q_MAP["Quantum Feature Map\n(Angle / Amplitude Encoding)"]
        Q_MAP --> Q_CIRC["QuantumCircuit & Kernel\n(Statevector in C^(2^n), Gates, Fidelity)"]
        FEAT --> MB["Statistical & ML Backends\n- Robust MAD / EWMA / CUSUM\n- ONNX / PyTorch (Optional)"]
        Q_CIRC & MB & ASM_VM --> IR["InferenceResult\n(Score, Confidence, Uncertainty)"]
    end

    subgraph DIAGNOSTICS ["5. Diagnostic & Health Evaluation"]
        IR --> DE["DiagnosticEngine\n(Evidence Fusion & Quality Scaling)"]
        DE --> HE["HealthEvent\n(Severity, Evidence Trail)"]
        HE --> HS["HealthScore\n(0-100 with Dynamic Uncertainty Band)"]
    end

    subgraph COPILOT ["6. AI Copilot & Safe Decision Gate"]
        HE --> AI_COP["Sofia AI Copilot\n- NVIDIA NIM (api.nvidia.com)\n- OpenRouter (openrouter.ai)\n- Offline Deterministic Renderer"]
        AUTO_FT -.->|Deploy Fine-Tuned Model| AI_COP
        CMD["CommandRequest"] --> PE{"PolicyEngine\n(Default: DENY)"}
        PE -->|Passes Interlocks & Approval| ACT["CommandDecision: APPROVE"]
        PE -->|Violation / High Uncertainty| DEN["CommandDecision: DENY"]
    end

    style INGEST fill:#1e1e2e,stroke:#89b4fa,stroke-width:2px,color:#cdd6f4
    style DSP fill:#181825,stroke:#a6e3a1,stroke-width:2px,color:#cdd6f4
    style LEARNING fill:#1e1e2e,stroke:#f38ba8,stroke-width:2px,color:#cdd6f4
    style QUANTUM fill:#181825,stroke:#cba6f7,stroke-width:2px,color:#cdd6f4
    style DIAGNOSTICS fill:#1e1e2e,stroke:#fab387,stroke-width:2px,color:#cdd6f4
    style COPILOT fill:#313244,stroke:#89dceb,stroke-width:2px,color:#cdd6f4

Loading

---

Mathematical & Scientific Foundations

1. In-Situ Assembly Neural Self-Training

Sofia compiles deep learning forward passes, error gradients, and weight updates directly into virtual register assembly:

• Forward Pass: $$z_j = \sum_{i} w_{ji} x_i + b_j, \quad h_j = \max(0, z_j)$$
• MSE Error & Gradient: $$L = \frac{1}{K}\sum_{k=1}^K (\hat{y}_k - y_k)^2, \quad \frac{\partial L}{\partial \hat{y}_k} = \frac{2}{K}(\hat{y}_k - y_k)$$
• Backpropagation & SGD Update (Instruction: UPDATE_SGD): $$w_{kj}^{(t+1)} = w_{kj}^{(t)} - \eta \cdot \frac{\partial L}{\partial w_{kj}}$$ Executed in-place on fixed Float64 memory arrays with zero garbage collection pauses.

2. Electrical Power Quality & Fortescue Transformation (from REI SignalLab)

• Instantaneous Active, Reactive, and Apparent Power: $$P = \frac{1}{N}\sum_{n=0}^{N-1} v_n \cdot i_n, \quad S = V_{rms} \cdot I_{rms}, \quad Q = \sqrt{S^2 - P^2}, \quad PF = \frac{P}{S}$$

• Total Harmonic Distortion ($\text{THD}$) (IEEE 519 up to 50th harmonic): $$\text{THD}V = \frac{\sqrt{\sum{h=2}^{50} V_h^2}}{V_1} \times 100%$$

• Fortescue Symmetrical Components (3-Phase Unbalance): Let $a = e^{j \frac{2\pi}{3}} = -\frac{1}{2} + j \frac{\sqrt{3}}{2}$: $$\begin{bmatrix} V_0 \ V_1 \ V_2 \end{bmatrix} = \frac{1}{3} \begin{bmatrix} 1 & 1 & 1 \ 1 & a & a^2 \ 1 & a^2 & a \end{bmatrix} \begin{bmatrix} V_a \ V_b \ V_c \end{bmatrix}$$

  • $V_0$: Zero sequence (ground faults).
  • $V_1$: Positive sequence (balanced operating component).
  • $V_2$: Negative sequence (motor overheating / unbalance).
  • Voltage Unbalance Factor: $\text{VUF} = \frac{|V_2|}{|V_1|} \times 100%$.

3. Acoustic Emission & Cavitation Indexing (ASTM E1316)

• Acoustic Emission Energy ($E_{AE}$): $$E_{AE} = \int_{0}^{T} v(t)^2 , dt \approx \sum_{n=0}^{N-1} v_n^2 \Delta t$$
• Cavitation Index ($C_p$): $$C_p = \frac{\int_{5\text{ kHz}}^{20\text{ kHz}} P(f) , df}{\int_{0}^{f_s/2} P(f) , df}$$ Measures the ratio of broadband high-frequency acoustic collapse energy to overall energy.

4. Vibration DSP & Bearing Kinematics

• Welch Power Spectral Density (Parseval Energy Preserved): $$\sum_{n=0}^{N-1} |x_n|^2 = \frac{1}{N} \sum_{k=0}^{N-1} |X_k|^2$$
• Demodulated Analytic Envelope (Hilbert Transform): $$\tilde{x}(t) = x(t) + j \cdot \mathcal{H}{x(t)} = A(t)e^{j\phi(t)}, \quad A(t) = \sqrt{x(t)^2 + [\mathcal{H}{x(t)}]^2}$$
• Bearing Defect Frequencies (Outer/Inner/Ball/Cage): $$\text{BPFO} = \frac{N_b}{2} f_r \left(1 - \frac{d}{D}\cos\alpha\right), \quad \text{BPFI} = \frac{N_b}{2} f_r \left(1 + \frac{d}{D}\cos\alpha\right)$$

5. Advanced Quantum Computing Emulation

• Quantum Statevector: $$|\psi\rangle = \sum_{i=0}^{2^n-1} \alpha_i |i\rangle \in \mathbb{C}^{2^n}, \quad \sum_{i} |\alpha_i|^2 = 1$$
• Angle Encoding Feature Map: $$|x\rangle = \bigotimes_{i=1}^n \left(\cos(x_i)|0\rangle + \sin(x_i)|1\rangle\right)$$
• Quantum Kernel Estimation: $$K(x, y) = |\langle \psi(x) | \psi(y) \rangle|^2$$ Yields transition fidelity in $[0, 1]$ for quantum support vector machines and anomaly isolation.

---

Installation

Python (Core Engine & CLI)

# Minimal production installation (NumPy only - Zero bloat)
pip install sofia-engine

# With industrial field protocols (MQTT, Modbus, Serial)
pip install "sofia-engine[industrial]"

# Full development suite
pip install "sofia-engine[dev]"

TypeScript / Node.js (Edge & Cloud SDK)

npm install @rootcastle/sofia-engine

---

Quickstart

1. In-Situ Assembly Neural Self-Training (Python & TypeScript)

import numpy as np
from sofia_ai.learning import AssemblyNeuralNetwork

# Initialize assembly neural network (3 inputs -> 8 hidden -> 1 output)
model = AssemblyNeuralNetwork(input_dim=3, hidden_dim=8, output_dim=1, learning_rate=0.05)

# Train directly inside SofiaAsmVM (Forward -> Loss -> Backprop -> SGD in bytecode)
x = np.array([0.8, -0.4, 1.2])
y_target = np.array([2.5])

for epoch in range(100):
    loss = model.train_step(x, y_target)

print(f"Final Assembly Training Loss: {loss:.6f}")
print("Predicted output:", model.forward(x))

# Emit native assembly code for target microcontrollers or WASM
print("x86_64 AVX2 Assembly:\n", model.emit_x86_assembly())
print("WebAssembly (WAT):\n", model.emit_wasm())

2. Automated Fine-Tuning Pipeline (Python)

from sofia_ai.learning import AutoFineTuner

# Automatically curate telemetry records and trigger fine-tuning
tuner = AutoFineTuner(provider="nvidia") # or "openai", "openrouter"
job = tuner.auto_tune_from_telemetry(
    records=[
        {"device_id": "pump-01", "rms": 4.5, "severity": "WARNING", "recommendation": "Check alignment"},
        {"device_id": "motor-02", "rms": 1.2, "severity": "NORMAL", "recommendation": "Continue monitoring"},
    ],
    dataset_output_path="data/telemetry_ft.jsonl",
    registry_path="models/registry.json"
)
print(f"Fine-Tuning Job ID: {job.job_id} | Status: {job.status}")

3. Multi-Domain Signal Processing (Python)

import numpy as np
from sofia_ai.features import (
    extract_electrical_features,
    extract_acoustic_features,
    extract_process_features,
    extract_motion_features
)

# 1. Electrical Power Quality (from 230V / 10A 50Hz signals)
t = np.arange(2000) / 2000.0
v = 230.0 * np.sqrt(2) * np.sin(2 * np.pi * 50.0 * t)
i = 10.0 * np.sqrt(2) * np.sin(2 * np.pi * 50.0 * t)
elec_fv = extract_electrical_features(v, i, fs=2000.0)
print(f"Power: {elec_fv['active_power_w']} W | PF: {elec_fv['power_factor']} | THD_V: {elec_fv['thd_v_percent']}%")

# 2. Acoustic Emission & Cavitation
sound = np.sin(2 * np.pi * 12000.0 * t)
ac_fv = extract_acoustic_features(sound, fs=50000.0)
print(f"AE Energy: {ac_fv['energy']:.4f} | Cavitation Index: {ac_fv['cavitation_index']:.2f}")

# 3. 3-Axis IMU Motion & Tilt
ax, ay, az = np.zeros(200), np.zeros(200), np.ones(200)
motion_fv = extract_motion_features(ax, ay, az, fs=100.0)
print(f"Accel Mag: {motion_fv['accel_mag_mean']:.2f} g | Roll: {motion_fv['roll_mean_deg']:.1f}°")

4. Quantum Circuit & Kernel Estimation (Python)

from sofia_ai.quantum import QuantumCircuit, QuantumKernel

# 1. Create 2-qubit Bell state (|00> + |11>) / sqrt(2)
qc = QuantumCircuit(num_qubits=2)
qc.h(0).cx(0, 1)
print("Measurement counts (1000 shots):", qc.measure(shots=1000))

# 2. Compute Quantum Kernel between two sensor feature vectors
kernel = QuantumKernel(num_qubits=3)
fidelity = kernel.evaluate([0.1, 0.5, 0.9], [0.1, 0.5, 0.9])
print(f"Quantum Kernel Fidelity: {fidelity:.4f}") # 1.0000

5. AI Copilot (CLI & Python)

# Ask with auto-detected NVIDIA NIM or OpenRouter key:
sofia ask "Explain voltage unbalance factor (VUF) exceeding 2% in a 3-phase induction motor" --device motor-01

from sofia_ai.copilot import AIEngine

ai = AIEngine(provider="auto") # Auto-detects NVIDIA_API_KEY or OPENROUTER_API_KEY
explanation = ai.explain(
    question="Why is THD_I 8.5% critical under IEEE 519?",
    device_id="substation-04",
    evidence=[{"metric": "thd_i", "observed": 8.5, "reference": 5.0}]
)
print(explanation)

---

Specification Traceability

Requirement Area	Specification IDs	Key Capabilities
Scientific AI & Learning	SOFIA-LRN-001 - 006	In-situ Assembly VM, neural self-training, SGD backprop, auto fine-tuning.
Multi-Domain Signals	SOFIA-SIG-001 - 012	Vibration, Electrical (IEEE 519), Acoustic (ASTM E1316), Thermal, Fluid, IMU.
Quantum Emulation	SOFIA-QEXP-001 - 005	Complex statevectors in $\mathbb{C}^{2^n}$, universal gates, quantum kernels.
AI Copilot	SOFIA-COP-001 - 004	NVIDIA NIM & OpenRouter integrations with offline deterministic fallback.
Safety Gate	SOFIA-SAFE-001 - 006	Default DENY, operator approval gate, physical interlocks, Nonce/TTL protection.
Edge Resilience	SOFIA-EDGE-001 - 007	Ring buffers, store-and-forward (64 MiB ceiling), reconnect backoff.

---

Hugging Face Model Registry & Storage Bucket

Sofia Engine distributes its official release manifests, runtime specifications, reproducible inference examples, and checkpoint storage on Hugging Face:

• Hugging Face Model Registry: huggingface.co/rootcastleengineering/sofia
• Hugging Face Storage Bucket: huggingface.co/buckets/rootcastleengineering/sofia-bucket
• Digital Object Identifier (DOI): 10.57967/hf/10549

Citation

@software{sofia_engine_2026,
  author       = {{Rootcastle Engineering \& Innovation}},
  title        = {Sofia Engine: Scientific \& Edge Intelligence Runtime},
  year         = {2026},
  version      = {3.0.0a1},
  publisher    = {Hugging Face},
  doi          = {10.57967/hf/10549},
  url          = {https://huggingface.co/rootcastleengineering/sofia}
}

---

License & Governance

• License: Open-source under Apache License 2.0. See LICENSE and NOTICE.
• Developed by: Rootcastle Engineering & Innovation.