# bitplatform for Blazor and C# application development

> bitplatform combines reusable Blazor components, browser APIs, routing, offline data, PWA support, and application templates in a C# toolchain. It fits developers building across WebAssembly, Blazor Server, and Hybrid apps, but its breadth also increases framework dependencies.

**bitfoundation/bitplatform** — Build all of your apps using what you already know and love ❤️

- Repository: https://github.com/bitfoundation/bitplatform
- Website: https://bitplatform.dev
- Stars: 1,381 · Forks: 264
- Language: C#
- License: MIT
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/bitfoundation-bitplatform

## What bitplatform solves for Blazor application teams

bitplatform addresses the assembly work that normally appears after a team selects Blazor and C#. The repository provides UI components, browser-facing services, routing, offline storage, progressive web app support, source generation, analyzers, build tools, and templates. Its intended users are developers who already work with Blazor and .NET but do not want every application to assemble those pieces independently.

The scope is broad. The libraries target .NET 8, 9, and 10, with support stated for Blazor WebAssembly, Blazor Server, and Hybrid applications using MAUI. The bit Boilerplate template goes further, presenting a full-stack option for Web, Android, iOS, Windows, and macOS from a single codebase. It also offers choices such as identity, multilingual interfaces, offline synchronization, caching, OpenTelemetry, an AI chatbot with RAG, .NET Aspire, and CI/CD pipelines.

That breadth is useful when an application needs several of those capabilities. It also makes bitplatform a poor default for a small Blazor application that needs only a component library or one browser API. In that situation, the relevant `Bit.BlazorUI` or `Bit.Butil` package may be more proportionate than starting from the full template.

## Inside bit BlazorUI, Brouter, Butil, and Besql

The platform separates application concerns into packages with specific responsibilities. `Bit.BlazorUI` contains more than 90 accessible components with light and dark themes and right-to-left support. Additional packages extend that set with components including DataGrid, Chart, PdfViewer, RichTextEditor, Map, FullCalendar, CountryPicker, and TimeZonePicker. Icons and visual assets have separate packages, which allows an application to reference only the groups it needs.

`Bit.Brouter` handles navigation. According to the README, it provides declarative and nestable routes, asynchronous guards, data loaders, named routes, query-string binding, and global navigation hooks. It is the default router in bit Boilerplate, so adopting the template also adopts this routing model unless it is replaced or reconfigured.

`Bit.Butil` exposes browser facilities through injectable, strongly typed C# services. The listed areas include the DOM, storage, media, sensors, cryptography, and workers. The stated purpose is to avoid dropping into JavaScript for these operations. This does not make every browser interaction C# only, but the documented surface reduces the amount of JavaScript interop a Blazor application must write.

For persistent browser data, `Bit.Besql` combines EF Core and SQLite in the browser. The repository describes it as a means of building offline-capable web applications that store data locally and synchronize it later. This is a narrower architecture than a normal server-backed application, and the README does not document conflict handling, synchronization limits, or the exact later sync mechanism.

## From `bit new` to a selected application template

The documented first use begins with the global `Bit.Cli` tool. Install it with prerelease packages, then create an application named `MyApp`. The README states that this works on Windows, macOS, and Linux.

```bash
dotnet tool install --global Bit.Cli --prerelease
bit new MyApp
```

The first command installs `Bit.Cli` globally. The second starts the `bit new` project flow. According to the README, `bit new` installs the .NET SDK, Node.js, Docker, the Aspire CLI, and other requirements, builds the application, initializes git, adds the first migration, and opens the IDE. The create-project documentation at `bitplatform.dev/templates/create-project` presents selectable options and generates the command.

This is more than a source template copier. The command performs environment setup and initial project operations, which makes it more relevant to a new machine than a script that only writes `.csproj` and Razor files. It also means the first use has external prerequisites and side effects. A team should review the generated command and selected options before running it on a workstation where SDK, container runtime, or Git state is already controlled by policy.

The repository also offers `Bit.BlazorEmpty` for a minimal Blazor start. The README does not give separate commands for that template, so the documented `bit new` flow above is the only installation tutorial presented there.

## Boilerplate scope versus the minimal Blazor template

bit Boilerplate is the heavier option. It combines the platform libraries into a cloud-ready full-stack template and exposes optional feature groups during project creation. These include passwordless authentication, two-factor authentication, SSO, localization with RTL, an offline database and synchronization, caching, OpenTelemetry, an AI chatbot with RAG, .NET Aspire, and CI/CD pipelines.

This creates a concrete trade-off. Selecting optional capabilities can shorten the path to a full application, but it also gives a new repository several architectural choices to review. Identity affects authentication and account flows. OpenTelemetry adds instrumentation choices. The offline database changes where data lives and how synchronization must work. CI/CD introduces external systems. Native integration and third-party Java, Kotlin, Swift, Objective-C, and JavaScript libraries affect platform packaging.

`Bit.BlazorEmpty` is the smaller alternative within the same repository. It is described as a minimal Blazor template for starting from scratch. A team that needs bitplatform components but does not want the Boilerplate services should compare that route with installing only the specific `Bit.BlazorUI`, `Bit.Brouter`, `Bit.Butil`, or other package. The README does not document a complete command matrix for selecting individual packages, so it would be misleading to present `bit new` as a package-only installer.

## Build tooling, analyzers, PWA updates, and older browser support

The build and tooling packages address recurring Blazor application concerns. `Bit.Minifier` reduces the size of .NET assemblies downloaded by a Blazor WebAssembly application by stripping non-public names and compiler-only attributes after trimming. Its documented workflow is to install it and publish in Release mode, with no additional configuration stated. The repository does not publish size figures, so claims about a particular reduction would require independent measurement.

`Bit.CodeAnalyzers` applies the project's preferred practices during development. `Bit.SourceGenerators` produces code aimed at quality and performance. These packages can improve consistency within a team that accepts those practices, but they also create project-specific rules that contributors must understand. The README does not list the individual diagnostics or generated outputs.

`Bit.Bswup` converts a Blazor application into a PWA and presents service-worker update progress. Its documented support for prerendering gives applications a controlled path from server-rendered output toward a progressively enhanced web app. This is not the same as making an application offline-capable by itself. Offline persistence belongs to `Bit.Besql`, while the PWA layer handles application delivery and updates.

For older clients, `Bit.BlazorES2019` provides an ES2019 build of the Blazor scripts. The README gives Safari before 16.4 and older WebViews as examples of environments it targets. This package expands browser coverage but introduces a compatibility decision at build time. Teams should first establish whether their actual user-agent distribution requires it.

## Constraints in multi-platform, offline, and generated code

The main limitation is architectural rather than an absence of components. bitplatform aims to coordinate several packages and a generated full-stack structure. A team adopting only `Bit.BlazorUI` does not automatically inherit offline storage, a service worker, the default router, or native packaging. Each capability has its own package and configuration boundary.

The Hybrid and desktop promise also depends on target-platform tooling. The Boilerplate supports native integration and third-party wrappers for Java, Kotlin, Swift, Objective-C, and JavaScript, but the README does not specify version matrices for each platform toolchain. Release readiness therefore cannot be inferred from the statement that Web, Android, iOS, Windows, and macOS are supported. Platform requirements need direct verification in the generated project and relevant documentation.

`Bit.Besql` presents another boundary. Its description supports local EF Core and SQLite storage plus later synchronization, but it does not explain multi-user conflict resolution, migration behavior in browsers, or storage quotas. Offline support should therefore not be interpreted as guaranteed multi-device consistency.

The CLI adds convenience but also performs substantial machine setup. It installs development dependencies, builds the result, initializes git, and adds a migration. That sequence is suitable for a fresh development environment, though the README does not describe a dry run, partial rollback, or clean-up procedure for every failure point. Developers working under managed workstation policies should inspect those effects before installation.

## Maintenance signals, releases, and MIT licensing

The repository is not archived, and the last push was on 2026-10-15. Recent release records include v-10.6.1 on 2026-09-19, v-10.6.0 on 2026-09-13, and v-10.5.0 on 2026-07-20. These facts indicate recent repository activity, but the README does not provide a compatibility policy, upgrade guide, long-term-support schedule, or migration guide between these versions.

Upgrading may affect more than application code because the platform spans packages, analyzers, source generators, the router, templates, and generated project structure. The README does not give version compatibility mappings or a command for upgrading an existing Boilerplate project. That omission matters when evaluating long-term maintenance cost. A team should not assume that changing a package version alone preserves the generated architecture.

The repository identifies the project as licensed under MIT. That designation indicates the stated license, but the README does not summarize notice requirements or address dependencies separately. Teams still need to inspect the repository `LICENSE` and review the licenses of packages, templates, native libraries, and third-party integrations they use. The MIT label should not be treated here as legal advice about a particular distribution.

## Conclusion

Developers who want a preconfigured Blazor application spanning web and supported desktop or mobile targets may adopt bitplatform, while teams that require a minimal dependency set or only one runtime should first inspect the generated solution and optional features. Before adoption, verify support for the required .NET version, target platforms, identity mode, offline database, telemetry, CI/CD choices, and third-party library integrations in the project created by `bit new`.

## FAQ

### How do I install bitplatform and create a project?

Install the `Bit.Cli` .NET tool with `dotnet tool install --global Bit.Cli --prerelease`, then run `bit new MyApp`. The README states that this is supported on Windows, macOS, and Linux.

### Which application models does bitplatform support?

The libraries target .NET 8, 9, and 10 and support Blazor WebAssembly, Blazor Server, and Hybrid apps. bit Boilerplate can generate unified Web, Android, iOS, Windows, and macOS applications from one codebase.

### Does bitplatform support offline data and PWA updates?

Yes, through separate components. `Bit.Besql` provides browser-based EF Core and SQLite for local data and later synchronization, while `Bit.Bswup` adds PWA service-worker behavior and update progress.

## Sources

- [bitfoundation/bitplatform on GitHub](https://github.com/bitfoundation/bitplatform)
- [License: MIT](https://github.com/bitfoundation/bitplatform/blob/develop/LICENSE)
- [Project website](https://bitplatform.dev)
- [README](https://github.com/bitfoundation/bitplatform/blob/develop/README.md)
- [Releases](https://github.com/bitfoundation/bitplatform/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/bitfoundation-bitplatform