The modern Flutter CLI for project scaffolding, automation, code generation, builds, flavors, Firebase App Distribution, and developer productivity.

🚀 Scaffold   •   ⚙️ Automate   •   🏗️ Generate   •   📦 Build   •   🔥 Deploy

dart pub global activate flutter_devops_kit

Verify the installation:

fkit doctor

# Check your development environment
fkit doctor

# Initialize FKIT inside your Flutter project
fkit init

# Generate a new feature
fkit gen feature

• 🏗️ Project initialization & setup
• 📂 Feature & module code generation
• 🎯 Clean Architecture templates
• 🧩 BLoC, Riverpod & Provider support
• 📦 APK, AAB & IPA build automation
• 🔥 Firebase App Distribution
• 🎨 Multi-flavor project management
• 📱 Launcher icon & asset generation
• 🌍 Localization support
• ⚡ FVM integration
• 🛠️ Developer productivity commands
• 🔄 Reusable template system

FKIT (Flutter DevOps Kit) is a reusable command-line toolkit built for Flutter developers, teams, and organizations.

Instead of repeatedly configuring project structure, architecture, modules, builds, signing, localization, launcher icons, Firebase App Distribution, and code generation manually, FKIT provides a unified, scalable, and consistent CLI workflow.

Install FKIT once, configure your project using a simple fkit.yaml file, and automate the repetitive parts of Flutter development.

FKIT is built around four core principles:

• ⚡ Project Automation — Eliminate repetitive Flutter setup tasks.
• 🏗️ Template-Driven Code Generation — Generate production-ready architecture and boilerplate.
• 🚀 Build & Release Automation — Simplify APK, AAB, IPA builds, flavors, signing, and Firebase App Distribution.
• 🛠️ Developer Productivity — Standardize workflows across personal, team, and enterprise projects.

Whether you're starting a brand-new Flutter application or maintaining a large production codebase, FKIT helps you automate repetitive tasks, enforce consistency, and accelerate development.

FKIT can be installed globally using the Dart package manager.

Before installing FKIT, make sure the following are available:

• Flutter SDK
• Dart SDK
• Git

Verify your Flutter and Dart installations:

flutter --version
dart --version

Install FKIT globally:

dart pub global activate flutter_devops_kit

Add the Dart global executable directory to your PATH.

echo 'export PATH="$PATH:$HOME/.pub-cache/bin"' >> ~/.zshrc
source ~/.zshrc

echo 'export PATH="$PATH:$HOME/.pub-cache/bin"' >> ~/.bashrc
source ~/.bashrc

Verify the installation:

fkit help

Install FKIT globally using PowerShell or Command Prompt:

dart pub global activate flutter_devops_kit

The Dart global executable directory is typically:

%LOCALAPPDATA%\Pub\Cache\bin

Add this directory to the Windows PATH environment variable.

1. Open System Properties.
2. Select Advanced.
3. Select Environment Variables.
4. Under User variables, select the Path variable.
5. Select Edit.
6. Select New.
7. Add: %LOCALAPPDATA%\Pub\Cache\bin
8. Save the changes and restart your terminal.

Verify the installation:

fkit help

To update to the latest published version:

dart pub global activate flutter_devops_kit

To remove FKIT:

dart pub global deactivate flutter_devops_kit

After installation, run:

fkit help

You can also verify your development environment with:

fkit doctor

Once installed, FKIT is available globally and can be used inside any Flutter project.

Flutter projects often require repetitive setup and maintenance tasks such as:

• Creating architecture-specific feature folders
• Generating DTOs, entities, repositories, use cases, BLoC's, and screens
• Maintaining dependency injection registrations
• Maintaining application routes
• Installing reusable project modules
• Configuring launcher icons
• Running code generation
• Managing Flutter and FVM commands
• Building APK, AAB, IPA, and Web applications
• Managing flavors
• Uploading builds to Firebase App Distribution
• Configuring Android signing
• Managing localization workflows
• Running formatting, analysis, and automated fixes

FKIT provides a single CLI interface for these workflows.

fkit <command>

Current release:

0.1.1

FKIT is under active development.

The current release focuses on building the foundation for a scalable Flutter CLI ecosystem, including template-driven generation, reusable modules, project automation, and architecture-aware maintenance.

• Global CLI installation
• Interactive project initialization
• YAML-based project configuration
• Template-driven project setup
• Automated project bootstrap generation
• Environment diagnostics and validation
• FVM support
• Multi-platform project configuration

• Feature-first architecture scaffolding
• Feature generation with fkit feat
• Component generation with fkit make
• Resource generation workflows
• Template-driven generators
• Automatic barrel file maintenance
• Automatic dependency injection maintenance
• Build Runner integration

• Module installation with fkit install
• Template-defined module configuration
• Interactive module options
• Conditional file generation
• Conditional package dependencies
• Automated dependency management
• Generic and DI-specific module integrations

Currently available modules:

• Theme
• Router
• Network

• GoRouter module generation
• Automatic route discovery
• Automatic route synchronization
• Existing route detection
• Duplicate route prevention
• Preservation of manually customized routes
• Automatic route import maintenance

• Dio-based API service
• Typed API responses
• Generic response mappers
• Object and list response mapping
• Pagination support
• API response extensions
• Centralized failure handling
• Dio exception mapping
• Network connectivity monitoring
• Network interceptor
• Authentication interceptor
• Optional Talker application and network logging

• Localization setup
• ARB file generation
• l10n.yaml generation
• Localization validation
• Localization diagnostics
• Automatic Flutter localization dependency configuration

• APK builds
• Android App Bundle builds
• IPA builds
• Flutter Web builds
• Flavor-aware workflows
• Firebase App Distribution
• Android signing setup
• Dart code obfuscation support

• Additional reusable modules
• Additional architecture templates
• Improved project setup customization
• Expanded automated test coverage
• Additional module integration strategies

• Fastlane integration
• Play Store deployment
• App Store deployment
• Web deployment automation
• Release pipelines
• Git tagging
• Changelog generation
• CI/CD templates
• Slack and Discord notifications

Run inside your Flutter project:

fkit init

This creates the FKIT project configuration and allows you to configure project settings and select the default architecture template.

Before running the complete project setup, configure any project-specific prerequisites required by your application.

Examples include:

• Firebase configuration
• Flutter flavors
• Environment files
• Platform-specific configuration

fkit setup

The setup command reads the selected architecture template and automatically performs the configured project setup workflow.

Depending on the selected template, FKIT can:

• Install reusable modules
• Add required dependencies
• Generate configured features
• Synchronize dependency injection
• Synchronize application routes
• Generate project bootstrap files
• Configure project-level requirements
• Run dependency synchronization
• Execute required code generation

For example, a template may define:

setup:
  modules:
    - theme
    - router
    - network

  features:
    - auth

  bootstrap:
    enabled: true

    app:
      template: bootstrap/app.dart.tpl
      output: lib/app/view/app.dart

    main:
      template: bootstrap/main.dart.tpl
      output: lib/main.dart

Running:

fkit setup

can transform a fresh Flutter project into a structured, architecture-ready starting point.

fkit doctor

fkit feat profile

fkit make screen auth login

fkit install network

fkit build apk production

fkit firebase production

FKIT uses reusable architecture templates to define how projects, features, components, modules, routing, dependency injection, and project setup workflows are generated.

The currently available template is:

• bloc_clean — Feature-first Clean Architecture using flutter_bloc

Templates can define:

• Feature structure
• Components
• Component groups
• Barrel files
• Dependency injection
• Routing
• Reusable modules
• Project requirements
• Project setup workflows
• Application bootstrap files

This architecture allows FKIT to support additional project structures and state-management approaches in future releases without coupling generators directly to a single architecture.

FKIT modules provide reusable project-level functionality that can be installed independently.

fkit install <module>

Available modules include:

fkit install theme
fkit install router
fkit install network

Modules can define:

• Generated files
• Required dependencies
• Development dependencies
• Interactive configuration options
• Conditional files
• Conditional dependencies
• Build Runner requirements
• Template and DI-specific integrations

FKIT follows a configuration-driven and template-driven architecture.

The CLI is organized around:

Commands
    ↓
Services
    ↓
Templates
    ↓
Generators
    ↓
Resolvers
    ↓
Maintainers
    ↓
Integrators

Major architectural concepts include:

• Commands for user-facing workflows
• Services for reusable application logic
• Templates for architecture-specific behavior
• Generators for file creation
• Resolvers for project discovery
• Maintainers for existing code synchronization
• Integrators for module and architecture integration

This structure is designed to prevent architecture-specific logic from being hardcoded directly into CLI commands.

A configured Flutter project may look like:

my_flutter_project/
├── android/
├── ios/
├── web/
├── lib/
│   ├── app/
│   ├── core/
│   └── features/
├── env/
├── pubspec.yaml
└── fkit.yaml

The exact project structure depends on the selected FKIT architecture template.

Clone the FKIT repository and retrieve dependencies:

dart pub get

Run FKIT locally:

dart run bin/fkit.dart help

Activate the local package globally:

dart pub global activate --source path .

After making CLI changes, reactivate the package:

dart pub global activate --source path .

Run FKIT inside a test Flutter project:

fkit help

Before publishing a new FKIT version:

dart format .

dart analyze

dart test

Run a dry publish:

dart pub publish --dry-run

If validation succeeds:

dart pub publish

FKIT is under active development.

The 0.1.x releases focus on establishing the core architecture, template system, generators, maintainers, reusable modules, and project automation foundation.

Breaking changes may occur while the architecture evolves toward a stable release.

Contributions, bug reports, architecture templates, modules, and automation ideas are welcome.

Areas of contribution include:

• Build automation
• Deployment workflows
• Architecture templates
• Module development
• Feature generators
• Maintainers
• Integrators
• CI/CD templates
• Documentation
• Testing

MIT License

Built with ❤️ for scalable Flutter engineering workflows.