Formaze.Blazor.MudBlazor 1.3.9

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.9

The field-configuration dialog uses its space instead of reserving it: the live preview is a full-width strip above the tabs rather than a column of its own, the settings sit in two columns, field width is a single list (1 to 4 columns, or Full width), and the state toggles read down one column. Every tab is shorter; nothing about saved forms changes.

→ Full changelog

What's new in v1.3.8

Accessibility fix: the column-layout digits added in 1.3.7 were a 22x22 target, below the 24x24 minimum of WCAG 2.5.8. They now match the action buttons beside them.

→ Full changelog

What's new in v1.3.7

The editor's column-layout control is readable without hovering it. The four pictograms shared one outer rectangle and differed only by hairlines about 3 px apart once rendered, so the only way to know what a button did was to wait for its tooltip. They are now a bordered segmented 1 2 3 4, and the selected layout carries a tinted background rather than a colour change alone.

→ Full changelog

What's new in v1.3.6

Each group in the editor now renders as a real container: a hairline border with rounded corners, the section name and its toolbar on a title row above the fields. A section used to be a bold heading followed by loose fields, so nothing showed where the drop area began or ended. Edit mode only, the rendered form is unchanged.

→ Full changelog

What's new in v1.3.5

Editor polish on the group header: Add field is now a + icon button, sized and tooltipped like the rest of the toolbar, instead of the only text button in it. It also stays visible once every model property is placed when the model has a List<DynamicField> DynamicFields property, opening the "Create dynamic field" dialog directly (it used to disappear, leaving no way to create a dynamic field in a new group).

→ Full changelog

What's new in v1.3.3

Hardening release, fully additive. Enums are stored by name in JSON and EF Core (old integer values still load), the JSON store writes atomically, EF Core can run on IDbContextFactory with AddFormazeEfCoreWithFactory<TContext>(), license checks are logged and the key can come from Formaze:LicenseKey in configuration, IFormazeLocalizer lets you add or override any UI string, validation messages show under every field type, and Enter in a tags field no longer submits the form.

→ Full changelog

What's new in v1.3.2

Bug-fix release. bool? properties no longer throw, DateTime time pickers no longer disappear from saved forms on reload, JSON export needs no script of your own, unsupported members are skipped instead of rendered as a crashing text box, validation follows a replaced Model, and numbers parse correctly in comma-decimal cultures. AddFormazeInMemory() now registers a singleton store shared by all users.

→ Full changelog

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
• Automated test suite — components, stores, sync and licensing (bUnit + xUnit)

→ 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

Properties Formaze cannot bind (nested objects, arrays, dictionaries, get-only or private-setter properties, indexers, Guid) are skipped automatically. Group fields into sections with [Display(GroupName = "...")].

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; one shared store for all users)
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>();            // scoped DbContext (AddDbContext)
builder.Services.AddFormazeEfCoreWithFactory<MyDbContext>(); // one context per operation (AddDbContextFactory), recommended on Blazor Server

The JSON file store writes atomically (temp file + move) and serializes concurrent saves of the same key. Every built-in store serializes with FormazeJson.Options (enums by name, nulls omitted); reuse it in a custom IFormazeStore so your backend round-trips the same shape.

Localization

Formaze's own strings (editor, validation messages, wizard, file picker…) follow CultureInfo.CurrentUICulture, with English, French, Spanish and German built in and English as the fallback. To add a language or reword a key, implement IFormazeLocalizer and either set options.Localizer or register it in DI:

public sealed class MyLocalizer : IFormazeLocalizer
{
    public string? Get(string key, CultureInfo culture) =>
        culture.TwoLetterISOLanguageName == "it" && key == "Wizard_Next" ? "Avanti" : null; // null = built-in text
}

builder.Services.AddFormazeJson(options => options.Localizer = new MyLocalizer());
// or: builder.Services.AddSingleton<IFormazeLocalizer, MyLocalizer>();

FormazeLocalization.Keys lists every key; FormazeLocalization.GetBuiltIn(key, culture) returns the built-in text.

Licensing

Get a license → formaze.dev/checkout

Set the key in the AddFormaze* callback, or leave it empty and put it in configuration as Formaze:LicenseKey (appsettings.json, user-secrets, or the FORMAZE__LICENSEKEY environment variable). When logging is configured, Formaze logs the resolved tier, expiry and domain once per scope, and a Warning explaining why a key was ignored (malformed, bad signature, expired, wrong domain).

Requirements

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

Links

• Documentation
• Live demo
• Get Pro