All properties

Every property spring_boot_starter_flutter reads, grouped by prefix. Each row gives the key, its type and allowed values, its default, what it does, and the page that explains it. Some keys are read by the app when it starts; others are read by spring_core_dart_generator at build time, which writes them into the app or into web/. The column "Read" says which.

Why

Most of the starter is configured with properties, not code. This page is the one place where all of them are listed, so you can check a key, its default and its unit without reading every page. The starter's metadata (lib/spring_gen/spring_metadata.json) describes the same keys, so editors with completion offer them too.

How to write them

Every key can be written in application.yml or application.properties in lib/resources/, in a profile file (application-web.yml, application-release.yml), in an imported file, or as a --dart-define. Names are relaxed: debug-banner, debugBanner and DEBUG_BANNER are the same key. Durations take ms, s, m, h, d (400ms, 5s). See Configuration in a Flutter app.

Example

A realistic configuration of a shop's app, split over three files.

# lib/resources/application.yml
spring:
  config:
    import: resources:themes/brand.yml
  flutter:
    app:
      type: material
      title: NEON Books
      description: The bookshop of the NEON district.
      debug-banner: false
      locales: en, ja
    shortcuts:
      search.open: [primary+k, slash]
      debug.open: [primary+shift+d, taps:4+hold:3s]
    lifecycle:
      pause-in-background: true
    fonts:
      auto-load: true
      exclude: [assets/pdf/**]
    splash:
      tasks:
        timeout: 5s
        share: 0.2
    theme:
      active: system
      remember: true
      seed-color: deepPurple
  datasource:
    url: sqlite:file:books.db
    sqlite:
      location: support
# lib/resources/application-desktop.yml
spring:
  flutter:
    desktop:
      window:
        title: NEON Books
        title-bar: transparent
        initial-size: 1280x800
        min-size: 800x600
# lib/resources/application-web.yml
spring:
  flutter:
    splash:
      yield-frames: true
      frame-budget: 8ms
      warm-up:
        text:
          enabled: true
    web:
      page:
        swipe-to-close: false
        max-pixel-ratio: 2
        translate: false
      dev-server:
        port: 5050
        proxy:
          - prefix: /api/
            target: http://localhost:8080
      seo:
        enabled: true
        site-url: https://books.example.com
        from-routes: true

The shop's app is a Material app: type: material and seed-color need spring_boot_starter_flutter_material in its dependencies (see Design libraries). With that starter as its one design starter, type: material may be left out: the starter decides.

spring.flutter.app

Read at the start. See The app widget.

Key Type Default Meaning
spring.flutter.app.type text: widgets, material, cupertino, or the type of an app factory of your own not set: the one design starter's type (material, cupertino), else widgets; with several, required The app widget: WidgetsApp, MaterialApp (needs spring_boot_starter_flutter_material) or CupertinoApp (needs spring_boot_starter_flutter_cupertino)
spring.flutter.app.title text empty The app's name for the OS (task switcher, browser tab); the web build writes it into web/index.html and web/manifest.json
spring.flutter.app.description text none What the app is, in a sentence; the web build writes it into web/index.html (<meta name="description">) and the manifest
spring.flutter.app.debug-banner bool true Flutter's DEBUG banner in debug builds
spring.flutter.app.locales comma-separated language tags (en,ja,pt_BR) the languages of the message files The locales the app supports; one comma-separated value, also in YAML

spring.flutter.app.type is deduced as Spring Boot deduces spring.main.web-application-type from the class path: one design starter (or one SpringAppFactory bean of the app's own type) makes the app of its type, none makes it widgets. With app factories of several types, both design starters for instance, the start fails, naming the property and the types, until one is chosen, for every platform or per platform in a profile (application-ios.properties). Set, the property always wins. See The type when not set.

spring.flutter (general)

Key Type Default Read Meaning Page
spring.flutter.scan-os-environment bool false at the start, from --dart-define only Reads the OS environment variables as properties (useful on desktop). A configuration file cannot set it Configuration
spring.flutter.shortcuts.<action> a key, a tap pattern, or a list the action's @Shortcut(keys:) at the start The keys or taps of an action: primary+k, char:?, taps:4+hold:3s, [alt+left, primary+bracket-left] Shortcuts

spring.flutter.lifecycle and spring.devtools

Key Type Default Meaning Page
spring.flutter.lifecycle.pause-in-background bool true Pauses the context in the background (@Scheduled tasks, WebSocket connections and other pauseable lifecycle beans stop) and restarts it in the foreground The app lifecycle
spring.devtools.restart.enabled bool true A hot reload restarts the context when the generated code changed: beans, annotations or lib/resources/ Hot reload

spring.flutter.fonts

Key Type Default Meaning Page
spring.flutter.fonts.auto-load bool true Loads every .ttf and .otf asset before the first frame, into the family the file names Assets and fonts
spring.flutter.fonts.exclude list of globs none Font assets not to load (assets/pdf/**) Assets and fonts
spring.flutter.fonts.families.<family>.files list of assets none The files of a family declared by name (.woff2 on the web too) Assets and fonts
spring.flutter.fonts.families.<family>.languages list of language tags none The languages the family is for: loaded only when the app shows one of them Assets and fonts

spring.flutter.splash

Read at the start. The splash's look is the theme's splash. See The splash and the start.

Key Type Default Meaning
spring.flutter.splash.yield-frames bool true on the web, false elsewhere Lets Flutter draw a frame between the beans while they are created, so the splash keeps moving; false turns the pacer off
spring.flutter.splash.frame-budget duration 8ms The work between two frames when yield-frames is on
spring.flutter.splash.trace bool false Measures the start (each stage, each bean's creation), logged at the end; on the web also in the Performance tab
spring.flutter.splash.tasks.enabled bool true Runs the SplashTask beans before the app shows; false: none runs
spring.flutter.splash.tasks.timeout duration 5s How long the splash waits for the tasks; one still running goes on behind the app
spring.flutter.splash.tasks.share number, 0 to 1 0.2 The loader's share the tasks take, when the app has any
spring.flutter.splash.warm-up.text.enabled bool false Lays out the characters of the app's text while the splash shows, so the fonts they need are downloaded first (worth it on the web)
spring.flutter.splash.warm-up.text.resources list of location patterns resources:messages*.properties The files whose characters are laid out
spring.flutter.splash.warm-up.text.first-font duration 400ms No font downloaded in that time: none is needed
spring.flutter.splash.warm-up.text.settle duration 250ms After a font came in, how long without another before the warm-up ends
spring.flutter.splash.warm-up.text.chunk number 200 How many characters are laid out in one frame

spring.flutter.debug and spring.flutter.frame-meter

Key Type Default Read Meaning Page
spring.flutter.debug.enabled bool not set by the generator (and at the start) true: the debug panel is in every build. false: in none (no code). Not set: in debug and profile builds only The debug panel
spring.flutter.debug.frame-meter.enabled bool not set by the generator (and at the start) The same, for the frame meter module: true: in every build. false: in none (no code). Not set: in debug and profile builds only The debug panel
spring.flutter.debug.motion.enabled bool not set by the generator (and at the start) The same, for the motion switch module The debug panel
spring.flutter.debug.timeline.enabled bool not set by the generator (and at the start) The same, for the timeline module; with it, each bean's creation is measured The timeline
spring.flutter.debug.timeline.position corner bottom-left at the start The corner of the timeline's pill The timeline
spring.flutter.debug.isolates.enabled bool not set by the generator (and at the start) The same, for the task manager module The task manager
spring.flutter.debug.isolates.position corner bottom-right at the start The corner of the task manager's table The task manager
spring.flutter.debug.isolates.interval duration 1s at the start How often the task manager reads its rows The task manager
spring.flutter.debug.drag.enabled bool not set: never by the generator true: the debug overlays can be dragged; otherwise no code for it Debug overlays
spring.flutter.debug.overlays.layout auto, stack, pages auto at the start How the overlays of one corner are put together Debug overlays
spring.flutter.debug.overlays.max-height fraction 0.4 at the start The room of a corner for auto Debug overlays
spring.flutter.debug.overlays.margin.top / bottom / left / right logical pixels 0 at the start Room past the safe area Debug overlays
spring.flutter.debug.overlays.drag.snap corners, free corners at the start Where a dropped overlay goes Debug overlays
spring.flutter.debug.overlays.drag.remember bool true at the start Whether a moved overlay keeps its place after a restart Debug overlays
spring.flutter.frame-meter.enabled bool false at the start Shows the frame meter over the app The frame meter
spring.flutter.frame-meter.position top-left, top-right, bottom-left, bottom-right top-right at the start The corner it shows in, inside the safe area The frame meter
spring.flutter.markdown.placeholders bool false at the start (and by the generator) Replaces each {{key}} of a Markdown page by the configuration's value of the key; one without a value stays Markdown
spring.flutter.frame-meter.target-rate number 60 at the start The frames a second the screen is meant to show: within 1 / target-rate is good, up to twice that a warning, more a drop The frame meter

spring.flutter.desktop.window

Read at the start, on macOS, Windows and Linux only. See The desktop window.

Key Type Default Meaning
spring.flutter.desktop.window.title text the runner's The window's title (title bar, Dock, taskbar, window switcher); a blank value is none
spring.flutter.desktop.window.title-bar default, transparent, hidden default The OS's title bar, a transparent one the content is drawn under, or none
spring.flutter.desktop.window.initial-size <width>x<height>, logical pixels the runner's The content size when the window opens, centered
spring.flutter.desktop.window.min-size <width>x<height> none The smallest size the user can drag the window to
spring.flutter.desktop.window.max-size <width>x<height> none The largest size the user can drag the window to

spring.flutter.web.page

Read by the generator, which writes them into web/index.html. See The web.

Key Type Default Meaning
spring.flutter.web.page.swipe-to-close bool true false: a swipe down in apps' own browsers (a messenger's, a social app's) scrolls the app instead of closing the page
spring.flutter.web.page.max-pixel-ratio number, 1 or more the screen's own The most pixels for each point Flutter draws at; 2 draws a 3x phone screen 2.25 times cheaper
spring.flutter.web.page.translate bool true false writes translate="no" and <meta name="google" content="notranslate">, so no translation is offered
spring.flutter.web.page.wasm-allow-list.<engine> bool per engine: blink, gecko, webkit not set: Flutter's own, Chrome and Edge only The browser engines that run a --wasm build's WebAssembly: gecko Firefox 147+, webkit Safari 26.2+; another name or value fails the build

spring.flutter.web.dev-server

Read by the generator, which writes web_dev_config.yaml for flutter run (Flutter 3.38 and later). See The web and The web dev server.

Key Type Default Meaning
spring.flutter.web.dev-server.host text, not empty any address The address the dev server listens on (localhost, 0.0.0.0)
spring.flutter.web.dev-server.port integer, 0 to 65535 a free port The port; 0 picks a free one; a port browsers block is a warning
spring.flutter.web.dev-server.base-href path starting and ending with / / The path the app is served under
spring.flutter.web.dev-server.https.cert-path file path none (HTTP) The TLS certificate (PEM); set both HTTPS keys or neither
spring.flutter.web.dev-server.https.cert-key-path file path none The certificate's private key (PEM)
spring.flutter.web.dev-server.headers.<Name> text none A header added to every response
spring.flutter.web.dev-server.proxy[n].target absolute URL none Where requests matching rule n are forwarded; required
spring.flutter.web.dev-server.proxy[n].prefix path none Rule n matches paths starting with it
spring.flutter.web.dev-server.proxy[n].regex regular expression none Or paths matching it; exactly one of prefix and regex
spring.flutter.web.dev-server.proxy[n].replace text the path unchanged The forwarded path, $1 for a group
spring.flutter.web.dev-server.content-security-policy text none; a ready policy in spa mode The Content-Security-Policy header
spring.flutter.web.dev-server.content-security-policy-report-only bool false Sends the policy as Content-Security-Policy-Report-Only
spring.flutter.web.dev-server.content-security-policy-connect-src list of origins none Origins added to the connect-src of spa mode's ready policy

spring.flutter.web.seo

Read by the generator, which writes the pages into web/. See SEO and Pages for search engines.

Key Type Default Meaning
spring.flutter.web.seo.enabled bool false Whether the build writes the pages
spring.flutter.web.seo.site-url URL none; required when enabled The site's address for canonical, og:url and the sitemap
spring.flutter.web.seo.from-routes bool false Every screen of the navigation starter is a page
spring.flutter.web.seo.title text {title} The <title> pattern; {title} is the page's own
spring.flutter.web.seo.description text none The description of a page that has none
spring.flutter.web.seo.image location or URL none The preview image of a page that has none (about 1200×630)
spring.flutter.web.seo.site-name text none og:site_name
spring.flutter.web.seo.exclude list of globs none Files of every Markdown folder left out (**/contents*.md)
spring.flutter.web.seo.content[n].location location none A folder of Markdown files, a page per file
spring.flutter.web.seo.content[n].path path / The folder's address
spring.flutter.web.seo.content[n].exclude list of globs none Files of that folder left out
spring.flutter.web.seo.pages[n].path path none A page by hand, or a route's page overridden
spring.flutter.web.seo.pages[n].title text none Its title
spring.flutter.web.seo.pages[n].description text none Its description
spring.flutter.web.seo.pages[n].image location or URL none Its preview image
spring.flutter.web.seo.pages[n].index bool true false: noindex, not in the sitemap
spring.flutter.web.seo.sitemap bool true Writes sitemap.xml and robots.txt
spring.flutter.web.seo.llms bool true Writes llms.txt and llms-full.txt
spring.flutter.web.seo.markdown bool true Writes each page's Markdown next to it (<path>.md)
spring.flutter.web.seo.page-files directory, html directory <path>/index.html or <path>.html

spring.flutter.resources

Read at the start. See Resources from the network.

Key Type Default Meaning
spring.flutter.resources.cache.enabled bool true Whether an http: or https: resource of the ResourceLoader (a Resource of @Value, ResourceView, ResourceImage) is downloaded once and kept in the files' cache place, under spring/resources/
spring.flutter.resources.cache.max-age duration 7d How long a kept resource is used as it is; past it, it is still used and asked again in the background with If-None-Match / If-Modified-Since (an unchanged one costs no download)
spring.flutter.resources.cache.max-entry-size data size 50MB The largest resource kept; a larger one is read from the network every time
spring.flutter.resources.cache.max-size data size (200MB) none: only the system's limit The most bytes the kept resources take together; past it the least recently used go first. Only their folder counts (spring/resources/): the @Cacheable caches on disk (spring.cache.disk.max-size) have limits of their own
spring.flutter.resources.cache.locations[n].pattern address pattern: ** any path, * one segment none The addresses rule n is for (https://avatars.steamstatic.com/**); the first rule that matches wins
spring.flutter.resources.cache.locations[n].max-age duration spring.flutter.resources.cache.max-age The age of the resources the rule matches
spring.flutter.resources.cache.locations[n].enabled bool true false: the resources the rule matches are not kept, and are read from the network every time
spring.flutter.resources.view.fade duration 200ms How long a ResourceView fades its resource in over its placeholder once it is there; 0 shows it at once, and so does less motion asked by the system

spring.datasource (SQLite)

Read at the start when the app has spring_boot_starter_data and a SQL data source. See SQLite databases.

Key Type Default Meaning
spring.datasource.url URL none The database URL; with a relative sqlite:file: name the file goes into the app's directory
spring.datasource.sqlite.location support, cache, documents support Which directory of the app holds the databases; any other value stops the start
spring.datasource.sqlite.base-directory path the directory of location Set by the starter, at the lowest precedence; your own value wins
spring.datasource.sqlite.isolate bool true Set by the starter: each connection on an isolate of its own; false keeps the calls on the UI isolate
spring.datasources.<name>.url URL none The same for a named data source
spring.datasources.<name>.sqlite.location support, cache, documents support The same for a named data source

spring.flutter.theme

The look of the app. Read at the start, and by the generator for the typed keys (context.theme) and the web page loader. The theme has its own reference: the keys at the root and in each themes.<name> are listed on Theme properties, the Material components on Component themes of the Material starter, cupertino.* on Cupertino theme properties.

Key Type Default Meaning Page
spring.flutter.theme.active system or a theme name system The theme shown at start Theme properties
spring.flutter.theme.system-light theme name light What system shows in the device's light mode Theme properties
spring.flutter.theme.system-dark theme name dark What system shows in the device's dark mode Theme properties
spring.flutter.theme.remember bool true Keeps the theme the user chose between runs and shows it again behind the splash Themes
spring.flutter.theme.source https URL or github:owner/repo/path@ref none A file downloaded for every theme, its values shared by all of them Theme properties
spring.flutter.theme.source-sha256 64 hex digits none Refuse a download with another digest Theme properties
spring.flutter.theme.refresh duration none Look at the address again in the background when the cache is older Theme properties
spring.flutter.theme.themes.<name>.extends theme name the root The theme it starts from Theme properties
spring.flutter.theme.themes.<name>.source, .source-sha256, .refresh as above none A theme downloaded from a URL, cached and refreshed Theme properties
brightness light, dark light (dark for dark) Whether the theme is light or dark Theme properties
seed-color color none: Flutter's baseline palette The color the palette is made from. Needs a design starter (Material or Cupertino); without one the start fails Colors
scheme-variant tonal-spot, fidelity, content, vibrant, expressive, monochrome, neutral, rainbow, fruit-salad tonal-spot How the palette is made from the seed. Needs a design starter Colors
contrast number, -1 to 1 0 The palette's contrast. Needs a design starter Colors
colors.<role> color from the seed, else Flutter's baseline One of the 46 Material roles Colors
typography.* map Material's Font family, fallbacks, the 15 text styles and code Typography
shape.<token> number Material 3's The corner scale Shape, spacing and elevation
elevation.<level> number 0, 1, 3, 6, 8, 12 level0 to level5 Shape, spacing and elevation
spacing.<name> number xs 4, s 8, m 16, l 24, xl 32 Gaps of your own widgets Shape, spacing and elevation
visual-density adaptive, standard, comfortable, compact Flutter's How tightly components are packed. Read by spring_boot_starter_flutter_material Density and ink
tap-target-size padded, shrink-wrap Flutter's The minimum tap area. Read by spring_boot_starter_flutter_material Density and ink
splash ripple, sparkle, none, or a map Flutter's ink The ink effect of taps (read by spring_boot_starter_flutter_material), or (as a map) the splash screen of the start (every app) Loaders and the splash
motion.* map page-transition, text-change, content-change, scroll-to-top, wheel-scroll, overscroll, durations, curves; the zoom and cupertino transitions need their design starter Motion and animations
animations.<name>.* map none Named animations: duration, curve, repeat Motion and animations
components.<component>.* map Material 3's One of the 49 Material component themes. Read by spring_boot_starter_flutter_material Component themes
cupertino.* map iOS's The CupertinoThemeData. Read by spring_boot_starter_flutter_cupertino Cupertino theme properties
tokens.* any none Your own values, at any depth Tokens and references
styles.<name>.* map none A look per state for your own widgets Styles and states
styles.code.*, styles.heading.*, styles.link.color, styles.table.*, styles.callout.* map the color scheme The look of MarkdownView MarkdownView
syntax.<language>.* map none The languages of code blocks Styles and states
background.* map none A color, image, overlay and animation behind every screen Background
loaders.<name>.* map none Loaders for ThemeLoader, ThemeSkeleton and the splash Loaders and the splash
frame-meter.* map the color scheme The look of the frame meter The frame meter

The keys from brightness down are written at the root of spring.flutter.theme (shared by every theme) or in spring.flutter.theme.themes.<name>.

The properties of a design (components, visual-density, tap-target-size, a single-value splash, cupertino) are accepted in an app without the starter that reads them: they are not shown and not checked, and one INFO line on spring_boot_starter_flutter.SpringThemes names the starter, once per property. Their keys are still checked: a misspelled componets fails the start.

Keys of other modules the starter uses

Key Type Default Meaning Page
spring.remote.allow-insecure bool false Allows http:// (and invalid certificates off the web) for the addresses the themes download from, with a warning listing them Theme properties
spring.messages.basename comma-separated names messages The message files; the app's locales follow them Messages and languages
spring.messages.use-code-as-default-message bool false A missing code shows the code itself Messages and languages
spring.profiles.active comma list none Your own profiles, added to the platform's and the build's Configuration
spring.config.import locations none More configuration files: resources:, asset:, https:// Configuration
logging.level.<logger> trace ... off info Log levels (the starter logs as spring_boot_starter_flutter.*) Logging
spring.web.resources.cache.cachecontrol.* Spring Boot's Cache-Control directives (max-age, cache-public...) none Read by the generator, as a browser reads the configuration: the rules of web/_headers, how long browsers keep the files of the web build The browser cache of a web build

See also