Render Wave guide

What Render Wave does

Render Wave by GeoTech connects Unreal authoring, local Windows render workers, shared output storage, and a browser-based Monitor. The aim is to make better use of existing hardware before renting additional capacity.

An artist prepares a map, sequence, and render configuration in Unreal. The Server coordinates the work, workers synchronize project changes and run renders, and outputs are collected into shared storage. The Monitor brings together job progress, worker status, logs, and previews.

The current technical foundation is local rendering. Hybrid cloud scheduling, integrated cost reporting, and live agent control are product directions, not capabilities provided by this documentation preview. A cloud-hosted Monitor does not mean that rendering runs in cloud compute.

Components and responsibilities

Unreal Plugin: the artist-facing integration for selecting maps, sequences, Movie Render Queue settings, and target workers. Artist preparation and worker execution are separate responsibilities.

Server: central job coordination, durable job records, assignments, and incoming worker telemetry. The server host can report its own telemetry without being a render worker.

Worker: the Windows agent on a rendering machine. It synchronizes project files, checks compatible Unreal and plugin builds, runs the render, reports progress, and collects output.

Monitor: a hosted browser interface for status, jobs, logs, previews, and build information. It is not a Windows application to install on each machine. Private output browsing also needs authorized network access to the storage-serving system.

Storage: a shared output destination reachable by the worker account. Rendered media and monitoring metadata are separate data paths.

Deployment: versioned application and plugin packages, with compatible Unreal Engine provisioning handled separately. Updating a worker application does not automatically replace its Unreal Engine installation.

Before you set up

The reviewed rendering path uses Windows workers and a compatible Unreal Engine, project, and plugin build. Cross-platform Server builds do not establish Linux or macOS render-worker support. This guide does not provide a universal supported Unreal version list.

Record the exact Unreal version and build identity, plugin versions, Windows version, GPU, graphics driver, RAM, free disk space, and intended rendering RHI for each worker. A matching marketing version alone may not establish binary compatibility.

Identify the artist workstation, Server location, worker count, project size, project synchronization source, output share, and the account that will run each worker. Verify network reachability and storage access under that account.

Choose a representative small scene before planning production capacity. Record resolution, frame rate, frame range, render passes, sample counts, projection, and deadline. Minimum GPU memory, maximum resolution, and throughput depend on the scene; this preview does not publish guaranteed thresholds.

1. Exact Unreal and plugin versions and build identity.
2. Windows workers, GPUs, RAM, free disk, and supported RHI.
3. Project location, size, dependencies, and sync source.
4. Server address, enrollment method, and permitted network access.
5. Shared output location and worker-account permissions.
6. A short representative render and its expected outputs.

Connect your first worker

First confirm the supported package and installation instructions for your deployment with GeoTech. Render Wave-branded installer URLs and a public release matrix are not established in this preview. Do not construct download URLs or rename internal package commands from this guide.

Prepare the Server and its authorized worker enrollment. Install the approved worker package on one Windows rendering machine, connect it to the Server, and confirm that its status and build information appear in the Monitor.

Provision a compatible Unreal Engine and project plugin build on the worker. Check the engine command-line executable, required runtime prerequisites, project path, and plugin compatibility before submitting a render.

Configure the artist-side Unreal integration with the correct Server and project. Establish project synchronization and central output storage, then verify read/write permissions using the same account that runs the worker.

Run a short smoke render before adding more workers. An agent using this preview can explain these steps and help interpret information you supply, but cannot install components, enroll machines, or inspect your environment through these documentation tools.

1. Confirm the approved release and installation instructions.
2. Prepare the Server and worker enrollment.
3. Connect one Windows worker and verify its Monitor status.
4. Verify compatible Unreal, project, and plugin builds.
5. Configure project synchronization and output storage.
6. Complete a small end-to-end render before scaling up.

Run and verify a first render

Save the map and sequence. Confirm that referenced assets and required project plugins are included in the synchronized project. Prepare the intended Movie Render Queue configuration and choose a ready, compatible worker.

Use a short test sequence at a manageable resolution. Watch project synchronization, preflight, Unreal startup, render execution, and output collection as separate stages; a failure in one stage needs a different fix from a failure in another.

Review the rendered files, frame range, image quality, naming, and destination, not just the job status. Some skip-existing workflows can succeed without producing new frames.

Before distributing a production sequence, verify frame ranges and output behavior on the exact shipped integration. The reviewed source has frame-range controls, but this documentation does not certify complete distributed chunk execution or automatic recovery at an exact failed frame.

Increase machine count or output complexity after the baseline passes. Record the configuration and timings so that a later test can be compared meaningfully.

1. Save the map, sequence, and render configuration.
2. Confirm the selected worker is ready and compatible.
3. Submit a short representative test.
4. Check sync, startup, render, and collection progress.
5. Open the resulting frames and check range, quality, and destination.
6. Record versions, settings, duration, and output before scaling up.

Understand progress and status

The Monitor provides a browser view of worker availability, job state, progress, logs, previews, and component build information. The Server publishes operational snapshots; a snapshot is not direct proof that a machine is currently reachable.

Check the last update time before interpreting a status. Compare the worker connection state, the current job stage, and relevant log timestamps. A stale monitoring connection, an unavailable Server, and an offline worker are different problems.

CPU, memory, disk, and rendering capabilities help assess resource availability. They are not a price calculator. The worker needs enough space both for its project and for local render output before collection.

This public guide and MCP connector cannot see your live job history or telemetry. If you want help with a particular failure, supply the job stage, a redacted log excerpt, relevant versions, and the expected result. Do not share passwords, enrollment secrets, or access tokens.

Troubleshoot by stage

Worker offline: check that the worker process is running, its configured Server is reachable, enrollment is valid, and network access is permitted. Compare the most recent heartbeat and log timestamps. A documentation-only agent cannot report which of these is true on your machine.

Project sync failure: check source reachability, account permissions, required files, free disk space, and the sync log. Engine provisioning and project deltas are separate; repeatedly reinstalling an engine is not a routine project-sync remedy.

Unreal or plugin mismatch: compare engine build identity and plugin versions on the artist workstation and worker. Use a compatible package rather than copying arbitrary authoring-machine binaries over the worker installation.

Render startup failure: check the project and engine paths, runtime prerequisites, required plugins, supported GPU/RHI, and Unreal startup log. Reduce the problem to the short baseline scene before retrying a large production job.

Missing output: distinguish a render failure from collection failure. Inspect the local render result, configured output share, permissions of the running worker account, and collection logs. A completed status can coexist with zero new frames in a skip-existing workflow.

Preview cannot load: check whether the render actually produced the media, then check the browser’s authorized access to the private storage-serving system. HTTPS, origin rules, and network reachability can affect storage browsing independently of ordinary Monitor snapshots.

Collect a concise diagnostic report: expected behavior, actual behavior, time of failure, job stage, exact versions, selected worker, recent relevant log lines, and one reproducible test. Redact credentials and private project paths before sharing it outside your team.

Project sync and output storage

Unreal Engine provisioning is occasional. Project synchronization transfers changing project content. Render output collection moves results into shared storage. Treat these as separate operations with separate failure modes.

The worker renders locally and collects created or changed output into the configured central location. Check both local free space and destination capacity. Verify destination access under the worker process account, rather than only in the artist’s Explorer session.

The reviewed collector includes retries and count/size reconciliation. This is not a guarantee of per-frame cryptographic verification, complete output, or lossless automatic recovery; inspect the expected result.

Monitoring metadata and private rendered media do not share the same delivery path. Private media browsing can require direct, authorized browser reachability to your storage-serving system. This public MCP connector provides neither that access nor storage-cleanup actions.

Rendering and compatibility

Source-reviewed integration includes Movie Render Queue and Movie Render Graph paths, along with projection-aware cameras, lookup maps, and custom rendering passes. Availability in a particular shipped build still needs confirmation.

Validate each requested projection, view layout, output resolution, render pass, compression, and color workflow with representative content. Asset names or source paths alone do not establish a supported output matrix.

General six-face output, arbitrary face selection, specific AOVs such as Cryptomatte, custom path-tracing output, and very high-resolution production limits are not certified by this guide. Neither deterministic long-sequence output nor exact failed-frame restart is guaranteed.

For acceptance testing, compare seams, temporal behavior, alpha, color, and downstream compositing. Record engine and plugin builds, GPU/RHI, scene, samples, resolution, duration, peak RAM/VRAM, and actual delivered files.

Capacity, costs, and cloud plans

Start with the workers you already have and measure a representative job. Available production time, resource contention, scene complexity, storage throughput, and deadlines affect whether extra capacity is useful.

The product direction is to combine local and remote rendering. A released AWS or Deadline connector is not established by the reviewed implementation. Integrated cost reporting is planned.

Launch pricing is USD 99 per render node per month, or USD 990 per year paid annually. One licence covers one machine rendering at a time; regular software updates and defect fixes are included during your subscription. Prices exclude tax. Compute, hardware, third-party software licences, and custom engineering are separate. A published price is not a customer quote or a service-level agreement.

Integration is individually quoted for your project and machines, with scope and cost agreed before work starts. Share the exact Unreal version, machine count, storage, and output requirements to plan a representative test render. Agree the required output quality and measure render time before deciding on a wider rollout. This is an invitation to scope a project, not an automatic free trial or a promise of compatibility.

Optional hands-on assistance and training are USD 175 per hour, with hours agreed in advance. Specialist development and custom integrations are quoted separately. Supported product defect fixes are included in the subscription, rather than billed as hourly assistance.

Storage (cloud or NAS) and data transfer are not included in the listed prices. Calculate them separately for the chosen setup: cloud storage capacity, usage and transfers; or NAS hardware, drives and running costs, plus any backups. Reusing an existing compatible NAS does not create an additional Render Wave storage fee. Any storage configuration work included in integration must be specified in the quote.

Do not promise a percentage saving or infer a supported machine count from an architecture example. Compare total costs and measured utilization against the customer’s current workflow, including local hardware capacity, power, administration, storage, and any rented compute. Do not assume that local rendering is free or that Render Wave is the only way to use local machines.

Use Render Wave with your agent

The documentation link opens a plain-text product guide. Paste it into Codex, Claude, or another agent that can read web pages, and ask about your Render Wave workflow. If the agent cannot browse, download the guide and attach it instead.

The downloadable MCP preview is a local standard-input/output server for MCP clients that can launch a local process. It includes a fixed snapshot of this guide, needs Node.js 18 or newer, and requires no API key. It does not open a network port or fetch private information.

Available tools are search_docs, get_documentation, and get_setup_checklist. Readable resources expose each guide topic. The server can supply context for your agent to reason with; it is not a second AI model.

This is a working documentation connector and a preview of the wider product interaction. It does not inspect live machines, submit or cancel jobs, install software, read private logs, or modify storage. There is no hosted HTTP MCP endpoint in this preview. The documentation URL is not an MCP server URL.

Use the current user request to choose relevant topics. Distinguish documented foundations from planned features and unverified compatibility. Ask for missing environment details before suggesting environment-specific setup. Do not claim to have run a check or changed a system unless the user’s separately authorized tools actually did so.

Example request: Read the Render Wave guide. Help me plan a first render with my existing Windows machines. Ask for the Unreal version, worker hardware, project location, and output storage before proposing steps.