Consume the packages

HEAT ProtoLib publishes four language packages, all generated from the same schema. Pick the one matching your integration; see Schemas if you need the .proto files directly instead.

Language	Distribution	Use case
C#	NuGet package	Unity, Godot, Windows services, HEAT Capture itself
C++	Static library (ZIP)	Unreal Engine, custom engines, embedded hosts
Python	Wheel	Data analysis, tooling, backend services
Rust	Source crate	High-performance backends, WebAssembly targets


dotnet add package HEAT.ProtoLib.CSharp

Minimum: .NET 10. The package multi-targets net10.0, netstandard2.1, netstandard2.0 and net48, so it also links into Unity and .NET Framework 4.8 projects.
Namespaces: HEAT.Proto (common types), HEAT.Proto.Simulation (Entity, Component, SimulationFrame, and their builders under HEAT.Proto.Simulation.Builders), HEAT.Proto.Capture (DataPacket), HEAT.Proto.Data (PDU, FolderUploadData).
Depends on Google.Protobuf and, at build time only, Grpc.Tools for proto compilation.


using HEAT.Proto.Simulation;
using HEAT.Proto.Simulation.Builders;
 
var frame = SimulationFrameBuilder.Create()
    .WithSimulationTick(42)
    .WithSimulationTimeSeconds(1.5)
    .AddEntity(EntityStateBuilder.Create()
        .WithEntity(e => e
            .WithId(100)
            .WithName("Vehicle1")
            .WithTransform(t => t.WithPosition(10.0f, 5.0f, 20.0f)))
        .Build())
    .Build();
 
byte[] data = frame.ToByteArray();
var parsed = SimulationFrame.Parser.ParseFrom(data);

Build or obtain HEAT-ProtoLib-CPP-<version>.zip from packages/Release/.
Extract it and link the static library:


include_directories(libs/HEAT-ProtoLib/include)
find_library(HEAT_PROTOLIB NAMES HEAT-ProtoLib-CPP PATHS libs/HEAT-ProtoLib/lib REQUIRED)
target_link_libraries(your_target PRIVATE ${HEAT_PROTOLIB})

Minimum: C++23, CMake 3.23+, MSVC 2022 (17.0+), GCC 12+ or Clang 16+.
Protobuf is vendored via a vcpkg export checked into the repository (tracked with Git LFS), so building HEAT ProtoLib itself needs no separate vcpkg install.
A consumer that cannot link the protobuf C++ runtime directly, most commonly an Unreal Engine module with its own toolchain constraints, can instead consume the C-API distribution (heat_protolib_capi.dll plus C/C++ headers, no protobuf or abseil dependency). It generates from the same schema, so field and builder names line up with the C++ package; see the migration guide in the repository’s docs/migration-cpp-to-capi.md if you need it.


#include <HEAT/Proto/Builders/SimulationFrameBuilder.hpp>
#include <HEAT/Proto/Builders/EntityStateBuilder.hpp>
 
using namespace HEAT::Proto::Builders;
 
auto frame = SimulationFrameBuilder()
    .with_simulation_tick(42)
    .add_entity(EntityStateBuilder()
        .with_entity([](auto& e) { e.with_id(100).with_name("Vehicle1"); })
        .build())
    .build();
 
std::string data = frame.SerializeAsString();


pip install packages/Release/heat_protolib-*.whl

Minimum: Python 3.8, per python/pyproject.toml.in. The Python integration guide in the repository recommends 3.9 or later; treat 3.8 as the floor and 3.9+ as the tested target.
Depends on protobuf>=5.29.0,<6.0.0.
An optional analytics extra (pip install heat-protolib[analytics]) pulls in pyarrow, pandas and python-dateutil. It exists for a proto-to-Parquet conversion workflow that is still a design proposal in the repository, not a shipped, supported tool; this documentation does not cover it.


from heat.proto.builders.entitybuilder import EntityBuilder
from heat.proto.builders.componentbuilder import ComponentBuilder
from heat.proto.builders.components.transformcomponentbuilder import TransformComponentBuilder
 
entity = (
    EntityBuilder.create()
    .with_id(1000)
    .with_name("MyVehicle")
    .add_component(
        ComponentBuilder.create()
        .with_transform(
            TransformComponentBuilder.create()
            .with_position(10.0, 20.0, 30.0)
            .build())
        .build())
    .build()
)

HEAT ProtoLib for Rust ships as source, not a binary crate:


[dependencies]
heat-protolib = { git = "https://github.com/VRAIie/HEAT-ProtoLib", branch = "main" }

The dependency key (heat-protolib) is the name your Cargo.toml gives it; the crate’s own [package] name is heat_protolib_rust. The current crate invokes prost-build during each consumer build, so protoc must be installed and discoverable on PATH. Generated Rust sources are also committed, but build.rs regenerates them.

The published integration guide states Rust 1.70 or later. The crate’s own Cargo.toml currently declares rust-version = "1.96" and edition = "2024", which is stricter than the guide states. Until that is reconciled upstream, build against a current stable toolchain rather than relying on 1.70.


use heat_protolib::heat::proto::simulation::*;
use heat_protolib::builders::*;
use prost::Message;
 
let frame = SimulationFrameBuilder::new()
    .with_simulation_tick(42)
    .add_entity(EntityStateBuilder::new()
        .with_entity_fn(|e| e.with_id(100).with_name("Vehicle1"))
        .build())
    .build();
 
let data = frame.encode_to_vec();

Cross-language guarantee

All four packages serialize to the same binary wire format: a message built in C# and written to disk parses correctly in Python, and the reverse. This is a property of Protocol Buffers, not something HEAT ProtoLib adds, but it is the reason the packages exist as four separate builds of one schema rather than four independent libraries: field numbering and encoding are identical, so there is no version-skew hazard between languages, only between schema versions. See Versioning and compatibility.

HEAT Capture team. Last updated 2 October 2026.

Opens your browser's print dialog. Choose "Save as PDF" as the destination.