Open-Source Observability · reactiveui

splat

Splat is a .NET library that simplifies cross-platform development by providing abstractions for logging, service location (dependency injection), image loading, and UI drawing primitives. It runs on desktop frameworks (WPF, WinForms, WinUI 3) and mobile platforms (MAUI, Avalonia), with a leaky abstraction pattern allowing fallback to platform-specific code when needed.

Talk to DEV.co Discuss Implementation

Source: GitHub — github.com/reactiveui/splat

995

GitHub stars

140

Forks

Primary language

MIT

License (OSI-approved)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

Field	Value
Repository	reactiveui/splat
Owner	reactiveui
Primary language	C#
License	MIT — OSI-approved
Stars	995
Forks	140
Open issues	14
Latest release	v20.0.0 (2026-06-12)
Last updated	2026-07-08
Source	https://github.com/reactiveui/splat

What splat is

Splat provides a lightweight IoC container (AppLocator) with two AOT-compatible resolver implementations (GlobalGenericFirstDependencyResolver and InstanceGenericFirstDependencyResolver), cross-platform abstractions for images, geometry, logging, and design-time detection. The library targets .NET Framework 4.6.2+, .NET Standard 2.0, .NET 6.0, and .NET 8.0.

Quickstart

Get the splat source

Clone the repository and explore it locally.

terminalbash

1git clone https://github.com/reactiveui/splat.git2cd splat3# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

Multi-platform MVVM applications

WPF, WinForms, and MAUI apps using shared ViewModels that need portable logging, image loading, and geometry primitives without platform-specific branches.

Service location in cross-platform libraries

Libraries targeting multiple .NET platforms that need a lightweight, AOT-friendly IoC container without heavyweight external dependencies.

Design-time and test-detection scenarios

Applications needing to detect unit test runners or design-mode execution to conditionally load resources or initialize test-specific services.

Implementation considerations

Splat uses a 'leaky abstraction' by design—always provide ToNative() and FromNative() extension points so platform-specific logic is testable and obvious.
Default resolver is InstanceGenericFirstDependencyResolver (v19+); GlobalGenericFirstDependencyResolver is ~25–30% faster but uses process-wide static state—choose based on testing/isolation needs.
Logging and service location are separate concerns; logging integrates with NLog and other frameworks, but does not enforce a particular log aggregation pattern.
Image loading abstractions expect platform handlers to be registered at startup; failure to register handlers will raise runtime errors, not compile-time warnings.
Unit test detection (ModeDetector.InUnitTestRunner()) is environment-sniffing; it is not foolproof—document and test test-specific behavior explicitly.

When to avoid it — and what to weigh

Require full-featured DI/IoC with advanced features — Splat is intentionally minimal. If you need factory selection, decorators, interceptors, or module composition beyond basic registration, consider Autofac, Microsoft.Extensions.DependencyInjection, or Ninject.
Single-platform .NET applications — Splat's abstractions add small overhead. Pure WPF or pure ASP.NET Core projects may find fuller-featured alternatives or simpler frameworks more appropriate.
Require runtime configuration from external sources — Splat does not provide configuration management (YAML/JSON loading, environment-based overrides). You must supply configuration separately.
Avoid legacy .NET Framework 4.6.2 support burden — The library explicitly supports older frameworks; if your codebase has dropped legacy support, the compatibility matrix may complicate dependency management.

License & commercial use

MIT License. Permissive, OSI-approved, allows commercial use, modification, and distribution with minimal restrictions (retain copyright and license notice).

MIT License explicitly permits commercial use, modification, sublicensing, and distribution. No patent indemnification clause. Verify your legal review confirms acceptability; no warranty is provided by the authors.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

Signal	Assessment
Maintenance	Active
Documentation	Adequate
License clarity	Clear
Deployment complexity	Low
DEV.co fit	Good
Assessment confidence	High

Security considerations

Splat does not provide security-specific features (encryption, authentication, authorization). It is a utility library. Application security depends on correct use of platform APIs (e.g., secure image storage) and does not introduce cryptographic or credential-handling code. Service location allows arbitrary types to be injected; validate registration sources to prevent injection attacks.

Alternatives to consider

Microsoft.Extensions.DependencyInjection

Modern, full-featured, supports .NET Standard 2.0+ and .NET Framework 4.6.2+. Heavier than Splat but more widely adopted in ASP.NET Core and enterprise projects. No cross-platform drawing or image abstractions.

Autofac

Mature IoC container with advanced features (decorators, factories, modules, interceptors). Supports multiple .NET versions. Heavier than Splat; not specifically designed for mobile or minimal-overhead scenarios.

Prism (formerly Prism Library)

Full MVVM framework for WPF and XAMARIN-based platforms. Includes module system, event aggregation, navigation. Significantly heavier than Splat; better for complex multi-module enterprise UIs, overkill for simple service location.

Software development agency

Build on splat with DEV.co software developers

Splat simplifies cross-platform .NET development with minimal overhead. Review the GitHub repository, benchmark the resolvers for your use case, and consult the community Slack for integration questions.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

izumi yokai fastapi-observability

Related on DEV.co

Explore the category and the services that help you build with it.

Open-Source Observability Application Development Enterprise Software Talk to DEV.co

splat FAQ

Can I use Splat without the service locator?

Partially. Core abstractions (logging, images, geometry, design detection) are independent. Service location via AppLocator is optional but central to the library's design. You can ignore AppLocator if you do not need DI.

Does Splat work with async/await and reactive patterns?

Unknown from provided data. The library is part of the ReactiveUI ecosystem (same org), but the README does not explicitly document async patterns, Tasks, or Observables. Review source or community channels for guidance.

What platforms are supported?

WPF, Windows Forms, WinUI 3, MAUI (WinUI, Android, iOS, macOS), and Avalonia. Supports .NET Framework 4.6.2, 4.7.2, .NET Standard 2.0, .NET 6.0, and .NET 8.0. No Xamarin (legacy) support mentioned.

How do I choose between GlobalGenericFirstDependencyResolver and InstanceGenericFirstDependencyResolver?

Global is ~25–30% faster; use it if you have a single global AppLocator and predictable registration patterns. Instance is safer for libraries and tests (isolated state per resolver); use it if you create multiple isolated resolver instances or run parallel tests.

Work with a software development agency

Need help beyond evaluating splat? DEV.co is a software development agency offering software development services and web development for teams of every size. Our software developers and web developers build custom software, web applications, APIs, and open-source observability integrations — and maintain them long-term.

Evaluate Splat for Your .NET Project

Talk to DEV.co Schedule a Consultation