Presentum Documentation

A declarative Flutter engine for building dynamic, conditional UI at scale

Build dynamic UI at scale

Presentum is a declarative Flutter engine that helps you manage campaigns, app updates, special offers, tips, and notifications with clean, testable, type-safe code.

Show the right message to the right user at the right time, with impression limits, cooldowns, A/B testing, and analytics - all handled automatically.

Declarative by design

Describe presentations as data. No imperative show/hide logic.

Type-safe

Generics ensure compile-time correctness. No runtime surprises.

Clean architecture

Business logic in guards, UI in outlets, tracking in storage.

Production ready

Eligibility rules, A/B tests, cooldowns, impression tracking built-in.

Quick example

// 1. Define surfaces
enum AppSurface with PresentumSurface {
  homeTopBanner,
  popup;
}

// 2. Create payload
class CampaignPayload extends PresentumPayload<AppSurface, CampaignVariant> {
  final String id;
  final int priority;
  final Map<String, Object?> metadata;
  final List<PresentumOption> options;
}

// 3. Initialize
final presentum = Presentum(
  storage: MyStorage(),
  guards: [CampaignGuard()],
);

// 4. Render
PresentumOutlet(
  surface: AppSurface.homeTopBanner,
  builder: (context, item) => BannerWidget(item),
)

That’s it! Presentum handles eligibility, impressions, cooldowns, and state automatically.

Get started

Introduction

Learn what Presentum is and why it exists

Quickstart

Build your first presentation in 5 minutes

Core concepts

Deep dive into architecture

What you can build

App updates

Force update dialogs, optional upgrade prompts, changelog announcements using Shorebird or CodePush.

Marketing

Special offers with discount codes, limited-time sales, seasonal campaigns, A/B tests.

Onboarding

Feature discovery tips, contextual tutorials, progressive disclosure, completion tracking.

Messaging

User-specific promotions, survey requests, upgrade prompts, time-sensitive alerts.

Production example

Real-world implementation from a live app:

Initialization

final presentum = Presentum(
  storage: CampaignStorage(),
  eventHandlers: [
    PresentumStorageEventHandler(storage: storage),
  ],
  guards: [
    AppOpenedCountGuard(
      appOpenedCount: userRepository.fetchAppOpenedCount,
    ),
    AppLifecycleChangedGuard(
      refresh: AppLifecycleChangedRefresh(),
    ),
    SyncStateWithCandidatesGuard(),
    CampaignSchedulingGuard(eligibility),
    RemoveIneligibleCampaignsGuard(eligibility),
  ],
);

See complete implementation ->

Guides

Basic setup

Complete setup walkthrough

Implementing guards

Build eligibility logic

Implementing storage

Persistent tracking layer

Building outlets

Create presentation widgets

Recipes

Firebase Remote Config

Dynamic campaign management

App update dialogs

Force and optional updates

A/B testing

Multi-variant experiments

Analytics integration

Track impressions and conversions

Powerful features

Eligibility system

Build complex targeting rules with conditions and extractors:

AllOfEligibility(conditions: [
  TimeRangeEligibility(start: start, end: end),
  AnySegmentEligibility(requiredSegments: {"premium"}),
  NumericComparisonEligibility(
    contextKey: 'app_version',
    comparison: NumericComparison.greaterThanOrEqual,
    threshold: 2.0,
  ),
])

Learn more ->

Event system

React to user interactions with flexible handlers:

eventHandlers: [
  PresentumStorageEventHandler(storage: storage),
  AnalyticsEventHandler(analytics),
  BlocEventHandler(bloc),
]

Learn more ->

Transition observers

Monitor state changes with comprehensive diffs:

transitionObservers: [
  BlocTransitionObserver(bloc),
  LoggingObserver(),
]

Learn more ->

Community

GitHub

Source code and issues

pub.dev

Package page and API docs

Ready to start?

Start with the quickstart guide

Build your first Presentum presentation in 5 minutes