Inicio Documentación Arquitectura CLI Flows pub.dev
Framework · 2026

Omega
Architecture

El sistema nervioso autónomo para aplicaciones de alta complejidad en Flutter.

Esta web es la puerta de entrada a Omega: aquí se explica qué es el framework, en qué se diferencia de BLoC/Riverpod, se muestra el diagrama de arquitectura y se detalla cómo integrarlo en tu app host (flows, agentes, navegación y CLI).

Creado por: Yeferson Segura

Liderando una nueva era en Flutter

Framework Version: 1.0.0-Stable

GitHub Instagram

Contexto Técnico

Superando los Límites Tradicionales

El Techo de Cristal de BLoC

Rigidez estructural. Acoplamiento fuerte entre Streams y Widgets. Complejidad exponencial en apps grandes.

El Laberinto de Riverpod

Dificultad de trazabilidad. Fragmentación de Providers. Curva de aprendizaje técnica sobre la semántica del negocio.

Core Philosophy

El Cambio de Paradigma

En Omega, la lógica no "vive" en la UI. La lógica reside en Agentes Autónomos que operan de forma independiente, comunicándose a través de una Capa Semántica.

UI as a Mirror

La interfaz es un espejo "tonto" que refleja las expresiones del proceso de negocio.

Actor-Based

Inspirado en el modelo de actores de Elixir/Erlang para un aislamiento total de responsabilidades.

Scalable-First

Diseñado para equipos grandes donde la modularidad es el único camino al éxito.

Functional Pillars

Arquitectura Evolutiva

🧠

Inteligencia Distribuida

Agentes autónomos reducen la carga del hilo principal y desacoplan la lógica del ciclo de vida del widget.

📡

Bus Global Reactivo

Canales de comunicación asíncronos permiten una observabilidad del 100% de la actividad del sistema.

🎭

Capa Semántica

Intenciones y Expresiones eliminan el acoplamiento directo entre la intención del usuario y la respuesta del sistema.

Technical Execution

Arquitectura Desacoplada


// El Agente: Cerebro de la lógica
class AuthAgent extends OmegaAgent {
  void _login(credentials) {
    emit("auth.login.success", payload: user);
  }
}

// El Flow: Orquestador de navegación
class AuthFlow extends OmegaFlow {
  void onEvent(ctx) {
    if (ctx.event?.name == "auth.login.success") {
       emitExpression("success");
       navigate("home");
    }
  }
}

Desacoplamiento Atómico

El código de negocio no menciona widgets, ni contextos, ni rutas. Es lógica pura, 100% portable y testeable en segundos sin necesidad de emuladores.

Arquitectura

Visión general de Omega

Diagrama de alto nivel que muestra cómo interactúan la UI, los agentes, los flows, el canal de eventos, el FlowManager, el navegador y el CLI.

Diagrama de arquitectura de Omega Architecture: UI, OmegaScope, OmegaBuilder, OmegaChannel, OmegaAgent, Behavior Engine, OmegaFlow, OmegaFlowManager, OmegaNavigator y Omega CLI.
Market Analysis

Omega vs El Mercado

Característica Omega Architecture BLoC / Riverpod
Autonomía de Lógica ✔ Agentes Independientes ✘ Dependientes de UI/Providers
Trazabilidad Semántica ✔ Nativa (Event Bus) ✘ Manual (Debug Print)
Navegación Desacoplada ✔ Sí (via Flows) ✘ No (via BuildContext)
Escalabilidad en Equipos ✔ Modular (Micro-Agents) ✘ Propenso a "Spaguetti"

Omega vs BLoC: La lógica en Omega vive en agentes que no conocen la UI; en BLoC está en Blocs atados a Streams y widgets. Omega desacopla la navegación (intents); BLoC suele usar BuildContext.

Omega vs Riverpod: Riverpod es muy flexible (providers, ref); Omega fija un modelo (agentes + flows + canal) y da trazabilidad explícita (eventos/intents con nombre). Navegación en Omega sin depender de context.

Comparativa

Cuándo elegir Omega

Elige Omega si...

Quieres lógica de negocio fuera de la UI y fácil de testear sin Flutter, navegación desacoplada, equipos que necesitan estructura clara (agentes, flows, intents) o apps con mucha complejidad.

BLoC o Riverpod si...

Prefieres algo muy adoptado (documentación, ejemplos, comunidad), te basta con eventos→estados→UI o con providers flexibles y no necesitas el modelo de agentes ni la capa de intents.

Omega no compite en popularidad; se diferencia por agentes + behavior + canal + flows + intents y navegación sin BuildContext. Es arquitectura, no solo state management.

Valor

La importancia de Omega

Un framework que une arquitectura clara, desacoplamiento real y herramientas desde el primer día.

Omega no es "un BLoC más". Es una forma de organizar la aplicación donde la lógica de negocio vive en agentes, la orquestación en flujos y la UI solo refleja lo que el sistema decide. Eso reduce bugs, acelera los tests y escala con el equipo.

🎯

Claridad desde el día uno

Sabes dónde va cada cosa: agentes para lógica, flows para orquestar, intents para comunicar. Sin adivinar en qué Provider o Bloc tocó cada regla.

🧪

Testeable de verdad

La lógica no depende de Flutter. Puedes probar agentes y flujos con tests unitarios puros, sin pumpWidget ni mocks de contexto.

📦

Escalable por diseño

Ecosistemas (agent + flow + behavior + UI) permiten que varios desarrolladores trabajen en features sin pisarse. El CLI genera la estructura consistente.

Valor

Por qué vale la pena usarlo

Menos acoplamiento, menos deuda

La UI no conoce rutas ni contextos de navegación. Los flujos emiten intenciones; el navegador reacciona. Cambiar pantallas o flujos no rompe la lógica de negocio.

Trazabilidad semántica

Eventos e intents tienen nombre y payload. Puedes seguir "quién pidió qué" y "quién respondió" sin depender de prints ni debugging a ciegas.

Un solo lugar para la configuración

omega_setup.dart en tu app concentra agentes, flujos y rutas. Un vistazo y entiendes cómo está montada la aplicación.

Inversión baja, beneficio alto

omega init y omega g ecosystem generan la estructura. Te enfocas en reglas de negocio y UX, no en montar capas a mano.

En resumen: Omega vale la pena cuando quieres una arquitectura que escale con la complejidad, que sea fácil de testear y que todo el equipo pueda seguir sin perderse en Providers o Blocs dispersos.

Documentación

Sobre el software

Framework reactivo y basado en agentes para aplicaciones Flutter.

🤖

Agentes reactivos

Entidades autónomas que reaccionan a eventos del sistema y mensajes directos.

⚙️

Motor de comportamiento

Lógica desacoplada con reglas y condiciones que determinan las reacciones del agente.

📡

Event-driven

Comunicación global mediante OmegaChannel (bus de eventos).

Gestión de flujos

Orquestación de transiciones de estado y lógica de negocio con OmegaFlow y OmegaFlowManager. Varios flujos pueden estar activos a la vez.

Intenciones semánticas

Abstracción de alto nivel para peticiones de usuario o del sistema (OmegaIntent).

Documentación

Conceptos core

Concepto Descripción
OmegaAgent Unidad de procesamiento. Tiene id, canal y motor de comportamiento.
OmegaAgentBehaviorEngine Evalúa eventos/intenciones y devuelve reacciones (acciones a ejecutar).
OmegaChannel Bus de eventos. Los agentes y flujos se suscriben a events y usan emit() para publicar.
OmegaFlow Flujo de negocio con estados (idle, running, paused…). Orquesta UI y agentes.
OmegaFlowManager Registra flujos, enruta intenciones a los que están en ejecución y los activa o pausa.
Documentación

Casos de uso

Apps de alta complejidad

Múltiples flujos (auth, checkout, onboarding) con lógica desacoplada y trazabilidad clara.

Equipos grandes

Modularidad por ecosistemas (agent + flow + behavior + UI). Cada feature puede desarrollarse de forma aislada.

Testing sin UI

Lógica de negocio en agentes y flujos, 100% testeable sin emuladores ni widgets.

Navegación desacoplada

Los flujos emiten intenciones de navegación; el navegador reacciona sin depender del BuildContext.

Documentación

Instalación

En tu app host (el proyecto Flutter que usa Omega), añade la dependencia. El archivo omega_setup.dart se crea en tu app con omega init, no viene dentro de la librería.

Añade en tu pubspec.yaml (desde pub.dev):

dependencies:
  omega_architecture: ^0.0.3
Documentación

Omega CLI

El CLI se ejecuta en tu app (la que usa omega_architecture). Resuelve la raíz de tu proyecto y crea/actualiza archivos en tu proyecto, no dentro del paquete.

Desde un proyecto que dependa de omega_architecture:

dart run omega_architecture:omega <comando> [opciones] [argumentos]
Comando Descripción
init [--force] Crea lib/omega/omega_setup.dart en tu app. Ahí defines rutas, agentes y flujos. --force sobrescribe.
g ecosystem <Nombre> Genera agente, flow, behavior y página; busca lib/omega/omega_setup.dart en tu proyecto y agrega el nuevo agente, flow y ruta. Ejecuta omega init antes.

Flujo de g ecosystem: 1) Resuelve la raíz del proyecto (donde está pubspec.yaml). 2) Busca lib/omega/omega_setup.dart; si no existe, pide ejecutar omega init. 3) Crea los archivos del ecosistema. 4) Actualiza ese mismo omega_setup.dart (imports + registro de agente, flow y ruta).

Opciones globales: -h, --help · -v, --version

dart run omega_architecture:omega init
dart run omega_architecture:omega g ecosystem Auth
Documentación

Uso: agente y behavior

class MyBehavior extends OmegaAgentBehaviorEngine {
  @override
  OmegaAgentReaction? evaluate(OmegaAgentBehaviorContext ctx) {
    if (ctx.event?.name == "greet")
      return const OmegaAgentReaction("sayHello", payload: "Welcome!");
    return null;
  }
}

class MyAgent extends OmegaAgent {
  MyAgent(OmegaChannel channel)
    : super(id: "my_agent", channel: channel, behavior: MyBehavior());

  @override
  void onMessage(OmegaAgentMessage msg) {}

  @override
  void onAction(String action, dynamic payload) {
    if (action == "sayHello") print(payload);
  }
}

Flujo

El canal emite eventos → el agente los recibe → el behavior evalúa y devuelve una reacción → onAction ejecuta la lógica.

Implementación

Integrar Omega en tu app host

La app host crea el runtime, envuelve la UI con OmegaScope y define la navegación inicial.

// lib/main.dart de tu app
void main() {
  final runtime = OmegaRuntime.bootstrap(createOmegaConfig);
  runApp(
    OmegaScope(
      channel: runtime.channel,
      flowManager: runtime.flowManager,
      child: MyApp(navigator: runtime.navigator),
    ),
  );
}

class MyApp extends StatelessWidget {
  final OmegaNavigator navigator;

  const MyApp({super.key, required this.navigator});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      navigatorKey: navigator.navigatorKey,
      home: const _RootHandler(),
    );
  }
}
// lib/_root_handler.dart
class _RootHandler extends StatefulWidget {
  const _RootHandler();

  @override
  State<_RootHandler> createState() => _RootHandlerState();
}

class _RootHandlerState extends State<_RootHandler> {
  @override
  void initState() {
    super.initState();
    // Ruta de inicio decidida por la app host
    WidgetsBinding.instance.addPostFrameCallback((_) {
      final scope = OmegaScope.of(context);
      final intent =
          OmegaIntent(id: "goLogin", name: "navigate.login");

      scope.channel.emit(
        OmegaEvent(
          id: "nav:${DateTime.now().millisecondsSinceEpoch}",
          name: "navigation.intent",
          payload: intent,
        ),
      );
    });
  }

  @override
  Widget build(BuildContext context) {
    return const Scaffold(body: Center(child: Text("Omega Running")));
  }
}

El archivo createOmegaConfig se genera en tu app con omega init y omega g ecosystem. Ahí registras los agentes, flujos y rutas que el runtime usará.

Documentación

Flutter: OmegaScope y OmegaBuilder

OmegaScope (DI)

Envuelve la app para inyectar OmegaChannel y OmegaFlowManager en el árbol de widgets.

OmegaScope(
  channel: myChannel,
  flowManager: myFlowManager,
  child: MyApp(),
)

OmegaBuilder (UI reactiva)

Reconstruye partes de la UI cuando ocurren eventos concretos en el sistema.

OmegaBuilder(
  eventName: 'user.updated',
  builder: (context, event) => Text('${event?.payload}'),
)
Documentación

Ciclo de vida de un flow

Un OmegaFlow solo procesa eventos e intenciones cuando está en estado running. Activar o no un flow define si participa o no en la orquestación.

Estados del flow

  • idle: creado pero aún no ha empezado. No procesa nada.
  • running: activo. Recibe eventos/intents y ejecuta onEvent/onIntent. Se llama onStart() al entrar.
  • sleeping: mantiene memoria, pero ignora eventos/intents. Útil para “hibernar” lógica.
  • paused: detenido temporalmente. No procesa nada hasta reactivarlo.
  • ended: finalizado. Cierra su stream de expresiones y libera recursos.

Activar y desactivar

  • flowManager.activate("flowId"): pone el flow en running sin tocar los demás. Puedes tener varios flows activos a la vez.
  • flowManager.switchTo("flowId"): activa uno y pausa los que estaban en running. Ideal para un solo flow “principal”.
  • flowManager.activateExclusive("flowId"): similar a switchTo, pero no valida si el id existe; es más “agresivo”.
  • Si no activas un flow: se queda en idle, no procesa eventos/intents y su onStart() nunca se llama.

Pausar, dormir y finalizar

  • flowManager.pause("flowId"): pasa el flow a paused. No procesa nada hasta reactivarlo con activate o switchTo.
  • flowManager.sleep("flowId"): llama a sleep() en el flow (estado sleeping). Mantiene memoria, pero está “en reposo”.
  • flowManager.end("flowId"): llama a end() (estado ended) y ya no debería volver a usarse.
  • flowManager.endAll(): finaliza todos los flows registrados y limpia el activeFlowId.

Consecuencias prácticas

  • Solo los flows en running reciben OmegaIntent desde handleIntent.
  • Si una pantalla depende de las expresiones de un flow, debes asegurarte de activarlo antes (por ejemplo en un RootHandler o tras login).
  • Usa switchTo cuando quieras un único flow “dueño” de la navegación y la experiencia principal.
  • Usa activate cuando quieras varios flows colaborando en paralelo (por ejemplo, notificaciones + auth + carrito).
Documentación

Ciclo de vida y dispose

Componente Responsabilidad
OmegaChannel Quien lo cree debe llamar a channel.dispose() al cerrar la app.
OmegaFlowManager Llamar a flowManager.dispose() para cancelar la suscripción de wireNavigator.
OmegaAgent Llamar a agent.dispose() para cancelar la suscripción al canal.
OmegaScope No hace dispose; el widget que cree channel y flowManager debe llamar a sus dispose() en State.dispose.
Documentación

Estructura del proyecto

lib/
├── omega/
│   ├── core/          # Channel, events, intents, types
│   ├── agents/        # OmegaAgent, behavior engine, protocol
│   ├── flows/         # OmegaFlow, OmegaFlowManager, expressions
│   ├── ui/            # OmegaScope, OmegaBuilder, navigation
│   └── bootstrap/     # Config, runtime
├── examples/          # Ejemplos completos
└── omega_architecture.dart  # Exportaciones públicas
Final Word

El Futuro es Reactivo

Omega no es solo una librería; es una forma de pensar el software. Escalable, testeable y lista para el mundo real.

© 2026 Omega Architecture Project • Yeferson Segura • Leading Flutter Evolution