What Becomes Possible
When Every NPC Can Think?
Imagine doubling your NPC population and getting richer emergent behavior instead of a lower frame rate. Warweaver gives you the cognitive runtime to build the systemic worlds that define a generation of games.
Built for Developers. Built for the Future.
We are obsessed with game developers. Every API we write, every optimization we make, and every guarantee we provide is designed to let you ship bold, unprecedented AI with absolute confidence. We handle the impossibly hard cognitive architecture—determinism, vector mapping, and allocation-free serialization—so you can focus on building the magic.
INTELLIGENCE AS CAPEX -> RUNTIME GENERATION
Building this requires a new paradigm. We start by treating Intelligence as a Capital
Expenditure, using
offline Large Language Models to compile human-authored lore into a high-performance vector
space (The Semantic Replication Layer).
But the frontier goes further. For developers who want to push the genre, we
are building
toward runtime memetic generation. Let your players' actions organically spawn new
cultural norms and societal
shifts directly on their machine or your servers—generating endless, unscripted history that is
always validated
and constrained by the laws of physics you define.
The 6-Phase Epoch
Behind the magic is a rigid execution pipeline. Every tick, every agent: Perceive → Strategize → Think → Collect → Apply → Reconcile. Enforced deterministically. No race conditions.
Ship Ambitious Behavior With Confidence
Emergent behavior creates rare, surprising interactions. Warweaver makes them safe to ship. Take a player's save seed, load it on your machine. The exact same outcome replays at the exact same tick. Every decision is traceable.
HOW WE GUARANTEE IT:
Q16.16 Fixed Point Math. No floating point drift.
PCG32 Deterministic RNG. Seed based. Same seed, same sequence.
Canonical Iteration Order. Sorted ID order. No platform dependencies.
Per Tick State Hashing. xxHash64 verification. Drift detection immediate.
Replay Any Moment, Understand Any Decision
When your NPC does something unexpected and brilliant, you can understand exactly why. When a player reports a bug, you replay their exact session. Bit-exact determinism makes emergence debuggable.
// Replay User Bug
// QA reports: "Merchant froze at tick 1247"
// User provides save seed: 0xDEADBEEF
void ReplayUserBug(ulong userSeed, int bugTick)
{
_manager.ResetSimulation(seed: userSeed);
while (_manager.CurrentTick < bugTick)
{
_manager.StepSimulation();
}
ushort merchantId = GetMerchantAgentId();
var trace = _manager.Host.GetReasoningTrace(merchantId, bugTick);
Debug.Log(trace.ToString());
// Fix operator scoring, replay again. Same seed. Same result. Bit exact determinism.
_manager.ResetSimulation(seed: userSeed);
}Complete debugging workflow, reasoning trace analysis, and save/load integration patterns available in evaluation SDK.
Built for the Scale You're Dreaming Of
Most NPC architectures force a choice between smart behavior and large populations. Warweaver was built from day one to do both: 10,000 agents at your target TPS on reference hardware, zero allocation, fully deterministic. Composition-first ECS so your AI logic scales cleanly as your world grows.
SCALE THAT CREATES NEW GAMEPLAY
Emergent faction dynamics that only appear at population scale.
Cascading NPC decisions that ripple across your world.
Every playthrough generates unique stories players share.
Built on an allocation-free kernel. Smooth performance at any population.
Telemetry Patterns
Choose the right pattern for your scale. Small projects use simple snapshots. Large-scale simulations use zero-copy NativeArray views. Performance optimized.
// Standard Scale (0-1000 agents)
// Double-buffer snapshot pattern. Thread-safe. Zero allocation.
void Update()
{
_adapter.SwapTelemetryBuffers();
var snapshot = _adapter.GetTelemetrySnapshot();
for (int i = 0; i < snapshot.AgentCount; i++)
{
var agent = snapshot.Agents[i];
UpdateAgentPosition(agent.AgentId, agent.X, agent.Y);
}
}// Large Scale (1000+ agents)
// Zero-copy NativeArray views for Burst jobs.
NativeArray<float> positionsX = _adapter.GetPositionXView();
NativeArray<float> positionsY = _adapter.GetPositionYView();
[BurstCompile]
struct UpdatePositionsJob : IJobParallelFor
{
[ReadOnly] public NativeArray<float> PositionsX;
[ReadOnly] public NativeArray<float> PositionsY;
public NativeArray<float3> Transforms;
public void Execute(int i)
{
Transforms[i] = new float3(PositionsX[i], 0f, PositionsY[i]);
}
}Complete performance tuning guide, Burst job examples, and optimization strategies available in evaluation SDK.
The Brain and The Body
Unity handles rendering, physics, and presentation. Warweaver handles cognition. They communicate through telemetry, a clean boundary that lets each system do what it does best.
- 100% replayability across platforms. Ship bold AI knowing you can debug anything.
- DOTS/ECS integration. Your AI scales with Unity's most powerful workflow.
- Allocation-free hot loops. Smooth performance even at massive populations.
- Reasoning traces for every decision. Understand exactly why NPCs surprise you.
Warweaver handles cognition. Unity handles rendering, physics, and networking. They each do what they're best at.
Supported Runtimes
Unity only. Additional engines may come later.
| Runtime | Version | Package | Status |
|---|---|---|---|
| Unity | 6.0+ | Unity Package Manager | SUPPORTED |
Is Warweaver Right for Your Game?
Warweaver is purpose-built for games where NPC decisions matter: colony simulations, sandbox RPGs, systemic worlds with large populations. If your game's magic comes from emergent NPC behavior, we'd love to talk.
Closed technical preview. We're working closely with a small number of ambitious teams.
REQUEST EVALUATION