Add custom voice commands to any software with zero latency.

let o = new Rhino(
  accessKey,
  contextPath);

while (!o.process(audio())) { }

let inference = o.getInference();
Build with NodeJS

RhinoManagerCallback
callback =
new RhinoManagerCallback() {
  @Override
  public void invoke(
    RhinoInference inference) {
    // Inference callback
  }
}

RhinoManager o =
new RhinoManager.Builder()
  .setAccessKey(accessKey)
  .setContextPath(contextPath)
  .build(
    appContext,
    callback);

o.start()
Build with Android

let o = RhinoManager(
  accessKey: accessKey,
  contextPath: contextPath,
  onInferenceCallback:
    { inference in
      // Inference callback
    }
  );

try o.start()
Build with iOS

const {
  inference,
  contextInfo,
  isLoaded,
  isListening,
  error,
  init,
  process,
  release,
} = useRhino();

useEffect(() => {
  // Inference callback
}, [inference]);

await init(
  accessKey,
  context,
  model
);
await process();
Build with React

RhinoManager o =
  await RhinoManager.create(
    accessKey,
    contextPath,
    (inference) => {
      // Inference callback
    });

await o.process()
Build with Flutter

let o =
  await RhinoManager.create(
    accessKey,
    contextPath,
    (inference) => {
      // Inference callback
    });

await o.process()
Build with React Native

RhinoManager o =
  RhinoManager.Create(
    accessKey,
    contextPath,
    (inference) => {
      // Inference callback
    });

o.Start();
Build with Unity

constructor(
  private o: RhinoService) {
  this.inferenceDetection =
    o.inference$.subscribe(
      inference => {
        // Inference callback
      }
    )
}

async ngOnInit() {
  await this.o.init(
    accessKey,
    context,
    model
  )
}
Build with Angular

{
  data() {
    const {
      state,
      init,
      process,
      release
    } = useRhino();

    init(
      accessKey,
      context,
      model,
    );

    return {
      s: state,
      process,
      release
    }
  },
  watch: {
    "s.inference": 
      function(o) {
        if (o !== null) {
        // Inference callback
        }
      }
  }
}
Build with Vue

Rhino o = Rhino.Create(
  accessKey,
  contextPath);

while (o.Process(AudioFrame())) {

}

Inference inference =
  o.GetInference();
Build with .NET

Rhino o = new Rhino.Builder()
  .setAccessKey(accessKey)
  .setContextPath(contextPath)
  .build();

while (!o.process(audioFrame())) {

}

RhinoInference inference =
  o.getInference();
Build with Java

o := NewRhino(
  accessKey,
  contextPath)
err := o.Init()

for {
  isFinalized, err :=
    o.Process(AudioFrame())
  if isFinalized {
    break
  }
}

inference, err :=
  o.GetInference()
Build with Go

let o: Rhino =
RhinoBuilder::new(
    access_key,
    context_path
  )
  .init()
  .expect("");

loop {
  if let Ok(is_finalized) =
    o.process(&audio_frame()) {
    if is_finalized {
      if let Ok(inference) =
        o.get_inference() {
        // Inference callback
      }
    }
  }
}
Build with Rust

pv_rhino_init(
  access_key,
  model_path,
  context_path,
  sensitivity,
  require_endpoint,
  &rhino);

while (true) {
  pv_rhino_process(
    rhino,
    audio_frame(),
    &is_finalized);

  if (is_finalized) {
    pv_rhino_get_intent(
      rhino,
      &intent,
      &num_slots,
      &slots,
      &values);
  }
}
Build with C