Formaze.Blazor.MudBlazor 1.3.1

Formaze.Blazor.MudBlazor

Zero form markup. Developers install, admins design.

Formaze is an embedded no-code form builder for Blazor apps. Add one component — your team configures the form live, without code changes or redeployments.

Define a C# model, drop one component, and let your admins design the form live — drag & drop fields, group them, set labels, all without a redeploy. Try the live demo →

What's new in v1.3.0

• 9 new field types — phone, slider, searchable autocomplete, file upload (with an OnFileUpload streaming handler), password, radio group, rating, multi-select (List<enum>) and tags (List<string>)
• Redesigned field editor — General/Options/Validation/Logic tabs with a live, interactive preview you can type into; validation is enforced in the preview so you can test it without leaving the editor
• Multi-step (wizard) forms — turn sections into steps with progress, Back/Next and per-step validation, in one toggle
• Repeating sections — a List<T> of your own class renders as a repeatable sub-form (Add/Remove rows)
• Section settings & layout — per-section description, conditional section visibility, and full-width / multi-column field widths
• Richer validation — operators, AND/OR and conditional-required, plus cross-field comparison (e.g. end date after start date)
• Localization — English, French, Spanish and German out of the box (all four cover the whole editor), with English fallback

→ Full changelog

What's new in v1.2.0

• Free tier is now unlimited on forms — the previous 3-form cap is gone; the "Powered by Formaze" watermark stays as the Free-tier marker
• JSON config import/export is now Pro — the editor's import/export buttons are reserved for Pro and Enterprise licenses

→ Full changelog

What's new in v1.1.0

• EF Core store — new companion package Formaze.Blazor.MudBlazor.EFCore persists form configs in any EF Core database (SQL Server, PostgreSQL, SQLite…)
• Conditional fields — show a field only when another equals a given value, configured live in the editor
• Custom field renderers — override rendering for any field via the CustomFieldRenderer parameter, with automatic fallback
• JSON export / import in the editor toolbar
• 370 tests — components, stores, sync and licensing

→ Full changelog

How it works

1. Developer installs the package and drops <FormazeComponent> on a page
2. Admin configures the form layout in the live UI — no redeploy needed
3. Users fill in and submit the form

Installation

dotnet add package Formaze.Blazor.MudBlazor

Requires MudBlazor already set up in your project. Targets .NET 8, 9, and 10.

Quick start

1. Register services in Program.cs (MudBlazor must already be registered):

builder.Services.AddMudServices();
builder.Services.AddFormazeJson(options =>
{
    options.LicenseKey = "YOUR_LICENSE_KEY"; // omit for the Free tier
});

2. Add the component to any Blazor page. Key and Model are required; set EditMode to true for admins to configure the form live:

<FormazeComponent T="ContactForm"
                  Key="contact"
                  Model="_model"
                  EditMode="_isAdmin"
                  OnValidSubmit="HandleSubmit" />

@code {
    private ContactForm _model = new();
    private bool _isAdmin = true;

    private void HandleSubmit()
    {
        // _model now holds the validated values
        Console.WriteLine($"{_model.Name} <{_model.Email}>");
    }
}

3. Define your model:

public class ContactForm
{
    [Display(Name = "Full name")]
    [Required]
    public string Name { get; set; } = "";

    [Display(Name = "Email")]
    [Required, EmailAddress]
    public string Email { get; set; } = "";

    [Display(Name = "Message")]
    [DataType(DataType.MultilineText)]
    public string Message { get; set; } = "";
}

Formaze reads the model and generates the form automatically. No Razor, no HTML, no boilerplate.

Supported field types

Admin features

When EditMode is enabled, admins can configure the form live:

• Add / remove fields from the model
• Reorder fields via drag & drop
• Group fields into labeled sections
• Configure each field — label, placeholder, required, min/max, format…
• Changes are saved automatically on exit from edit mode

Store options

Choose where form configurations are persisted:

// JSON files on disk (default)
builder.Services.AddFormazeJson();

// In-memory (prototyping / tests only — lost on restart)
builder.Services.AddFormazeInMemory();

// Custom store (Redis, Azure Blob, your own IFormazeStore)
builder.Services.AddFormaze<MyCustomStore>();

// EF Core — any database (SQL Server, PostgreSQL, SQLite…)
// requires the companion package: Formaze.Blazor.MudBlazor.EFCore
builder.Services.AddFormazeEfCore<MyDbContext>();

Licensing

Get a license → formaze.dev/checkout

Requirements

• .NET 8, 9, or 10
• Blazor Server or WebAssembly (interactive render mode)
• MudBlazor 9.x

Links

• Documentation
• Live demo
• Get Pro