Typo-tolerant, in-memory autocomplete for .NET

string[] recipes = [
        "Easy chicken broth soup base recipe",
        "Vegetable noodle soup (chicken optional)",
        "Chicken noodle soup (classic homemade recipe)",
        "Beef noodle soup recipe (Chinese Lanzhou style)"
    ];

var found = recipes.Search("Chicen So"); // 👈 user types this

Console.WriteLine(found.FirstOrDefault());

// → "Chicken noodle soup (classic homemade recipe)"

Autypo works out-of-the-box using a LINQ-style Search extension method without any configuration. The sensible defaults can be overridden.

To make repeated queries against the same data, you'll want to index your collection ahead of time. This is how to get intelligent completions in such a case.

string[] movies = [
    "The Lord of the Rings: The Return of the King",
    "Star Wars: Return of the Jedi",
    "Batman Returns"
];

var index = movies.ToAutypoComplete();

IEnumerable<string> suggestions = index.Complete("retur of the");
// → "Star Wars: Return of the Jedi"
// + "The Lord of the Rings: The Return of the King"

suggestions = index.Complete("bamman rets");
// → "Batman Returns"

No tokenization setup. No fuzzy matching config. Just smart results.

For real-world apps, Autypo integrates seamlessly with ASP.NET Core and supports background indexing, multi-field search, and dependency-injected data sources.

using Autypo;
using Autypo.AspNetCore;
using Autypo.Configuration;

builder.Services.AddScoped<ProductsLoader>();

builder.Services.AddAutypoSearch<Product>(config => config
    .WithDataSource(serviceProvider => serviceProvider.GetRequiredService<ProductsLoader>())
    .WithBackgroundLoading(UninitializedBehavior.ReturnEmpty)

    .WithIndex(product => product.Name, index => index
        .WithAdditionalKeys(product => [product.Description]) // Index name + description
        .WithUnorderedTokenOrdering() // Order of words doesn't matter
        .WithPartialTokenMatching() // Partial queries still match
        // ... and many more configuration options!
    ));

Define a search endpoint using dependency-injected Autypo:

app.MapGet("/products/search", async (
    [FromQuery] string query,
    [FromServices] IAutypoSearch<Product> search) =>
{
    var results = await search.SearchAsync(query);
    return results.Select(r => r.Value);
});

Example Query:

GET /products/search?query=fngerprint usb recogn

Example Result:

[
 {
   "code": "A1067",
   "name": "Fingerprint USB",
   "description": "Secure USB flash drive with fingerprint encryption"
 },
]

• Getting Started
• Installation
• Features
• Limitations
• Perfect For
• Learning Resources
• Samples
• Benchmarks
• Project Structure
• Support and Feedback
• License

Autypo is available on NuGet.

For ASP.NET Core integration (includes the core engine):

dotnet add package Autypo.AspNetCore

For standalone or non-web scenarios (e.g., console apps, background jobs):

dotnet add package Autypo

Autypo gives you fast, typo-tolerant search with modern developer ergonomics — zero config to start, but extreme tuning if you need it.

• Typo-tolerant by default — fuzzy, partial, and out-of-order input
• Token-level matching control (prefix, fuzziness)
• Opt-in partial matching and out-of-order input
• Built to rank “real world” input
• Multi-index support with priority-based short-circuiting

• Index multiple fields (e.g. name + description)
• Plug in custom scorers, filters, and match policies
• Add tokenizers and analyzers (N-grams, stemming, etc)
• Per-query tuning for fuzziness, partial match, max results

• Blazing-fast in-memory autocomplete via IAutypoComplete
• Full-featured, multi-index search engine via IAutypoSearch<T>
• Eager, background, or lazy indexing — your choice
• Refresh indexes at runtime with AutypoRefreshToken
• Async-first, thread-safe, allocation-conscious

• ASP.NET Core integration with full DI support
• Blazor Server–ready (ideal for typeahead inputs)
• Fully .NET-native — no native bindings, no hosted servers

Autypo is intentionally designed for short-text and autocomplete scenarios — not full-text search.

• Documents are limited to 64 tokens max (e.g., product names, commands, short descriptions)
• In-memory indexing is fast and efficient, but may not suit massive corpora or multi-megabyte documents
• Autypo is not intended for long-form text search — for that, consider other tools.

This tradeoff is deliberate: it keeps Autypo incredibly fast, predictable, and ideal for UX-critical search.

• E-commerce product & SKU search
• Admin panel filtering and form helpers
• Smart command palettes
• CLI "Did You Mean?" suggestions
• Blazor autocomplete inputs
• Live-search over reference data (countries, tags, part numbers)
• Fuzzy full-text matching over short documents

For short-string autocomplete, Lucene is overkill — heavy setup, broad scope, and tuned for documents you don't have. Autypo matches its fuzzy quality on this workload with a single NuGet install and zero configuration.

* Levenshtypo is the fuzzy string search library that powers Autypo’s low-level approximate matching engine. It supports typo-tolerant single-token search using optimized Tries and Levenshtein Automata.

⚠️ See full benchmark repo and disclaimer →

/src
  └── Autypo/                   # Core library
  └── Autypo.AspNetCore/        # ASP.NET Core integration
  └── Autypo.Benchmarks/        # Microbenchmarks
  └── Autypo.IntegrationTests/
  └── Autypo.UnitTests/
  └── Autypo.Aot/               # Ensures that Autypo works in AOT scenarios
  
/samples
  └── ApiSearchProducts/        # REST API example
  └── BlazorCities/             # Blazor Server autocomplete
  └── ConsoleDidYouMean/        # CLI demo

🧠 Have a question?
💡 Got feedback?
🐛 Found a bug?

Open an issue or start a discussion. We'd love to hear from you.

Autypo is released under the MIT License.

Autocomplete + Typo-tolerance = Autypo.

Simple name, serious power.

Try it: dotnet add package Autypo