What is Nativeblocks?

Nativeblocks is a tool for building native mobile apps faster, without waiting on app store approvals. It uses a server-driven UI (SDUI) approach, which means you can update your app’s design and behavior by changing the data on the backend instead of shipping a new app version. Nativeblocks helps you deliver updates instantly, work with your team more efficiently, and debug faster. You stay in full control while moving faster.

What is SDUI?

It’s all powered by SDUI or server-driven UI. In SDUI, the user interface is controlled by the backend. The server sends a JSON payload that describes the layout and components — buttons, text, images, and whatever the screen needs. The app then reads that JSON and shows the UI based on it. This pattern helps teams make fast, dynamic updates without touching app code. Companies like Shopify, Airbnb, and Spotify use this method to build scalable UI systems across platforms like iOS and Android

SDUI challenges

Building a full SDUI system from scratch isn’t easy. You’d need to handle schema design, backend rendering logic, UI coordination on the client, and a way to keep everything in sync across platforms. It takes a lot of time, effort, and maintenance, especially when you’re trying to support both iOS and Android. That’s why many teams end up needing a proper SDUI framework that handles the heavy lifting, so they can focus on building features, not infrastructure.

That’s exactly where Nativeblocks comes in. It gives you all the pieces you need to run a complete SDUI setup without having to build and maintain it yourself. From the visual studio where you design screens, to the backend that stores them, to the Core SDK that renders everything natively in your app, Nativeblocks handles the entire flow. You still have full control over your components and platform logic, but you don’t have to reinvent the system.

How Nativeblocks works?

Nativeblocks builds on this idea. At the center of it all is the Core SDK a lightweight engine that handles logic like screen loading and state management. It doesn’t include UI components or application logic itself. Instead, it connects with your components, built-in SwiftUI, and Jetpack Compose, which orbit around the SDK like planets in a solar system. This setup gives you full control to style, structure, and optimize your UI however you want.

To design screens, you use Nativeblocks Studio, a simple web-based editor. You drag and drop blocks to build screens visually, like buttons, images, or inputs. It’s quick, and you don’t have to write UI code manually. These block-based screens get synced to the Nativeblocks Backend. The backend stores all the screens and components, and a sync server keeps everything up-to-date.

When your app runs, it talks to the backend. The backend sends back a JSON screen definition, which describes what blocks to show and how to arrange them. The Nativeblocks core SDK reads that JSON and tells the app which UI components to display. It doesn’t draw anything itself, it just knows how to match blocks to the right native components. So you get a fully native UI, just like if you coded it yourself.

Behind the scenes, there’s also a Compiler and Plugin. This tool generates the actual code and schema for your components. If you create a new block in the Studio, the Compiler ensures your Kotlin or Swift code can render it. It also helps the Studio, backend, and SDK all understand each other by generating consistent schemas. The Compiler connects to your component system, not directly to the SDK, so you’re always in control of how your components behave.

So here’s how it all works:

• You build screens visually in the Studio.
• The backend stores and serves them as JSON.
• The Core SDK reads the JSON in your app.
• Your custom components render the screen.
• The Compiler keeps the system in sync across platforms.

With Nativeblocks, you can update the UI instantly, keep everything native, and skip the hassle of app store redeploys. It’s great for things like onboarding screens, feature flags, A/B tests, or even full production screens

Getting started is simple. Just:

• Add the Nativeblocks SDK to your iOS or Android app (just a few lines of code).
• Define your components with SwiftUI, Jetpack Compose, or use the built-in Nativeblocks Foundation blocks/actions.
• Let the Compiler generate the schema and component code and then sync them with the backend.
• Use Nativeblocks Studio to build and update screens without touching native code.

Once set up, your app pulls screens from the backend, and the SDK handles the rest, matching blocks to components and showing the correct screen. No app updates, no waiting.

To learn more, check out:

• Website: nativeblocks.io
• Docs & SDK Setup: nativeblocks.io/references
• GitHub Examples: github.com/nativeblocks (sample components and SDK demos)
• Product Updates & Blog: nativeblocks.io/blog