Supported Platforms

WitEngine is designed as a cross-platform framework, enabling heterogeneous computing clusters where different devices contribute according to their capabilities. This section details currently supported platforms, architectures, and the roadmap for future expansion.

Current Platform Support

WitEngine currently runs on four major platforms across two CPU architectures:

Legend:

• Host — Can run the full WitEngine orchestrator (script parsing, job management)
• Node — Can run WitEngineNode (execute activities, report results)

Platform Details

Windows

Windows is the primary development platform for WitEngine.

Typical Use Cases:

• Development workstations
• Render farm nodes with NVIDIA GPUs
• Enterprise server deployments

Linux

Linux provides excellent server-side support and is common in cluster deployments.

Typical Use Cases:

• Cloud compute instances (AWS, Azure, GCP)
• On-premises server clusters
• Docker/Kubernetes deployments
• Raspberry Pi and ARM single-board computers

macOS

macOS supports both Intel and Apple Silicon Macs.

Typical Use Cases:

• Developer workstations
• Creative professional nodes (video, audio, graphics)
• Mixed office environments

Android

Android enables mobile devices to participate as compute nodes.

Typical Use Cases:

• Edge computing for IoT scenarios
• Utilizing idle mobile device capacity
• Field data collection and preprocessing
• Distributed sensing applications

⚠️ Android Considerations: Mobile devices have battery and thermal constraints. WitEngine respects Android's background execution policies and should be configured to run during charging or with explicit user consent for background work.

Architecture Support

x64 (AMD64)

The most common architecture for servers and desktops.

ARM64 (AArch64)

Growing in popularity for power-efficient computing.

Cross-Architecture Clusters

WitEngine fully supports mixed-architecture clusters:

The key requirement: all nodes must have compatible plugins. If a plugin is compiled only for x64, ARM64 nodes cannot execute those activities.

GPU Support

GPU capabilities vary by platform:

*macOS Vulkan via MoltenVK translation layer

GPU Requirements in Activities

Activities can declare GPU requirements:

// CUDA-specific activity (Windows/Linux only)
[RequiresGpu(Features = GpuFeatures.Cuda)]
public class CudaMatrixMultiply : WitActivityTransform { }

// Metal-specific activity (macOS only)
[RequiresGpu(Features = GpuFeatures.Metal)]
public class MetalImageProcess : WitActivityTransform { }

// Cross-platform GPU activity
[RequiresGpu(GpuType = GpuType.Discrete)]
public class GpuAcceleratedTask : WitActivityTransform { }

The orchestrator automatically routes work to nodes with matching GPU capabilities.

Platform-Specific Considerations

Plugin Compatibility

Plugins must be compiled for each target platform. A typical plugin distribution:

MyPlugin/
├── win-x64/
│   └── MyPlugin.dll
├── win-arm64/
│   └── MyPlugin.dll
├── linux-x64/
│   └── MyPlugin.dll
├── linux-arm64/
│   └── MyPlugin.dll
├── osx-x64/
│   └── MyPlugin.dll
├── osx-arm64/
│   └── MyPlugin.dll
└── android-arm64/
    └── MyPlugin.dll

Pure .NET plugins (no native dependencies) can often be architecture-neutral. Plugins with native dependencies require per-platform builds.

Native Dependencies

Some activities require native libraries:

Activities with native dependencies should:

1. Declare platform requirements via [RequiresOs]
2. Handle missing dependencies gracefully
3. Document installation requirements

Network and Firewall

All platforms require network access for distributed operation:

Future Platform Roadmap

WitEngine's architecture is designed for expansion. The following platforms are planned or under consideration:

Priority Platforms (Near-term)

Why Game Consoles?

Modern game consoles are essentially high-performance computing devices that sit idle most of the time:

These devices could contribute significant compute power during idle hours — imagine a render farm that includes living room consoles contributing overnight.

Android Smart Devices extend the existing Android support to:

• Smart TVs (Samsung, LG, Sony with Android TV)
• Set-top boxes (NVIDIA Shield, Chromecast)
• Automotive systems (Android Automotive)
• Smart displays

Long-term Vision

Vision: Universal Compute Mesh

The long-term vision is a world where any device with a processor can contribute to distributed computation:

Checking Platform Capabilities

From Scripts

Scripts can query node capabilities:

~ Get available nodes ~
NodeCollection:nodes = Grid.GetNodes();

~ Filter by platform ~
NodeCollection:windowsNodes = Collection.Where(nodes, 
    n => Node.GetPlatform(n) == "Windows");

NodeCollection:cudaNodes = Collection.Where(nodes,
    n => Node.HasGpuFeature(n, "Cuda"));

From Code

The capability system provides detailed information:

public interface IWitCapabilities
{
    IWitCapabilitiesOs Os { get; }           // Platform, version
    IWitCapabilitiesCpu Cpu { get; }         // Architecture, cores
    IWitCapabilitiesMemory Memory { get; }   // RAM
    IWitCapabilitiesStorage TempStorage { get; }  // Disk
    IReadOnlyList<IWitCapabilitiesGpu> Gpus { get; }  // GPUs
    IReadOnlyDictionary<string, string> CustomProperties { get; }
}

Summary

WitEngine's cross-platform design means you can start with whatever hardware you have and expand as needed. A cluster can grow from a single developer laptop to a global mesh of heterogeneous devices — all running the same scripts, with work automatically distributed based on capabilities.