WitEngine

The Challenge of Distributed Computing

Imagine you need to render an animated film, process millions of documents, or train a machine learning model. Your single computer would take weeks. The obvious solution — use multiple machines working together — introduces extraordinary complexity:

• Network communication — How do machines talk to each other?
• Task partitioning — How do you divide the work fairly?
• Load balancing — How do you prevent fast machines from sitting idle?
• Failure handling — What happens when a machine crashes mid-task?
• Hardware diversity — How do you handle different CPUs, GPUs, and operating systems?

Traditional approaches require months of infrastructure work before any actual computation begins.

WitEngine eliminates this complexity.

The Intelligent Orchestrator

WitEngine acts as an intelligent orchestrator — you describe what you want to compute, and it figures out how to distribute it efficiently. Just as a taxi dispatcher assigns cars based on location and traffic, WitEngine assigns tasks based on machine capabilities, current load, and performance characteristics.

From Complex Infrastructure to Simple Scripts

Without WitEngine, distributing work across machines requires:

❌ Setting up message queues (RabbitMQ, Kafka)
❌ Implementing worker processes with health monitoring
❌ Building a custom task scheduler
❌ Handling serialization for complex data
❌ Managing partial failures and retries
❌ Months of development and testing

With WitEngine:

Job:ProcessDataset(ItemCollection:items)
{
    ~ Distribute the work across all available machines ~
    ResultCollection:results = Grid.ForEach(item in items) 
        => Processor.Process(item);
    
    Report:summary = Report.Aggregate(results);
}

The Grid.ForEach call handles everything: finding available machines, dividing the work based on performance, sending data, collecting results, and handling failures.

Smart Distribution with Benchmarks

One of WitEngine's core innovations is benchmark-based load distribution. When a machine joins the cluster, it runs a standardized benchmark that measures its computational capabilities. This score becomes the basis for intelligent task allocation.

How It Works

Consider an office with diverse hardware:

When you submit a job with 1000 tasks, WitEngine doesn't split them equally (250 per machine). Instead, it distributes proportionally:

• Developer Workstation: 420 tasks
• Designer Mac: 310 tasks
• Office Laptop: 170 tasks
• Old Desktop: 100 tasks

The result? All machines finish at approximately the same time. No powerful machine sits idle waiting for slower ones to complete.

Dynamic Rebalancing

Benchmarks aren't static. WitEngine continuously monitors actual performance:

• If a machine performs better than expected, it receives more work
• If a machine slows down (thermal throttling, competing processes), work is redistributed
• If a machine goes offline, its pending tasks are automatically reassigned

This ensures optimal utilization even as conditions change throughout a long-running job.

Two Distribution Strategies

WitEngine offers two strategies optimized for different workload patterns:

Balanced Strategy (Push Model) — Work is divided upfront based on benchmark scores. Each node receives its full batch immediately. Best for predictable tasks with consistent execution times.

Queued Strategy (Pull Model) — Nodes pull tasks from a shared queue as they complete previous work. Faster nodes automatically do more. Best for variable execution times or unpredictable workloads.

ProcessingOptions:opts = ProcessingOptions.Create("Queued");
Results:r = Grid.ForEach(item in items, opts) => Process(item);

Core Design Principles

Pattern-Based Distribution

WitEngine is built on a fundamental insight: most distributed workloads follow predictable patterns. Whether you're rendering frames, processing files, or running simulations:

1. Take a collection of inputs
2. Apply the same operation to each input
3. Collect the outputs

WitEngine provides primitives that capture these patterns, handling all complexity behind the scenes.

Fault Tolerance

When a machine fails during processing:

• Its incomplete tasks are automatically reassigned
• No manual intervention required
• Results are never lost
• The job continues without interruption

Heterogeneous Support

WitEngine is a low-level .NET library and runs wherever .NET runs — it carries no platform lock-in of its own. A single cluster can mix machines freely: different operating systems and architectures, with or without a GPU, across LAN, WAN or cloud. Each machine contributes what it can — servers, workstations and laptops alike, each receiving work proportional to its capabilities — and WitEngine orchestrates them into a unified computational resource.

Key Features

Controllers, activities, and scripts

WitEngine is built on a modular plugin system where everything is a plugin — even built-in functionality comes from controllers. Custom types and operations are first-class citizens.

Each controller contributes two things:

• Variables — data types usable in scripts (e.g., Int, Matrix, Image).
• Activities — operations on that data (e.g., Int.Add, Matrix.Multiply, Image.Resize).

Built-in controllers include primitives (Int, String, Bool), control flow (If, Loop, ForEach), distributed computing (Grid.ForEach), and linear algebra (Matrix, Vector).

Scripts compose activities into processes

Activities are the building blocks; scripts wire them together into a process — a single job that runs across the cluster. The activities in one script can come from different controllers written by different authors: one author's activity, another's, a third's, composed into a single pipeline.

That's what makes the platform compositional rather than fixed. You extend it in two ways — write a new controller to add activities (a genuinely new capability), or write a new script to compose existing activities into a new operation, with no low-level code. A script can turn activities that already exist into something none of them did alone, and every controller added to the ecosystem increases what every script can express.

An activity doesn't have to be pure computation: a controller can wrap a piece of equipment — a camera, a motor, a display — so the same scripts that coordinate computation can drive and sequence physical hardware into one automated process.

Capability-Based Node Selection

Not every node can run every task. Activities can declare hardware requirements:

[RequiresCpu(MinLogicalCores = 8)]
[RequiresMemory(MinRamMb = 16384)]
[RequiresGpu(MinVRamMb = 8192, Features = GpuFeatures.Cuda)]
public class WitActivityTrainModel : WitActivityTransform { }

The orchestrator automatically filters nodes based on:

• OS — Platform, version
• CPU — Architecture, core count
• Memory — Available RAM
• GPU — Type, VRAM, features (CUDA, OpenCL, Metal)
• Custom properties — User-defined capabilities

Only compatible nodes receive the work.

Where WitEngine sits

WitEngine is the execution core of OmnibusCloud — one platform built in three layers. WitEngine provides the distributed-computing foundation; WitCloud is the deployable server an organization installs on its own hardware; OmnibusCloud is that server opened to the internet as a public network.

WitEngine is the foundation, and this page is about that layer: the scripting language, distributed execution, the benchmark system and fault tolerance. WitCloud builds on it with device enrollment, scheduling and monitoring for a private cluster. OmnibusCloud is the same server opened to the internet — the portal where projects are published and people join with their machines, launching as crowdcomputing. WitEngine can be licensed independently.

Use Cases

• Rendering & Animation — Distribute frame rendering across hundreds of machines
• Scientific Computing — Run simulations at scale without supercomputer access
• Data Processing — Process massive datasets in parallel
• Machine Learning — Distribute training across available resources
• Build Systems — Parallelize compilation across developer machines
• Batch Processing — Process thousands of files simultaneously

Getting Started

WitEngine is the core of the OmnibusCloud platform. The engine itself is proprietary and can be licensed independently; the controllers and SDK are open, so you can extend the platform with new kinds of work.

For developers:

• Explore the open controllers and SDK: github.com/OmnibusCloud — sample controllers and a public SDK for building and debugging your own extensions.
• Documentation and guides: omnibuscloud.io.

The SDK lets you build a controller, test its distributed behavior locally, and deploy it to a private WitCloud cluster or the public OmnibusCloud network.

Let's build the ultracomputer together!