Nabu 1.0.0-preview.6

Nabu

Razor Class Library for Whisper speech-to-text in Blazor apps. Supports browser (WebGPU/WASM) and server backends.

Getting Started

Cloning the Project

This project uses Git submodules for heavy dependencies. Use the following command to clone everything:

git clone --recurse-submodules https://github.com/dloadinq/nabu.git
cd nabu

Optimizing Submodules (Sparse-Checkout)

To avoid downloading unnecessary files and to prevent build conflicts with Native AOT (e.g., in silero-vad), use Sparse-Checkout. After cloning, run these commands:

# Setup Silero VAD to only include C# examples and the ONNX model
cd external/silero-vad
git sparse-checkout set --no-cone "/examples/csharp/*" "/src/silero_vad/data/silero_vad.onnx"
cd ../..

# Setup NanoWakeWord (only the core library folder)
cd external/NanoWakeWord
git sparse-checkout set --no-cone "/NanoWakeWord/*"
cd ../..

Features

• Dual-backend: Automatically switches between browser inference (WebGPU/WASM) and server inference (Whisper.net via SignalR)
• Live preview: Real-time transcription text while recording
• Voice Activity Detection: Silero VAD (ONNX)
• Wake-word detection: Optional via NanoWakeWord
• Voice commands: Semantic command matching with scoping and JSON/code registration
• Voice navigation: Automatic route-based voice navigation
• 50+ languages supported
• Compatible with Blazor Server, Blazor WebAssembly, Razor Pages, and .NET MAUI

Installation

NuGet (recommended)

Blazor Server / Blazor WebAssembly:

dotnet add package Nabu --version 1.0.0-preview.5

Razor Pages (also includes Blazor support):

dotnet add package Nabu.Server --version 1.0.0-preview.5

Or in your .csproj:

<ItemGroup>
 <PackageReference Include="Nabu" Version="1.0.0-preview.5" />
 
 <PackageReference Include="Nabu.Server" Version="1.0.0-preview.5" />
</ItemGroup>

Project reference (from source)

<ItemGroup>
 
 <ProjectReference Include="../src/Nabu/Nabu.csproj" />
 
 <ProjectReference Include="../src/Nabu.Server/Nabu.Server.csproj" />
</ItemGroup>

Blazor Server

1. Register services

// Program.cs
using Nabu;

builder.Services.AddRazorComponents()
 .AddInteractiveServerComponents();

builder.Services.AddNabu()
 .AddHandler<MyHandler>();

2. Add the SiriWave script to App.razor

<script src="https://cdn.jsdelivr.net/npm/siriwave/dist/siriwave.umd.min.js"></script>

Place this before the closing </body> tag.

3. Add the @using directive to _Import.razor

@using Nabu

4. Implement INabuHandler

using Nabu;

public class MyHandler : INabuHandler
{
 public Task OnTranscriptionReadyAsync(string text)
 {
 // text is never empty or whitespace.
 // Filter NabuConstants.TerminationText / NoRecognizableSpeechText if needed.
 Console.WriteLine($"Transcription: {text}");
 return Task.CompletedTask;
 }
}

5. Add <NabuAssistant> to a page

@page "/"
@rendermode InteractiveServer

<NabuAssistant ShowLanguageSelect="true" />

@rendermode InteractiveServer must be active. You can set it on the page (as above) or directly on the component:

@page "/"

<NabuAssistant ShowLanguageSelect="true" @rendermode="InteractiveServer" />

Razor Pages

1. Register services

// Program.cs
using Nabu;

builder.Services.AddRazorPages();

builder.Services.AddNabu()
 .AddHandler<MyHandler>();

2. Add the SiriWave script to _Layout.cshtml

<script src="https://cdn.jsdelivr.net/npm/siriwave/dist/siriwave.umd.min.js"></script>

Place this before the closing </body> tag.

3. Add the @using and @addTagHelper directives to _ViewImports.cshtml

@using Nabu
@addTagHelper *, Nabu.Server

4. Add <nabu-assistant> to a page

<nabu-assistant show-language-select="true"></nabu-assistant>

<script>
 window.addEventListener('nabu:transcriptionFinal', event => {
 const text = (event.detail || '').trim();
 if (!text) return;

 fetch('?handler=Transcription', {
 method: 'POST',
 headers: { 'Content-Type': 'application/json' },
 body: JSON.stringify({ text })
 });
 });
</script>

// Index.cshtml.cs
public class IndexModel : PageModel
{
 public async Task<IActionResult> OnPostTranscriptionAsync([FromBody] TranscriptionDto dto)
 {
 // handle dto.Text
 return new JsonResult(new { ok = true });
 }

 public record TranscriptionDto(string Text);
}

Voice Commands

Nabu can resolve spoken phrases into discrete command IDs via semantic matching, so you don't need exact keyword lists.

Register commands in Program.cs

builder.Services.AddNabu()
 .AddCommandHandler<MyCommandHandler>()
 .AddCommand("increment", ["add one", "count up"], scope: "/counter")
 .AddCommand("reset", ["reset", "start over"], scope: "/counter");

Register commands from an embedded JSON resource

builder.Services.AddNabu()
 .AddCommandHandler<MyCommandHandler>()
 .AddCommandsFromResource("commands.json");

Simple format (no scope):

{
 "increment": ["add one", "count up", "increment"]
}

Extended format (with scope):

{
 "increment": {
 "scope": "/counter",
 "phrases": ["add one", "count up", "increment"]
 }
}

Both formats can be mixed in the same file.

Implement INabuCommandHandler

using Nabu;

public class MyCommandHandler : INabuCommandHandler
{
 public Task OnCommandAsync(string commandId, string originalText)
 {
 Console.WriteLine($"Command: {commandId} (from: \"{originalText}\")");
 return Task.CompletedTask;
 }
}

Page-level command dispatch with VoiceCommandRegistry

For finer-grained control, inject VoiceCommandRegistry into a page and register callbacks directly:

@inject VoiceCommandRegistry VoiceCommands
@implements IDisposable

@code {
 protected override void OnInitialized()
 {
 VoiceCommands.Register("increment", text => { count++; StateHasChanged(); return Task.CompletedTask; });
 VoiceCommands.Register("reset", text => { count = 0; StateHasChanged(); return Task.CompletedTask; });
 }

 public void Dispose()
 {
 VoiceCommands.Unregister("increment");
 VoiceCommands.Unregister("reset");
 }
}

Voice Navigation

Nabu can generate voice navigation phrases automatically from route mappings:

builder.Services.AddNabu()
 .AddNavigation(nav => nav
 .Map("/", "home", "homepage")
 .Map("/counter", "counter", "counting page"));

This automatically registers phrases like "go to the counter page", "navigate to home", "open the homepage", etc.

Server backend (Nabu.Local)

For server-side inference via Whisper.net, run Nabu.Local as a separate service.

Start

cd src/Nabu.Local
dotnet run
# Listens on http://localhost:50000 by default

Configuration (appsettings.json)

{
 "WhisperLocal": {
 "Url": "http://localhost:50000",
 "Whisper": {
 "GpuModelPath": "models/ggml-medium.bin",
 "CpuModelPath": "models/ggml-medium_q4.bin",
 "Language": "english"
 },
 "Vad": {
 "Threshold": 0.75,
 "MinSpeechDurationMs": 250,
 "MinSilenceDurationMs": 1200
 },
 "WakeWord": {
 "Model": "hey_jarvis_v0.1",
 "Threshold": 0.4
 }
 }
}

If no server is reachable, Nabu falls back to browser inference automatically.

CSS customization

Override the overlay appearance with CSS custom properties:

:root {
 --speech-overlay-bg: rgba(0, 0, 0, 0.65);
 --speech-dialog-bg: rgba(20, 20, 40, 0.95);
 --speech-dialog-radius: 24px;
 --speech-dialog-max-width: 520px;
 --speech-highlight-color: #4ade80; /* "Done." text */
 --speech-visualizer-height: 280px;
 --speech-send-btn-bg: #16a34a;
}

All available variables are listed in src/Nabu/wwwroot/css/speech-overlay.css.

Component parameters

NabuAssistant

Supported languages

Popular: English, German, French, Spanish, Italian, Portuguese, Chinese, Japanese, Korean, Hindi

~45 additional languages are available via NabuLanguages.Extended.

Project structure

src/
 Nabu/ # Razor Class Library (main library, NuGet: Nabu)
 Nabu.Server/ # Server-side components: Tag Helper, ViewComponent, command map (NuGet: Nabu.Server)
 Nabu.Core/ # Internal: audio processing, VAD, Whisper, wake-word
 Nabu.Inference/ # Internal: inference interfaces, embedding, command store
 Nabu.Local/ # Optional standalone server service (Whisper.net + SignalR)
examples/
 Nabu.BlazorDemo/ # Demo: Blazor Server
 Nabu.BlazorWasmDemo/ # Demo: Blazor WebAssembly
 Nabu.RazorPagesDemo/ # Demo: Razor Pages
 Nabu.MauiDemo/ # Demo: .NET MAUI
external/
 silero-vad/ # Voice Activity Detection (git submodule, sparse)
 NanoWakeWord/ # Wake-word detection (git submodule)