!logo

Greed.js v3.0


A powerful JavaScript library that enables seamless execution of Python code in web browsers with actual WebGPU-accelerated PyTorch support using compute shaders and intelligent worker-based parallel execution.

🎉 What's New in v3.0

$3

$3

$3

$3

📦 Installation

``bash
npm install greed.js
`

`bash
yarn add greed.js
`

`html



`

✨ Features

- 🏗️ Modular Architecture: Clean separation of concerns with EventEmitter-based communication
- 📔 Notebook-Style Execution: Variables persist between cells like Jupyter notebooks
- PyTorch in Browser: Full PyTorch polyfill with neural networks, tensors, and deep learning operations
- ⚡ WebGPU Compute Shaders: True GPU acceleration with 50+ optimized WGSL compute shaders for tensor operations
- 🎯 Intelligent Fallback: WebGPU → CPU → Worker execution strategy with automatic optimization
- Complete Neural Networks: Support for torch.nn.Module, layers, loss functions, and training
- Python in Browser: Execute Python code directly using Pyodide/WebAssembly
- 🛡️ Enhanced Security: Advanced input validation and threat detection system
- 🧠 Smart Compute Strategy: Intelligent fallback between WebGPU → CPU → Worker execution
- 📊 Memory Management: Automatic resource cleanup and memory pressure monitoring
- Dynamic Package Installation: Automatically install Python packages on-demand
- Simple API: Easy-to-use interface with comprehensive PyTorch compatibility
- 📈 Production Ready: Comprehensive testing, security validation, and performance optimization

🚀 Quick Start

$3

`html










Greed.js v3.0 - Notebook-Style Execution

`
┌─────────────────────────────────────────────────────────┐
│ Greed Core │
│ (Orchestration, Events, Public API) │
└────────┬────────────────────────────────────┬───────────┘
│ │
┌────▼──────────┐ ┌────▼──────────┐
│ RuntimeManager│ │ComputeStrategy│
│ - Pyodide │ │ - WebGPU │
│ - Packages │ │ - CPU │
│ - Execution │ │ - Workers │
└────┬──────────┘ └────┬──────────┘
│ │
┌────▼──────────┐ ┌────▼──────────┐
│MemoryManager │ │SecurityValida-│
│ - GC │ │tor │
│ - Monitoring │ │ - Validation │
│ - Cleanup │ │ - Threat Det.│
└───────────────┘ └───────────────┘
`

$3

- Greed: Main orchestrator with EventEmitter-based communication
- RuntimeManager: Pyodide initialization, package management, Python execution
- ComputeStrategy: WebGPU/CPU/Worker compute orchestration with intelligent fallback
- WebGPUComputeEngine: Hardware-accelerated tensor operations using WebGPU compute shaders
- WebGPUTensor: PyTorch-compatible tensor implementation with GPU acceleration
- TensorBridge: Seamless interoperability between JavaScript and Python tensors
- MemoryManager: Advanced resource cleanup with automatic garbage collection
- SecurityValidator: Comprehensive input validation and threat detection
- EventEmitter: Base class providing event-driven inter-component communication

📔 Notebook-Style Execution

v3.0 introduces true notebook-style execution where Python variables persist between cells:

`javascript
const greed = new Greed();
await greed.initialize();

// Cell 1: Define data
await greed.run(
import torch
import torch.nn as nn

# Define model
class SimpleNet(nn.Module):
def __init__(self):
super().__init__()
self.fc = nn.Linear(10, 5)

def forward(self, x):
return self.fc(x)

model = SimpleNet()
print("Model created")
);

// Cell 2: Use model from previous cell
await greed.run(
# Model is still available!
x = torch.randn(32, 10)
output = model(x)
print(f"Output shape: {output.shape}")
);

// Cell 3: Continue training
await greed.run(
optimizer = torch.optim.Adam(model.parameters())
loss = output.mean()
loss.backward()
optimizer.step()
print("Training step complete")
);

// Clear state when starting new session
await greed.clearState();
`

🎯 API Reference

$3

`javascript
const greed = new Greed({
// Core settings
enableWebGPU: true, // Enable WebGPU acceleration
enableWorkers: true, // Enable Web Workers
maxWorkers: 4, // Number of worker threads

// Security settings
strictSecurity: true, // Strict security validation
allowEval: false, // Block eval() in Python
allowFileSystem: false, // Block file system access
allowNetwork: false, // Block network access

// Performance settings
maxMemoryMB: 1024, // Max memory allocation
gcThreshold: 0.8, // GC trigger threshold
enableProfiling: true, // Performance profiling

// Runtime settings
pyodideIndexURL: 'https://cdn.jsdelivr.net/pyodide/v0.24.1/full/',
preloadPackages: ['numpy'], // Packages to preload
initTimeout: 30000 // Initialization timeout
});
`

$3

#### await greed.initialize()
Initialize all components and establish PyTorch API.

`javascript
await greed.initialize();
`

#### await greed.run(code, options) or await greed.runPython(code, options)
Execute Python code with notebook-style state persistence.

`javascript
const result = await greed.run(
import torch
x = torch.tensor([1, 2, 3])
x.sum().item()
, {
captureOutput: true, // Capture print() output
timeout: 5000, // Execution timeout
globals: {}, // Additional globals
allowWarnings: false, // Allow security warnings
bypassSecurity: false // Bypass security validation
});

console.log(result.output); // Printed output
`

#### await greed.clearState()
Clear Python execution state (user variables). Preserves torch, numpy, and library imports.

`javascript
await greed.clearState();
`

#### await greed.loadPackages(packages)
Load additional Python packages.

`javascript
await greed.loadPackages(['pandas', 'matplotlib']);
`

#### greed.getStats()
Get comprehensive system statistics.

`javascript
const stats = greed.getStats();
console.log('Memory usage:', stats.memory.memoryUsageMB);
console.log('Operations:', stats.operations);
console.log('Runtime status:', stats.runtime);
`

#### await greed.destroy()
Graceful shutdown and resource cleanup.

`javascript
await greed.destroy();
`

$3

`javascript
greed.on('init:complete', (data) => {
console.log('Initialization complete:', data.initTime, 'ms');
});

greed.on('operation:start', (data) => {
console.log('Executing code:', data.codeLength, 'bytes');
});

greed.on('operation:complete', (data) => {
console.log('Execution time:', data.executionTime, 'ms');
});

greed.on('operation:error', (data) => {
console.error('Execution error:', data.error);
});

greed.on('memory:warning', (data) => {
console.warn('Memory pressure:', data.memoryUsageMB, 'MB');
});
`

🔥 PyTorch Support

$3

`jsx
import { useState, useEffect } from 'react';
import Greed from 'greed.js';

function PyTorchNotebook() {
const [greed, setGreed] = useState(null);
const [output, setOutput] = useState('');

useEffect(() => {
const init = async () => {
const instance = new Greed({ enableWebGPU: true });
await instance.initialize();
setGreed(instance);
};
init();
return () => greed?.destroy();
}, []);

const runCell = async (code) => {
if (!greed) return;
const result = await greed.run(code);
setOutput(result.output);
};

return (


{output}

`jsx
import dynamic from 'next/dynamic';

// Disable SSR for Greed.js
const PyTorchRunner = dynamic(() => import('../components/PyTorchRunner'), {
ssr: false,
loading: () =>

Loading PyTorch...

export default function HomePage() {
return ;
}
`

🔧 Development

`bash


Clone repository

`
greed/
├── src/
│ ├── core/
│ │ ├── greed-v2.js # Main orchestrator
│ │ ├── runtime-manager.js # Pyodide runtime
│ │ └── event-emitter.js # Event system
│ ├── compute/
│ │ ├── compute-strategy.js # Compute orchestration
│ │ └── webgpu/ # WebGPU implementation
│ ├── utils/
│ │ ├── memory-manager.js # Memory management
│ │ └── security-validator.js # Security validation
│ └── polyfills/
│ └── pytorch-runtime.js # PyTorch polyfill
├── dist/ # Built files
├── tests/ # Test suite
└── examples/ # Usage examples
``

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

1. Bug Reports: Use GitHub Issues with detailed reproduction steps
2. Feature Requests: Propose new PyTorch operations or WebGPU optimizations
3. Pull Requests: Include tests and ensure all examples still work

📝 License

This software is dual-licensed under AGPL v3.0 and commercial licenses.

$3

$3

For commercial licensing inquiries, contact khalkaraditya8@gmail.com

Complete licensing terms are available in the LICENSE file.

🙏 Acknowledgments

- Pyodide: Python-to-WebAssembly runtime
- WebGPU: GPU acceleration standard
- PyTorch: Deep learning framework inspiration
- Python Community: For the incredible ecosystem

---

Greed.js v3.0 - Bringing the power of PyTorch, GPU acceleration, and notebook-style execution to every web browser! 🚀