
# 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](configuration.md).

## Example

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

```yaml
# 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
```

```yaml
# lib/resources/application-desktop.yml
spring:
  flutter:
    desktop:
      window:
        title: NEON Books
        title-bar: transparent
        initial-size: 1280x800
        min-size: 800x600
```

```yaml
# 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](design-libraries.md)). 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](app-widget.md).

| 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](app-widget.md#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](configuration.md#the-os-environment) |
| `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](shortcuts.md) |

## 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](lifecycle.md) |
| `spring.devtools.restart.enabled` | bool | `true` | A hot reload restarts the context when the generated code changed: beans, annotations or `lib/resources/` | [Hot reload](hot-reload.md) |

## 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](assets-and-fonts.md) |
| `spring.flutter.fonts.exclude` | list of globs | none | Font assets not to load (`assets/pdf/**`) | [Assets and fonts](assets-and-fonts.md) |
| `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](assets-and-fonts.md) |
| `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](assets-and-fonts.md) |

## spring.flutter.splash

Read at the start. The splash's look is the theme's `splash`. See [The splash and the start](splash.md).

| 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](debug-panel.md) |
| `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](debug-panel.md#the-modules) |
| `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](debug-panel.md#the-modules) |
| `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](timeline.md) |
| `spring.flutter.debug.timeline.position` | corner | `bottom-left` | at the start | The corner of the timeline's pill | [The timeline](timeline.md) |
| `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](isolates.md) |
| `spring.flutter.debug.isolates.position` | corner | `bottom-right` | at the start | The corner of the task manager's table | [The task manager](isolates.md) |
| `spring.flutter.debug.isolates.interval` | duration | `1s` | at the start | How often the task manager reads its rows | [The task manager](isolates.md) |
| `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](overlays.md#dragging-them) |
| `spring.flutter.debug.overlays.layout` | `auto`, `stack`, `pages` | `auto` | at the start | How the overlays of one corner are put together | [Debug overlays](overlays.md#the-layout) |
| `spring.flutter.debug.overlays.max-height` | fraction | `0.4` | at the start | The room of a corner for `auto` | [Debug overlays](overlays.md#the-layout) |
| `spring.flutter.debug.overlays.margin.top` / `bottom` / `left` / `right` | logical pixels | `0` | at the start | Room past the safe area | [Debug overlays](overlays.md#the-layout) |
| `spring.flutter.debug.overlays.drag.snap` | `corners`, `free` | `corners` | at the start | Where a dropped overlay goes | [Debug overlays](overlays.md#dragging-them) |
| `spring.flutter.debug.overlays.drag.remember` | bool | `true` | at the start | Whether a moved overlay keeps its place after a restart | [Debug overlays](overlays.md#dragging-them) |
| `spring.flutter.frame-meter.enabled` | bool | `false` | at the start | Shows the frame meter over the app | [The frame meter](frame-meter.md) |
| `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](frame-meter.md) |
| `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](markdown.md#values-from-the-configuration) |
| `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](frame-meter.md) |

## spring.flutter.desktop.window

Read at the start, on macOS, Windows and Linux only. See [The desktop window](desktop-window.md).

| 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](web.md#the-page-around-the-app).

| 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](web.md#the-dev-server-of-flutter-run) and [The web dev server](../spring-core-dart-generator/flutter/web-dev-server.md).

| 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](seo.md) and [Pages for search engines](../spring-core-dart-generator/flutter/seo.md).

| 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](resources.md).

| 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`](../spring-boot-starter-cache/disk-caches.md)) 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](sqlite.md).

| 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](themes/properties.md), the Material components on [Component themes](../spring-boot-starter-flutter-material/components/index.md) of the Material starter, `cupertino.*` on [Cupertino theme properties](../spring-boot-starter-flutter-cupertino/theme-properties.md).

| Key | Type | Default | Meaning | Page |
|---|---|---|---|---|
| `spring.flutter.theme.active` | `system` or a theme name | `system` | The theme shown at start | [Theme properties](themes/properties.md) |
| `spring.flutter.theme.system-light` | theme name | `light` | What `system` shows in the device's light mode | [Theme properties](themes/properties.md) |
| `spring.flutter.theme.system-dark` | theme name | `dark` | What `system` shows in the device's dark mode | [Theme properties](themes/properties.md) |
| `spring.flutter.theme.remember` | bool | `true` | Keeps the theme the user chose between runs and shows it again behind the splash | [Themes](themes/index.md) |
| `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](themes/properties.md#a-theme-from-a-url) |
| `spring.flutter.theme.source-sha256` | 64 hex digits | none | Refuse a download with another digest | [Theme properties](themes/properties.md#a-theme-from-a-url) |
| `spring.flutter.theme.refresh` | duration | none | Look at the address again in the background when the cache is older | [Theme properties](themes/properties.md#a-theme-from-a-url) |
| `spring.flutter.theme.themes.<name>.extends` | theme name | the root | The theme it starts from | [Theme properties](themes/properties.md) |
| `spring.flutter.theme.themes.<name>.source`, `.source-sha256`, `.refresh` | as above | none | A theme downloaded from a URL, cached and refreshed | [Theme properties](themes/properties.md#a-theme-from-a-url) |
| `brightness` | `light`, `dark` | `light` (`dark` for `dark`) | Whether the theme is light or dark | [Theme properties](themes/properties.md) |
| `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](themes/colors.md) |
| `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](themes/colors.md) |
| `contrast` | number, -1 to 1 | `0` | The palette's contrast. Needs a design starter | [Colors](themes/colors.md) |
| `colors.<role>` | color | from the seed, else Flutter's baseline | One of the 46 Material roles | [Colors](themes/colors.md) |
| `typography.*` | map | Material's | Font family, fallbacks, the 15 text styles and `code` | [Typography](themes/typography.md) |
| `shape.<token>` | number | Material 3's | The corner scale | [Shape, spacing and elevation](themes/shape-spacing-elevation.md) |
| `elevation.<level>` | number | 0, 1, 3, 6, 8, 12 | `level0` to `level5` | [Shape, spacing and elevation](themes/shape-spacing-elevation.md) |
| `spacing.<name>` | number | `xs` 4, `s` 8, `m` 16, `l` 24, `xl` 32 | Gaps of your own widgets | [Shape, spacing and elevation](themes/shape-spacing-elevation.md) |
| `visual-density` | `adaptive`, `standard`, `comfortable`, `compact` | Flutter's | How tightly components are packed. Read by `spring_boot_starter_flutter_material` | [Density and ink](../spring-boot-starter-flutter-material/density-and-ink.md) |
| `tap-target-size` | `padded`, `shrink-wrap` | Flutter's | The minimum tap area. Read by `spring_boot_starter_flutter_material` | [Density and ink](../spring-boot-starter-flutter-material/density-and-ink.md) |
| `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](themes/loaders.md) |
| `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](themes/motion-and-animations.md) |
| `animations.<name>.*` | map | none | Named animations: `duration`, `curve`, `repeat` | [Motion and animations](themes/motion-and-animations.md) |
| `components.<component>.*` | map | Material 3's | One of the 49 Material component themes. Read by `spring_boot_starter_flutter_material` | [Component themes](../spring-boot-starter-flutter-material/components/index.md) |
| `cupertino.*` | map | iOS's | The `CupertinoThemeData`. Read by `spring_boot_starter_flutter_cupertino` | [Cupertino theme properties](../spring-boot-starter-flutter-cupertino/theme-properties.md) |
| `tokens.*` | any | none | Your own values, at any depth | [Tokens and references](themes/tokens-and-references.md) |
| `styles.<name>.*` | map | none | A look per state for your own widgets | [Styles and states](themes/styles-and-states.md) |
| `styles.code.*`, `styles.heading.*`, `styles.link.color`, `styles.table.*`, `styles.callout.*` | map | the color scheme | The look of `MarkdownView` | [MarkdownView](markdown.md) |
| `syntax.<language>.*` | map | none | The languages of code blocks | [Styles and states](themes/styles-and-states.md) |
| `background.*` | map | none | A color, image, overlay and animation behind every screen | [Background](themes/background.md) |
| `loaders.<name>.*` | map | none | Loaders for `ThemeLoader`, `ThemeSkeleton` and the splash | [Loaders and the splash](themes/loaders.md) |
| `frame-meter.*` | map | the color scheme | The look of the frame meter | [The frame meter](frame-meter.md) |

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](themes/properties.md) |
| `spring.messages.basename` | comma-separated names | `messages` | The message files; the app's locales follow them | [Messages and languages](messages.md) |
| `spring.messages.use-code-as-default-message` | bool | `false` | A missing code shows the code itself | [Messages and languages](messages.md) |
| `spring.profiles.active` | comma list | none | Your own profiles, added to the platform's and the build's | [Configuration](configuration.md) |
| `spring.config.import` | locations | none | More configuration files: `resources:`, `asset:`, `https://` | [Configuration](configuration.md#imports) |
| `logging.level.<logger>` | `trace` ... `off` | `info` | Log levels (the starter logs as `spring_boot_starter_flutter.*`) | [Logging](../spring-core-dart/logging/index.md) |
| `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](cache-headers.md) |

## See also

- [Configuration in a Flutter app](configuration.md)
- [Theme properties](themes/properties.md)
- [Properties the build reads](../spring-core-dart-generator/build-properties.md)
- [Metadata for editors](../spring-core-dart-generator/metadata.md)
