flutter-server-driven-ui is a Windows app built with Flutter and Dart. It shows screens that come from JSON data instead of fixed app code. That means the app can change what it shows based on data from a local file or a REST API.
It is built for people who want a simple way to run a UI that is described in JSON. You do not need to set up a development environment to use the released app.
Visit this page to download the Windows release:
After you open the release page:
- Find the latest version
- Download the Windows file
- Save it to your PC
- Open the file to start the app
If your browser saves the file in Downloads, open that folder and double-click the file there.
This app is meant for Windows computers.
Before you run it, check these basics:
- Windows 10 or Windows 11
- A standard desktop or laptop
- Enough space for the app files
- A network connection if you plan to load data from a REST API
If the app opens in a compressed folder, extract the files first. Then run the main app file from the extracted folder.
- Download the release from the link above
- Open the downloaded file or folder
- Run the app file
- Wait for the first screen to load
- Use the app as shown by the JSON contract or local data source
If Windows asks for permission, choose the option to allow the app to run.
This app uses a server-driven UI model.
In simple terms:
- JSON controls the screen layout
- The app reads those JSON rules at runtime
- The widget tree is built while the app runs
- Navigation comes from the same JSON source
- Data can come from local assets or a REST API
This setup lets the same app show different screens without changing the core code for each view.
- JSON-based screen definitions
- Dynamic layout creation at runtime
- Support for navigation rules in JSON
- Local asset data support
- REST API data source support
- Flutter and Dart app structure
- UI built from contracts instead of fixed views
- Works well for content that changes often
A normal run may follow this flow:
- The app starts
- It loads a JSON contract
- It reads layout and screen data
- It builds the visible widgets
- It shows navigation based on the contract
- It loads content from local files or an API
This flow keeps the app flexible and easy to update through data changes.
The app can use two common data sources.
Use local assets when the data should stay inside the app package. This fits:
- Demo content
- Offline use
- Static screen layouts
- Testing screen changes
Use a REST API when the screen data should come from a remote service. This fits:
- Content that changes often
- Live data
- Central control of screens
- Shared data for many users
The app can read both styles of input and build the UI from the same kind of contract.
The project focuses on a contract-first setup. That means the JSON defines:
- What screen to show
- How the screen is laid out
- What text and media to use
- Which controls appear
- Where each action should go
This makes the app useful when you want a UI that can change without a full app rewrite.
Navigation also comes from the JSON contract.
That can include:
- Moving from one screen to another
- Opening a detail view
- Returning to a previous screen
- Switching based on a button tap
- Loading a new view from a remote response
This keeps the app flow tied to the same data source that drives the layout.
This app fits projects like:
- Admin panels
- Content dashboards
- Product catalogs
- Training screens
- Demo apps
- Internal tools
- Forms and guided screens
- Apps that use remote screen rules
It is a strong fit when screen structure changes often and you want those changes to come from JSON.
To use the released app on Windows, keep these items ready:
- A Windows PC
- The release file from GitHub
- A file extractor if the download comes as a zip file
- Access to the local JSON files or API endpoint used by the app
- Internet access if the app must call a remote REST API
- Go to the releases page
- Download the newest Windows release
- Open the downloaded file
- Extract it if needed
- Run the main app file
- Load your JSON contract or API data
- Check that the first screen appears as expected
If the screen stays blank, check the JSON path, local files, or API URL used by the app
This repository covers these areas:
- API
- App design
- Architecture
- Dart
- Flutter
- JSON
- Layout
- REST
- REST API
- Screens
- UI
These topics reflect the app’s focus on data-driven screens and runtime UI building.
A server-driven UI can make app changes easier to manage.
It helps when you want to:
- Change screens from data
- Reuse the same app shell
- Reduce hardcoded views
- Keep layout rules in one place
- Load content from different sources
This setup gives you more control over the screen without rebuilding the whole interface each time
Use this page to get the Windows app:
Download the latest file from that page, then run it on your Windows PC