# TEngine Network Module Architecture: Unity-Native HTTP and Debug Communication

> Explore TEngine's network module architecture, leveraging Unity's native APIs for efficient async HTTP and debugging. Centralized via ResourceModule for enhanced performance and integration.

- Repository: [ALEX/tengine](https://github.com/alex-rachel/tengine)
- Tags: architecture
- Published: 2026-02-24

---

**TEngine's network module is a lightweight abstraction layer built on top of Unity's native `UnityWebRequest` and `PlayerConnection` APIs, centralized through the `ResourceModule` to provide async HTTP operations with integrated caching and editor debugging capabilities.**

The `alex-rachel/tengine` repository implements a thin, high-level networking wrapper that leverages Unity's built-in infrastructure rather than third-party libraries. This architecture prioritizes runtime efficiency by keeping the main thread unblocked through coroutine-based or `UniTask` async patterns while providing a unified entry point for all HTTP traffic through the resource management system.

## Core Architectural Layers

TEngine organizes its networking capabilities into three distinct layers that work together to handle runtime HTTP requests and editor-to-player communication.

### HTTP Client Layer (UnityWebRequest)

All runtime HTTP operations in TEngine route through `UnityEngine.Networking.UnityWebRequest`. According to the source code in [`UnityProject/Assets/TEngine/Runtime/Core/Utility/Utility.Http.cs`](https://github.com/alex-rachel/tengine/blob/main/UnityProject/Assets/TEngine/Runtime/Core/Utility/Utility.Http.cs), the framework wraps this native API to handle GET/POST requests, TLS connections, streaming downloads, and timeout management.

The `ResourceModule.CustomWebRequester(string url)` method in [`UnityProject/Assets/TEngine/Runtime/Module/ResourceModule/ResourceModule.cs`](https://github.com/alex-rachel/tengine/blob/main/UnityProject/Assets/TEngine/Runtime/Module/ResourceModule/ResourceModule.cs) serves as the centralized factory for creating these requests. This design ensures consistent header configuration, default timeout values, and error handling policies across the entire application.

### Editor Debug Communication (PlayerConnection)

For development workflows, TEngine implements a message-based peer-to-peer system using `UnityEngine.Networking.PlayerConnection.PlayerConnection`. The files [`RemotePlayerConnection.cs`](https://github.com/alex-rachel/tengine/blob/main/RemotePlayerConnection.cs) and [`RemoteEditorConnection.cs`](https://github.com/alex-rachel/tengine/blob/main/RemoteEditorConnection.cs) located in `UnityProject/Packages/YooAsset/Runtime/DiagnosticSystem/` enable the Unity Editor to exchange messages with running player builds.

This architecture supports live reloading, remote profiling, and log streaming without requiring custom socket implementations or external networking libraries.

### Resource Integration and Caching

Before executing any network request, TEngine checks the local cache through YooAsset's `DefaultCacheFileSystem`. The `ResourceModule` implements a cache-first strategy where `CustomWebRequester` only initiates HTTP traffic if the requested asset or configuration file is not present or valid in local storage.

This integration point ensures that asset bundles, configuration JSON files, and other remote resources minimize unnecessary network overhead while maintaining synchronization with server-side updates.

## Key Implementation Characteristics

### Unified Request Creation

All HTTP traffic funnels through a single entry point. The `CustomWebRequester` method creates `UnityWebRequest` instances and returns them to callers, centralizing header configuration and timeout defaults. This prevents fragmentation of networking logic across different game systems.

### Async Execution Patterns

The architecture supports two asynchronous patterns to keep the main thread responsive:

1. **Coroutine-based**: Traditional `IEnumerator` methods compatible with Unity's legacy async model
2. **UniTask integration**: Modern `async/await` syntax using `UniTask<T>` for zero-allocation async operations

### Error and Retry Logic

The wrapper implementation checks `isNetworkError` and `isHttpError` properties on completed requests. The centralized error handling in `ResourceModule` can be extended with retry policies, exponential backoff, or fallback to cached content when network conditions are unstable.

## Practical Code Examples

### Creating a Simple GET Request

```csharp
using TEngine.Runtime.Module;
using UnityEngine.Networking;
using Cysharp.Threading.Tasks;

// Request a JSON config from the server using TEngine's wrapper
var request = ResourceModule.CustomWebRequester(
    "https://example.com/config.json");

// Send asynchronously using UniTask
await request.SendWebRequest();

if (request.result == UnityWebRequest.Result.Success)
{
    string json = request.downloadHandler.text;
    // Parse configuration data
}
else
{
    Debug.LogError($"Network error: {request.error}");
}

```

### Downloading Assets with Cache Fallback

```csharp
using System.IO;
using YooAsset;

string bundleUrl = "https://assets.example.com/ab_001";
var cachePath = YooAssets.GetCacheFilePath(bundleUrl);

if (File.Exists(cachePath))
{
    // Load from local cache
    var bundle = await AssetBundle.LoadFromFileAsync(cachePath);
}
else
{
    // Use TEngine's network wrapper to fetch remotely
    var request = ResourceModule.CustomWebRequester(bundleUrl);
    await request.SendWebRequest();

    if (request.result == UnityWebRequest.Result.Success)
    {
        // Persist to cache for future requests
        File.WriteAllBytes(cachePath, request.downloadHandler.data);
        var bundle = await AssetBundle.LoadFromMemoryAsync(
            request.downloadHandler.data);
    }
}

```

### Editor Remote Debugging Connection

```csharp
using UnityEngine.Networking.PlayerConnection;
using System;

// Establish connection to running player for debugging
var conn = PlayerConnection.instance;

// Send custom debug command via GUID
conn.Send(
    Guid.Parse("DEADBEEF-1234-5678-90AB-CDEF12345678"),
    System.Text.Encoding.UTF8.GetBytes("ShowProfiler"));

```

## Summary

- **Architecture**: TEngine uses a thin wrapper around Unity's `UnityWebRequest` and `PlayerConnection` APIs rather than implementing custom socket protocols
- **Entry Point**: All HTTP requests originate from `ResourceModule.CustomWebRequester()` in [`ResourceModule.cs`](https://github.com/alex-rachel/tengine/blob/main/ResourceModule.cs)
- **Caching**: Network requests integrate with YooAsset's `DefaultCacheFileSystem` to implement cache-first resource loading
- **Async Support**: The module supports both Unity coroutines and `UniTask` for non-blocking network operations
- **Debugging**: Editor-to-player communication uses `PlayerConnection` classes located in the DiagnosticSystem package for live debugging capabilities

## Frequently Asked Questions

### What underlying technology does TEngine use for HTTP requests?

TEngine relies entirely on Unity's native `UnityWebRequest` API for all HTTP operations. The framework does not bundle third-party networking libraries like libcurl or custom TCP implementations. Instead, it provides a high-level wrapper in [`Utility.Http.cs`](https://github.com/alex-rachel/tengine/blob/main/Utility.Http.cs) and [`ResourceModule.cs`](https://github.com/alex-rachel/tengine/blob/main/ResourceModule.cs) that configures `UnityWebRequest` instances with appropriate headers, timeouts, and error handling while maintaining full compatibility with Unity's cross-platform networking stack.

### How does TEngine handle offline mode or poor network conditions?

The architecture implements a cache-first strategy through its integration with YooAsset. Before initiating any HTTP request via `CustomWebRequester`, the system checks `YooAssets.GetCacheFilePath()` to determine if a valid local copy exists. If cached content is available, the network request is bypassed entirely. Additionally, the error handling logic in the request wrapper can be extended to implement retry policies when `isNetworkError` or `isHttpError` returns true.

### Can TEngine's networking work with async/await instead of coroutines?

Yes. While the architecture supports traditional Unity coroutines (`IEnumerator`), it is fully compatible with `UniTask` for modern async/await patterns. The `CustomWebRequester` returns a `UnityWebRequest` object that can be awaited directly using `await request.SendWebRequest()` when using the UniTask package, providing zero-allocation asynchronous operations without blocking the main thread.

### What is the purpose of the RemotePlayerConnection classes?

The [`RemotePlayerConnection.cs`](https://github.com/alex-rachel/tengine/blob/main/RemotePlayerConnection.cs) and [`RemoteEditorConnection.cs`](https://github.com/alex-rachel/tengine/blob/main/RemoteEditorConnection.cs) files implement editor-to-player debugging communication using Unity's `PlayerConnection` API. This allows developers to send commands, receive logs, and trigger hot-reloads from the Unity Editor to a running build on device. This messaging system operates independently of the HTTP client architecture and uses GUID-based message channels for peer-to-peer communication during development workflows.