In our 500-call test the Rust engine used less than half the processor, with nothing lost.

The first pieces of the engine are running in testing, and the numbers are in.

Carrying 500 calls

Same test as before: 500 calls at once, real audio at the real rate, nothing lost either way.

Processor used to carry 500 calls

Before: 1.2 processor cores
With the engine: 0.5 processor cores

Less than half.

The pauses

This is the one we care about most. The old path left a lot of memory to tidy up, and tidying means the whole program stops for a moment.

Time paused for memory cleanup during a 15-second test

Before: 850 milliseconds
With the engine: 40 milliseconds

From most of a second to about a twentieth of one. Under load, those pauses were when audio arrived late.

Converting voice

When two sides of a call use different codecs, each packet is decoded and encoded again. The engine uses the reference Opus library, built from source.

Encoding one packet of telephone-quality speech as Opus

Before: 178 microseconds per packet
With the engine: 48 microseconds per packet

Decoding one packet of Opus

Before: 52 microseconds per packet
With the engine: 13 microseconds per packet

A desk phone talking to a browser now costs about a quarter of the codec work it did.

At a branch

The same engine runs in the branch box. Carrying 400 calls:

Processor used by a branch box to carry 400 calls

Before: 3.0 processor cores
With the engine: 1.9 processor cores

What these numbers are

Measured on our own test desktop, with our own test, on calls between desks. They are not a promise about your hardware.

What they are not

Proof that it is ready. The whole test suite passes with the engine on and with it off, and that is still not the same as real phones spending real time on it. It stays marked as in testing, and off unless switched on, until they have.

The engine's first numbers