Genkit Dart: Build Full-Stack AI Apps with Dart and Flutter

Google announced the preview launch of Genkit Dart in March 2026, bringing the same “write once, run anywhere” philosophy that made Flutter successful to AI-powered features. Genkit is already available for TypeScript, Go, and Python, and now Dart developers can build high-quality, full-stack, AI-powered applications for any platform.

What is Genkit Dart?

Genkit Dart is an open-source AI framework that provides a unified interface for integrating AI models from multiple providers. It lets you write AI logic once and run it either as a backend service or directly inside your Flutter app.

The framework builds on the same Genkit principles used in production at Google, with Dart-specific optimizations for type safety and cross-platform deployment.

Key Capabilities

Model-Agnostic API

Genkit supports Google Gemini, Anthropic Claude, OpenAI GPT models, and any OpenAI API-compatible provider out of the box. Switching between providers requires minimal code changes:

import 'package:genkit/genkit.dart';
import 'package:genkit_google_genai/genkit_google_genai.dart';
import 'package:genkit_anthropic/genkit_anthropic.dart';

void main() async {
  final ai = Genkit(
    plugins: [googleAI(), anthropic()],
  );

  // Call Google Gemini
  final geminiResponse = await ai.generate(
    model: googleAI.gemini('gemini-3.1-pro-preview'),
    prompt: 'Hello from Gemini',
  );

  // Call Anthropic Claude
  final claudeResponse = await ai.generate(
    model: anthropic.model('claude-opus-4.6'),
    prompt: 'Hello from Claude',
  );
}

Type-Safe AI Flows

Using Dart’s strong type system with the schemantic package, Genkit generates strongly typed data and creates type-safe AI flows. You define input/output schemas as abstract classes, and build_runner generates the JSON schema bindings:

import 'package:schemantic/schemantic.dart';

@Schema()
abstract class $TravelPlan {
  String get destination;
  int get days;
  List<String> get interests;
}

// Use in a flow
final response = await ai.generate(
  model: googleAI.gemini('gemini-3.1-pro-preview'),
  prompt: 'Plan a trip to Paris for 5 days focusing on food and art.',
  outputSchema: TravelPlan.$schema,
);

final plan = response.output; // Typed TravelPlan object

Run Anywhere Dart Runs

Genkit Dart supports three deployment patterns:

1. Entirely in Flutter — Write all Genkit logic directly in your Flutter app. Great for prototypes or apps where users provide their own API keys.

2. Backend service with Flutter client — Run AI logic on a server (Cloud Functions, Cloud Run) and call it from your Flutter app. Best for production apps with private prompts and API keys.

3. Shared package pattern — Write AI logic once in a shared Dart package and use it on both server and client.

Developer UI

Genkit includes a localhost web UI where you can test prompts, view traces, and debug your flows without writing any frontend code. Run it with:

genkit start

The Developer UI shows execution traces, model inputs/outputs, and latency breakdowns — invaluable for iterating on prompts and debugging tool calls.

Getting Started

Add Genkit to your pubspec.yaml:

dependencies:
  genkit: ^0.13.0
  genkit_google_genai: ^0.3.0
  schemantic: ^0.1.0

dev_dependencies:
  build_runner: ^2.4.0

Then initialize Genkit and start generating:

import 'package:genkit/genkit.dart';
import 'package:genkit_google_genai/genkit_google_genai.dart';

void main() async {
  final ai = Genkit(
    plugins: [googleAI()],
    model: googleAI.gemini('gemini-flash-latest'),
  );

  final response = await ai.generate(
    prompt: 'Explain Dart isolates in one paragraph.',
  );

  print(response.text);
}

The Genkit Dart Ecosystem

The Genkit Dart ecosystem includes several packages on pub.dev:

Package	Purpose
genkit	Core framework
genkit_google_genai	Google AI (Gemini) plugin
genkit_anthropic	Anthropic Claude plugin
genkit_openai	OpenAI + compatible APIs plugin
genkit_chrome	Chrome Prompt API (Gemini Nano)
genkit_mcp	Model Context Protocol plugin
genkit_firebase_ai	Firebase AI Logic plugin
genkit_middleware	Reusable middleware (retries, fallbacks)
genkit_shelf	Shelf HTTP server integration

Production-Ready Features

Genkit Dart isn’t just for prototyping. It includes production essentials:

• Structured output — Get typed objects back from models instead of raw text
• Tool calling — Let models call your Dart functions during generation
• Streaming — Stream model output token-by-token for responsive UIs
• Observability — Built-in tracing and logging via the Developer UI
• Middleware — Composable hooks for retries, model fallback, and tool approval
• Multi-step flows — Chain multiple model calls with explicit control flow

When to Use Genkit Dart

Genkit Dart is a strong fit when you need:

• AI features in a Flutter app that might switch providers
• Type safety between your AI logic and app code
• A single codebase for client and server AI logic
• Observability and debugging tools during development
• Production-ready structured output and tool calling

For simpler use cases, direct API calls to a single provider may suffice. But as your AI features grow in complexity, Genkit’s abstractions pay for themselves quickly.

Conclusion

Genkit Dart brings Google’s production-tested AI framework to the Dart ecosystem. With model flexibility, type safety, and the ability to run anywhere Dart runs, it’s the foundation for building serious AI-powered Flutter applications. The preview is available now on pub.dev — start experimenting and building the next generation of intelligent apps.

References:

• Announcing Genkit Dart — genkit.dev
• Genkit Dart Documentation — genkit.dev
• Genkit Dart GitHub — github.com
• Dart Blog Announcement — dart.dev