magnetron

Super minimalistic machine-learning framework.
Explore the docs »

View Example | Report Bug | Request Feature

Magnetron is a minimalistic, PyTorch-style machine-learning framework designed for IoT and other resource-limited environments.
The tiny C99 core - wrapped in a modern Python API - gives you dynamic graphs, automatic differentiation and network building blocks without the bloat.
A CUDA backend is also WIP.

• PyTorch-like Python API
  → Seamless switch for PyTorch users with familiar syntax and behavior
• Automatic differentiation on dynamic computation graphs
  → Supports flexible model construction and training workflows
• High-level neural-net building blocks
  → Includes nn.Module, Linear, Sequential, and more out of the box
• Broadcasting-aware operators with in-place variants
  → Efficient, NumPy-like tensor ops with performance in mind
• CPU multithreading + SIMD (SSE4, AVX2/AVX512, ARM NEON)
  → High performance even without a GPU
• Multiple datatypes: float32, float16, int32, and boolean
  → Flexibility for both training and quantized inference
• Custom compressed tensor file formats
  → Fast serialization & model loading
• Modern PRNGs (Mersenne Twister, PCG)
  → Reliable and reproducible randomness
• Clear validation and error messages
  → Easier debugging and better developer experience
• N-dimensional, flattened tensors
  → Simple internal representation with general support for shapes
• No external C or Python dependencies (except CFFI for the Python wrapper)
  → Lightweight and portable – great for embedded or restricted environments

A simple XOR neuronal network (MLP) trained with Magnetron. Copy and paste the code below into a file called xor.py and run it with Python.

import magnetron as mag
from magnetron import optim, nn
from matplotlib import pyplot as plt

EPOCHS: int = 2000

# Create the model, optimizer, and loss function
model = nn.Sequential(nn.Linear(2, 2), nn.Tanh(), nn.Linear(2, 1), nn.Tanh())
optimizer = optim.SGD(model.parameters(), lr=1e-1)
criterion = nn.MSELoss()
loss_values: list[float] = []

x = mag.Tensor.from_data([[0, 0], [0, 1], [1, 0], [1, 1]])
y = mag.Tensor.from_data([[0], [1], [1], [0]])

# Train the model
for epoch in range(EPOCHS):
    y_hat = model(x)
    loss = criterion(y_hat, y)
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()

    loss_values.append(loss.item())

    if epoch % 100 == 0:
        print(f'Epoch: {epoch}, Loss: {loss.item()}')

# Print the final predictions after the training
print('=== Final Predictions ===')

with mag.no_grad():
    y_hat = model(x)
    for i in range(x.shape[0]):
        print(f'Expected: {y[i]}, Predicted: {y_hat[i]}')

# Plot the loss

plt.figure()
plt.plot(loss_values)
plt.xlabel('Epoch')
plt.ylabel('MSE Loss')
plt.title('Training Loss over Time')
plt.grid(True)
plt.show()

This results in the following output:

To get a local copy up and running follow these simple steps.
Magnetron itself has no Python dependencies except for CFFI to call the C library from Python.
Some examples use matplotlib and numpy for plotting and data generation, but these are not required to use the framework.

• Linux, MacOS or Windows
• A modern, C-99 capable compiler (gcc, clang, msvc)
• Python 3.6 or higher
• CMake (Linux: sudo apt install cmake, OSX: brew install cmake)

A pip-installable package will be provided once all core features are implemented. Until then, follow these steps to build Magnetron from source:

1. Clone and enter the Magnetron repository:

   git clone https://github.com/MarioSieg/magnetron && cd magnetron

2. Create and activate a virtual environment:

   python3 -m venv .venv && source .venv/bin/activate

3. Install Magnetron
   (Make sure CMake and a C compiler are installed – see Prerequisites):

   pip install .

4. Run the XOR training example:

   python3 examples/xor.py

See the Examples directory which contains various models and training examples.
For usage in C or C++ see the Unit Tests directory.

The following table lists all available operators and their properties.

Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are greatly appreciated. If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".

(c) 2025 Mario "Neo" Sieg. [email protected]
Distributed under the Apache 2 License. See LICENSE.txt for more information.

• GGML
• TINYGRAD
• MICROGRAD

(back to top)