Introducing TyTorch: A Machine Learning Library for TypeScript/Node.js

We’re excited to announce the release of TyTorch - TypeScript bindings for PyTorch that bring the full power of deep learning to Node.js with complete type safety.

What is TyTorch?

TyTorch is a native Node.js addon that provides direct bindings to PyTorch’s C++ API (libtorch). It enables you to use PyTorch’s powerful tensor operations, automatic differentiation, and GPU acceleration directly from TypeScript and JavaScript.

Unlike other approaches that require Python bridges or ONNX conversions, TyTorch gives you direct access to PyTorch’s optimized C++ kernels with minimal overhead.

Key Features

🔥 Full TypeScript Support: Complete type definitions for all operations
⚡ Native Performance: Direct bindings to libtorch (PyTorch C++ API)
🎯 Familiar API: PyTorch-style API that feels natural to ML practitioners
🖥️ Multi-Device: Support for CPU, CUDA, and Apple Silicon (MPS) devices
🚀 Zero-Copy Operations: Minimal JavaScript/C++ boundary overhead
📦 ES Module Support: Modern JavaScript module system

Why TyTorch?

Machine learning is increasingly important in web applications, but JavaScript has lacked a robust, production-ready ML framework with the power of PyTorch. TyTorch bridges this gap:

No Python Required: Run PyTorch models directly in Node.js without Python dependencies
Type Safety: Catch errors at compile time with TypeScript
Native Speed: Full access to PyTorch’s optimized kernels and GPU acceleration
Unified Stack: Write both your ML models and application logic in TypeScript

Quick Example

Here’s a simple example showing how to create tensors, perform operations, and use automatic differentiation:

import { torch } from 'tytorch';

// Create tensors
const x = torch.tensor([1.0, 2.0, 3.0], { requires_grad: true });
const weights = torch.tensor([0.5, 0.3, 0.2]);

// Forward pass
const output = x.mul(weights).sum();

// Backward pass (automatic differentiation)
output.backward();

// Access gradients
console.log(x.grad.toArray());  // [0.5, 0.3, 0.2]

What’s Implemented?

TyTorch currently includes 46 tensor operations covering the essentials for machine learning:

Core Operations

Arithmetic operations (add, sub, mul, div, matmul)
Shape operations (reshape, transpose, squeeze, unsqueeze, permute, flatten)
Reduction operations (sum, mean)
Device management (CPU, CUDA, MPS)

Machine Learning Essentials

Autograd: Full automatic differentiation support (backward, gradients, requires_grad)
Activation Functions: relu, sigmoid, tanh, softmax, log_softmax
Loss Functions: mse_loss, cross_entropy, nll_loss, binary_cross_entropy
Dtype Conversions: float32, float64, int32, int64

All operations are thoroughly tested with 500+ tests across unit, CPU, and MPS test suites.

Platform Support

macOS (Apple Silicon and Intel) - Fully tested ✅
Linux (x86_64 with CUDA support) - Should work ⚠️
Windows - Experimental ⚠️

Currently, TyTorch is a prototype tested primarily on macOS. Linux and Windows support is in progress.

Installation

Installing TyTorch requires two steps:

1. Install PyTorch (libtorch)

First, install PyTorch via pip:

# macOS/Linux
pip3 install torch torchvision torchaudio

# Set environment variables (add to your shell config)
export LIBTORCH="$(python3 -c 'import torch; print(torch.__path__[0])')"
export DYLD_LIBRARY_PATH="$LIBTORCH/lib:$DYLD_LIBRARY_PATH"  # macOS
export LD_LIBRARY_PATH="$LIBTORCH/lib:$LD_LIBRARY_PATH"      # Linux

2. Install TyTorch

npm install tytorch

For detailed installation instructions including Windows support, see the README.

Roadmap

TyTorch is under active development. Here’s what’s coming next:

Phase 2C (Current): Indexing, slicing, and concatenation operations
Phase 2D: Element-wise math operations (pow, sqrt, exp, log)
Phase 3: Advanced features (convolution, pooling, normalization layers)

See the full development roadmap for details.

Example: Training a Simple Model

Here’s a more complete example showing a training loop:

import { torch } from 'tytorch';

// Create training data
const X = torch.randn([100, 10]);  // 100 samples, 10 features
const y = torch.randn([100, 1]);   // 100 labels

// Initialize model parameters
const weights = torch.randn([10, 1], { requires_grad: true });
const bias = torch.zeros([1], { requires_grad: true });

// Training loop
for (let epoch = 0; epoch < 100; epoch++) {
  // Forward pass
  const predictions = X.matmul(weights).add(bias);
  const loss = predictions.sub(y).pow(2).mean();

  // Backward pass
  loss.backward();

  // Update weights (gradient descent)
  weights.data = weights.sub(weights.grad.mul(0.01));
  bias.data = bias.sub(bias.grad.mul(0.01));

  // Zero gradients
  weights.zero_grad();
  bias.zero_grad();

  if (epoch % 10 === 0) {
    console.log(`Epoch ${epoch}, Loss: ${loss.toArray()[0]}`);
  }
}

Technical Architecture

TyTorch uses a clean, modular architecture:

Native Layer: C++ operations using libtorch, organized one file per operation
TypeScript Layer: Type-safe wrappers with comprehensive JSDoc documentation
Build System: node-gyp for native addon compilation
Testing: Comprehensive test suite with unit, CPU, and MPS-specific tests

All new operations include proper error handling with try-catch blocks that convert C++ exceptions to catchable JavaScript errors.

Get Involved

TyTorch is open source and we welcome contributions!

GitHub: github.com/identellica/tytorch
npm: npmjs.com/package/tytorch
License: Apache 2.0

Whether you want to:

Report bugs or request features
Contribute code or documentation
Share your use cases
Help with testing on different platforms

We’d love to hear from you! Open an issue or submit a pull request on GitHub.

What’s Next?

TyTorch is still in early development (v0.1.0), but it’s already capable of training simple models. Our goal is to make it a production-ready ML framework for Node.js.

Try it out and let us know what you think! Install with npm install tytorch and check out the documentation to get started.

TyTorch is developed by Identellica and released under the Apache 2.0 license.