added example

+# GetX codelab
+
+In this example you will learn the basics of GetX. You will see how much easier it is to code with this framework, and you will know what problems GetX proposes to solve.
+
+If the default Flutter application were rewritten with Getx, it would have only a few lines of code. The Getx state manager is easier than using setState. You just need to add a ".obs" at the end of your variable, and wrap the widget you want to change within a Obx().
+
+```dart
+void main() => runApp(MaterialApp(home: Home()));
+
+class Home extends StatelessWidget {
+  var count = 0.obs;
+  @override
+  Widget build(context) => Scaffold(
+      appBar: AppBar(title: Text("counter")),
+      body: Center(
+        child: Obx(() => Text("$count")),
+      ),
+      floatingActionButton: FloatingActionButton(
+        child: Icon(Icons.add),
+        onPressed: () => count ++,
+      ));
+}
+```
+However, this simple example deals with ephemeral state management. If you need to access this data in several places in your application, you will need global state management.
+The most common way to do this is to separate the business logic from its visualization. I know, you've heard this concept before, and it might have been scary for you, but with Getx, it's stupidly simple.
+Getx provides you with a class capable of initializing data, and removing it when it is no longer needed, and its use is very simple:
+Just create a class by extending GetxController and insert ALL your variables and functions there.
+
+```dart
+class Controller extends GetxController {
+  var count = 0;
+  void increment() {
+    count++;
+    update();
+  }
+}
+```
+Here you can choose between simple state management, or reactive state management.
+The simple one will update its variable on the screen whenever update() is called. It is used with a widget called "GetBuilder".
+
+```dart
+class Home extends StatelessWidget {
+  final controller = Get.put(Controller());
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(title: Text("counter")),
+      body: Center(
+        child: Column(
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: [
+            GetBuilder<Controller>(
+                builder: (_) => Text(
+                      'clicks: ${controller.count}',
+                    )),
+            RaisedButton(
+              child: Text('Next Route'),
+              onPressed: () {
+                Get.to(Second());
+              },
+            ),
+          ],
+        ),
+      ),
+      floatingActionButton: FloatingActionButton(
+          child: Icon(Icons.add),
+          onPressed: controller.increment(),  
+          ),
+    );
+  }
+}
+class Second extends StatelessWidget {
+  final Controller ctrl = Get.find();
+  @override
+  Widget build(context){
+     return Scaffold(body: Center(child: Text("${ctrl.count}")));
+  }
+}
+```
+When instantiating your controller, you may have noticed that we use `Get.put(Controller())`. This is enough to make your controller available to other pages as long as it is in memory.
+You may have noticed that you have a new button using `Get.to(Second())`. This is enough to navigate to another page. You don't need a 
+
+```dart
+Navigator.of(context).push(context, 
+ MaterialPageRoute(context, builder: (context){
+    return Second();
+ },
+);
+``` 
+all that huge code, it's reduced to a simple `Get.to(Second())`. Isn't that incredible?
+
+You may also have noticed that on the other page you simply used Get.find (), and the framework knows which controller you registered previously, and returns it effortlessly, you don't need to type the find with `Get.find<Controller>()` so that he knows what you need.
+
+However, this is simple state management. You may want to control the output of each change of state, you may want to use and manipulate streams, you may want a variable to only be changed on the screen, when it definitely changes, you may need a debounce on changing the state, and to these and other needs, Getx has powerful, intelligent, and lightweight state management that can address any need, regardless of the size of your project. And its use is even easier than the previous one.
+
+In your controller, you can remove the update method, Getx is reactive, so when a variable changes, it will automatically change on the screen.
+You just need to add a ".obs" in front of your variable, and that's it, it's already reactive.
+
+```dart
+class Controller extends GetxController {
+  var count = 0.obs;
+  void increment() {
+    count++;
+  }
+}
+```
+Now you just need to change GetBuilder for GetX and that's it
+```dart
+class Home extends StatelessWidget {
+  final controller = Get.put(Controller());
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(title: Text("counter")),
+      body: Center(
+        child: Column(
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: [
+            GetX<Controller>(
+                builder: (_) => Text(
+                      'clicks: ${controller.count}',
+                    )),
+            RaisedButton(
+              child: Text('Next Route'),
+              onPressed: () {
+                Get.to(Second());
+              },
+            ),
+          ],
+        ),
+      ),
+      floatingActionButton: FloatingActionButton(
+          child: Icon(Icons.add),
+          onPressed: controller.increment(),  
+          ),
+    );
+  }
+}
+class Second extends StatelessWidget {
+  final Controller ctrl = Get.find();
+  @override
+  Widget build(context){
+     return Scaffold(body: Center(child: Text("${ctrl.count}")));
+  }
+}
+```
+
+GetX is a useful widget when you want to inject the controller into the init property, or when you want to retrieve an instance of the controller within the widget itself. In other cases, you can insert your widget into an Obx, which receives a widget function. This looks much easier and clearer, just like the first example
+
+```dart
+class Home extends StatelessWidget {
+  final controller = Get.put(Controller());
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(title: Text("counter")),
+      body: Center(
+        child: Column(
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: [
+            Obx(() => Text(
+                      'clicks: ${controller.count}',
+                    )),
+            RaisedButton(
+              child: Text('Next Route'),
+              onPressed: () {
+                Get.to(Second());
+              },
+            ),
+          ],
+        ),
+      ),
+      floatingActionButton: FloatingActionButton(
+          child: Icon(Icons.add),
+          onPressed: controller.increment(),  
+          ),
+    );
+  }
+}
+class Second extends StatelessWidget {
+  final Controller ctrl = Get.find();
+  @override
+  Widget build(context){
+     return Scaffold(body: Center(child: Text("${ctrl.count}")));
+  }
+}
+```
+If you are a more demanding user, you must have said: BLoC separates the View from the business logic. But what about the presentation logic? Will I be obliged to attach it to the visualization? Will I be totally dependent on the context for everything I want to do? Will I have to insert a bunch of variables, TextEditingControllers in my view? If I need to hear the Scroll on my screen, do I need to insert an initState and a function into my view? If I need to trigger an action when this scroll reaches the end, do I insert it into the view, or in the bloc/changeNotifier class? Well, these are common architectural questions, and most of the time the solution to them is ugly.
+With Getx you have no doubts when your architecture, if you need a function, it must be on your Controller, if you need to trigger an event, it needs to be on your controller, your view is generally a StatelessWidget free from any dirt.
+This means that if someone has already done something you’re looking for, you can copy the controller entirely from someone else, and it will work for you, this level of standardization is what Flutter lacked, and it’s because of this that Getx has become so popular in the last few days. Flutter is amazing, and has minor one-off problems. Getx came to solve these specific problems. Flutter provides powerful APIs, and we turn them into an easy, clean, clear, and concise API for you to build applications in a fast, performance and highly scalable way.
+If you have already asked yourself some of these questions above, you have certainly found the solution to your problems. Getx is able to completely separate any logic, be it presentation or business, and you will only have pure widgets in your visualization layer. No variables, no functions, just widgets. This will facilitate the work of your team working with the UI, as well as your team working with your logic. They won't depend on initState to do anything, their controller has onInit. Your code can be tested in isolation, the way it is.
+But what about dependency injection? Will I have it attached to my visualization?
+If you've used any state manager, you've probably heard of "multiAnything", or something like that.
+You have probably already inserted dozens of ChangeNotifier or Blocs classes in a widget, just to have it all over the tree.
+This level of coupling is yet another problem that Getx came to solve. For this, in this ecosystem we use BINDINGS.
+Bindings are dependency injection classes. They are completely outside your widget tree, making your code cleaner, more organized, and allowing you to access it anywhere without context.
+You can initialize dozens of controllers in your Bindings, when you need to know what is being injected into your view, just open the Bindings file on your page and that's it, you can clearly see what has been prepared to be initialized in your View.
+Bindings is the first step towards having a scalable application, you can visualize what will be injected into your page, and decouple the dependency injection from your visualization layer.
+
+To create a Binding, simply create a class and implement Bindings
+
+```dart
+class SampleBind extends Bindings {
+  @override
+  void dependencies() {
+    Get.lazyPut<Controller>(() => Controller());
+    Get.lazyPut<Controller2>(() => Controller2());
+    Get.lazyPut<Controller3>(() => Controller3());
+  }
+}
+```
+You can use with named routes (preferred)
+```dart
+void main() {
+  runApp(GetMaterialApp(
+    initialRoute: '/home',
+    getPages: [
+      GetPage(name: '/home', page: () => First(), binding: SampleBind()),
+    ],
+  ));
+}
+```
+
+Or unnamed
+```dart
+Get.to(Second(), binding: SampleBind());
+```
+
+There is a trick that can clear your View even more.
+Instead of extending StatelessWidget, you can extend GetView, which is a StatelessWidget with a "controller" property.
+
+See the example and see how clean your code can be using this approach.
+The standard Flutter counter has almost 100 lines, it would be summarized to:
+
+on main.dart
+```dart
+void main() {
+  runApp(GetMaterialApp(
+    initialRoute: '/home',
+    getPages: [
+      GetPage(name: '/home', page: () => HomeView(), binding: HomeBinding()),
+    ],
+  ));
+}
+```
+on home_bindings.dart
+```dart
+class HomeBinding implements Bindings {
+  @override
+  void dependencies() {
+    Get.lazyPut(() => HomeController());
+  }
+}
+```
+
+on home_controller.dart
+```dart
+class HomeController extends GetxController {
+  var count = 0.obs;
+  void increment() => count++;
+}
+```
+on home_view.dart
+```dart
+class Home extends GetView<Controller> {
+  @override
+  Widget build(context) => Scaffold(
+      appBar: AppBar(title: Text("counter")),
+      body: Center(
+        child: Obx(() => Text("${controller.counter}")),
+      ),
+      floatingActionButton: FloatingActionButton(
+        child: Icon(Icons.add),
+        onPressed: controller.increment,
+      ));
+}
+```
+What did you do:
+He built an example of the counter, (with less code than the original), decoupling its visualization, its business logic, its dependency injection, in a clean, scalable way, facilitating code maintenance and reusability. If you need an accountant on another project, or your developer friend does, you can just share the content of the controller file with him, and everything will work perfectly.
+As the view has only widgets, you can use a view for android, and another for iOS, taking advantage of 100% of your business logic, your view has only widgets! you can change them however you want, without affecting your application in any way.
+
+However, some examples like internationalization, Snackbars without context, validators, responsiveness and other Getx resources, were not explored (and it would not even be possible to explore all resources in such a simple example), so below is an example not very complete, but trying demonstrate how to use internationalization, reactive custom classes, reactive lists, snackbars contextless, workers etc.
+
+```dart
+import 'package:flutter/material.dart';
+import 'package:get/get.dart';
+
+void main() {
+  runApp(GetMaterialApp(
+    // It is not mandatory to use named routes, but dynamic urls are interesting.
+    initialRoute: '/home',
+    defaultTransition: Transition.native,
+    translations: MyTranslations(),
+    locale: Locale('pt', 'BR'),
+    getPages: [
+      //Simple GetPage
+      GetPage(name: '/home', page: () => First()),
+      // GetPage with custom transitions and bindings
+      GetPage(
+        name: '/second',
+        page: () => Second(),
+        customTransition: SizeTransitions(),
+        binding: SampleBind(),
+      ),
+      // GetPage with default transitions
+      GetPage(
+        name: '/third',
+        transition: Transition.cupertino,
+        page: () => Third(),
+      ),
+    ],
+  ));
+}
+
+class MyTranslations extends Translations {
+  @override
+  Map<String, Map<String, String>> get keys => {
+        'en': {
+          'title': 'Hello World %s',
+        },
+        'en_US': {
+          'title': 'Hello World from US',
+        },
+        'pt': {
+          'title': 'Olá de Portugal',
+        },
+        'pt_BR': {
+          'title': 'Olá do Brasil',
+        },
+      };
+}
+
+class Controller extends GetxController {
+  int count = 0;
+  void increment() {
+    count++;
+    // use update method to update all count variables
+    update();
+  }
+}
+
+class First extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        leading: IconButton(
+          icon: Icon(Icons.add),
+          onPressed: () {
+            Get.snackbar("Hi", "I'm modern snackbar");
+          },
+        ),
+        title: Text("title".trArgs(['John'])),
+      ),
+      body: Center(
+        child: Column(
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: [
+            GetBuilder<Controller>(
+                init: Controller(),
+                // You can initialize your controller here the first time. Don't use init in your other GetBuilders of same controller
+                builder: (_) => Text(
+                      'clicks: ${_.count}',
+                    )),
+            RaisedButton(
+              child: Text('Next Route'),
+              onPressed: () {
+                Get.toNamed('/second');
+              },
+            ),
+            RaisedButton(
+              child: Text('Change locale to English'),
+              onPressed: () {
+                Get.updateLocale(Locale('en', 'UK'));
+              },
+            ),
+          ],
+        ),
+      ),
+      floatingActionButton: FloatingActionButton(
+          child: Icon(Icons.add),
+          onPressed: () {
+            Get.find<Controller>().increment();
+          }),
+    );
+  }
+}
+
+class Second extends GetView<ControllerX> {
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        title: Text('second Route'),
+      ),
+      body: Center(
+        child: Column(
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: [
+            GetX<ControllerX>(
+              // Using bindings you don't need of init: method
+              // Using Getx you can take controller instance of "builder: (_)"
+              builder: (_) {
+                print("count1 rebuild");
+                return Text('${_.count1}');
+              },
+            ),
+            GetX<ControllerX>(
+              builder: (_) {
+                print("count2 rebuild");
+                return Text('${controller.count2}');
+              },
+            ),
+            GetX<ControllerX>(builder: (_) {
+              print("sum rebuild");
+              return Text('${_.sum}');
+            }),
+            GetX<ControllerX>(
+              builder: (_) => Text('Name: ${controller.user.value.name}'),
+            ),
+            GetX<ControllerX>(
+              builder: (_) => Text('Age: ${_.user.value.age}'),
+            ),
+            RaisedButton(
+              child: Text("Go to last page"),
+              onPressed: () {
+                Get.toNamed('/third', arguments: 'arguments of second');
+              },
+            ),
+            RaisedButton(
+              child: Text("Back page and open snackbar"),
+              onPressed: () {
+                Get.back();
+                Get.snackbar(
+                  'User 123',
+                  'Successfully created',
+                );
+              },
+            ),
+            RaisedButton(
+              child: Text("Increment"),
+              onPressed: () {
+                Get.find<ControllerX>().increment();
+              },
+            ),
+            RaisedButton(
+              child: Text("Increment"),
+              onPressed: () {
+                Get.find<ControllerX>().increment2();
+              },
+            ),
+            RaisedButton(
+              child: Text("Update name"),
+              onPressed: () {
+                Get.find<ControllerX>().updateUser();
+              },
+            ),
+            RaisedButton(
+              child: Text("Dispose worker"),
+              onPressed: () {
+                Get.find<ControllerX>().disposeWorker();
+              },
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}
+
+class Third extends GetView<ControllerX> {
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      floatingActionButton: FloatingActionButton(onPressed: () {
+        controller.incrementList();
+      }),
+      appBar: AppBar(
+        title: Text("Third ${Get.arguments}"),
+      ),
+      body: Center(
+          child: Obx(() => ListView.builder(
+              itemCount: controller.list.length,
+              itemBuilder: (context, index) {
+                return Text("${controller.list[index]}");
+              }))),
+    );
+  }
+}
+
+class SampleBind extends Bindings {
+  @override
+  void dependencies() {
+    Get.lazyPut<ControllerX>(() => ControllerX());
+  }
+}
+
+class User {
+  User({this.name = 'Name', this.age = 0});
+  String name;
+  int age;
+}
+
+class ControllerX extends GetxController {
+  final count1 = 0.obs;
+  final count2 = 0.obs;
+  final list = [56].obs;
+  final user = User().obs;
+
+  updateUser() {
+    user.update((value) {
+      value.name = 'Jose';
+      value.age = 30;
+    });
+  }
+
+  /// Once the controller has entered memory, onInit will be called.
+  /// It is preferable to use onInit instead of class constructors or initState method.
+  /// Use onInit to trigger initial events like API searches, listeners registration
+  /// or Workers registration.
+  /// Workers are event handlers, they do not modify the final result,
+  /// but it allows you to listen to an event and trigger customized actions.
+  /// Here is an outline of how you can use them:
+
+  /// made this if you need cancel you worker
+  Worker _ever;
+
+  @override
+  onInit() {
+    /// Called every time the variable $_ is changed
+    _ever = ever(count1, (_) => print("$_ has been changed (ever)"));
+
+    everAll([count1, count2], (_) => print("$_ has been changed (everAll)"));
+
+    /// Called first time the variable $_ is changed
+    once(count1, (_) => print("$_ was changed once (once)"));
+
+    /// Anti DDos - Called every time the user stops typing for 1 second, for example.
+    debounce(count1, (_) => print("debouce$_ (debounce)"),
+        time: Duration(seconds: 1));
+
+    /// Ignore all changes within 1 second.
+    interval(count1, (_) => print("interval $_ (interval)"),
+        time: Duration(seconds: 1));
+  }
+
+  int get sum => count1.value + count2.value;
+
+  increment() => count1.value++;
+
+  increment2() => count2.value++;
+
+  disposeWorker() {
+    _ever.dispose();
+    // or _ever();
+  }
+
+  incrementList() => list.add(75);
+}
+
+class SizeTransitions extends CustomTransition {
+  @override
+  Widget buildTransition(
+      BuildContext context,
+      Curve curve,
+      Alignment alignment,
+      Animation<double> animation,
+      Animation<double> secondaryAnimation,
+      Widget child) {
+    return Align(
+      alignment: Alignment.center,
+      child: SizeTransition(
+        sizeFactor: CurvedAnimation(
+          parent: animation,
+          curve: curve,
+        ),
+        child: child,
+      ),
+    );
+  }
+}
+```

+flutter/ephemeral

+cmake_minimum_required(VERSION 3.10)
+project(runner LANGUAGES CXX)
+
+set(BINARY_NAME "example")
+set(APPLICATION_ID "com.example.example")
+
+cmake_policy(SET CMP0063 NEW)
+
+set(CMAKE_INSTALL_RPATH "$ORIGIN/lib")
+
+# Configure build options.
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE "Debug" CACHE
+    STRING "Flutter build mode" FORCE)
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
+    "Debug" "Profile" "Release")
+endif()
+
+# Compilation settings that should be applied to most targets.
+function(APPLY_STANDARD_SETTINGS TARGET)
+  target_compile_features(${TARGET} PUBLIC cxx_std_14)
+  target_compile_options(${TARGET} PRIVATE -Wall -Werror)
+  target_compile_options(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-O3>")
+  target_compile_definitions(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:NDEBUG>")
+endfunction()
+
+set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter")
+
+# Flutter library and tool build rules.
+add_subdirectory(${FLUTTER_MANAGED_DIR})
+
+# System-level dependencies.
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
+
+add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}")
+
+# Application build
+add_executable(${BINARY_NAME}
+  "main.cc"
+  "my_application.cc"
+  "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc"
+)
+apply_standard_settings(${BINARY_NAME})
+target_link_libraries(${BINARY_NAME} PRIVATE flutter)
+target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK)
+add_dependencies(${BINARY_NAME} flutter_assemble)
+
+# Generated plugin build rules, which manage building the plugins and adding
+# them to the application.
+include(flutter/generated_plugins.cmake)
+
+
+# === Installation ===
+# By default, "installing" just makes a relocatable bundle in the build
+# directory.
+set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle")
+if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+  set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE)
+endif()
+
+# Start with a clean build bundle directory every time.
+install(CODE "
+  file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\")
+  " COMPONENT Runtime)
+
+set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data")
+set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib")
+
+install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}"
+  COMPONENT Runtime)
+
+install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}"
+  COMPONENT Runtime)
+
+install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
+  COMPONENT Runtime)
+
+if(PLUGIN_BUNDLED_LIBRARIES)
+  install(FILES "${PLUGIN_BUNDLED_LIBRARIES}"
+    DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
+    COMPONENT Runtime)
+endif()
+
+# Fully re-copy the assets directory on each build to avoid having stale files
+# from a previous install.
+set(FLUTTER_ASSET_DIR_NAME "flutter_assets")
+install(CODE "
+  file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\")
+  " COMPONENT Runtime)
+install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}"
+  DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime)
+
+# Install the AOT library on non-Debug builds only.
+if(NOT CMAKE_BUILD_TYPE MATCHES "Debug")
+  install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
+    COMPONENT Runtime)
+endif()

+cmake_minimum_required(VERSION 3.10)
+
+set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral")
+
+# Configuration provided via flutter tool.
+include(${EPHEMERAL_DIR}/generated_config.cmake)
+
+# TODO: Move the rest of this into files in ephemeral. See
+# https://github.com/flutter/flutter/issues/57146.
+
+# Serves the same purpose as list(TRANSFORM ... PREPEND ...),
+# which isn't available in 3.10.
+function(list_prepend LIST_NAME PREFIX)
+    set(NEW_LIST "")
+    foreach(element ${${LIST_NAME}})
+        list(APPEND NEW_LIST "${PREFIX}${element}")
+    endforeach(element)
+    set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE)
+endfunction()
+
+# === Flutter Library ===
+# System-level dependencies.
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
+pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0)
+pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0)
+pkg_check_modules(BLKID REQUIRED IMPORTED_TARGET blkid)
+
+set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so")
+
+# Published to parent scope for install step.
+set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE)
+set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE)
+set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE)
+set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE)
+
+list(APPEND FLUTTER_LIBRARY_HEADERS
+  "fl_basic_message_channel.h"
+  "fl_binary_codec.h"
+  "fl_binary_messenger.h"
+  "fl_dart_project.h"
+  "fl_engine.h"
+  "fl_json_message_codec.h"
+  "fl_json_method_codec.h"
+  "fl_message_codec.h"
+  "fl_method_call.h"
+  "fl_method_channel.h"
+  "fl_method_codec.h"
+  "fl_method_response.h"
+  "fl_plugin_registrar.h"
+  "fl_plugin_registry.h"
+  "fl_standard_message_codec.h"
+  "fl_standard_method_codec.h"
+  "fl_string_codec.h"
+  "fl_value.h"
+  "fl_view.h"
+  "flutter_linux.h"
+)
+list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/")
+add_library(flutter INTERFACE)
+target_include_directories(flutter INTERFACE
+  "${EPHEMERAL_DIR}"
+)
+target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}")
+target_link_libraries(flutter INTERFACE
+  PkgConfig::GTK
+  PkgConfig::GLIB
+  PkgConfig::GIO
+  PkgConfig::BLKID
+)
+add_dependencies(flutter flutter_assemble)
+
+# === Flutter tool backend ===
+# _phony_ is a non-existent file to force this command to run every time,
+# since currently there's no way to get a full input/output list from the
+# flutter tool.
+add_custom_command(
+  OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS}
+    ${CMAKE_CURRENT_BINARY_DIR}/_phony_
+  COMMAND ${CMAKE_COMMAND} -E env
+    ${FLUTTER_TOOL_ENVIRONMENT}
+    "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh"
+      linux-x64 ${CMAKE_BUILD_TYPE}
+)
+add_custom_target(flutter_assemble DEPENDS
+  "${FLUTTER_LIBRARY}"
+  ${FLUTTER_LIBRARY_HEADERS}
+)

+//
+//  Generated file. Do not edit.
+//
+
+#include "generated_plugin_registrant.h"
+
+
+void fl_register_plugins(FlPluginRegistry* registry) {
+}

+//
+//  Generated file. Do not edit.
+//
+
+#ifndef GENERATED_PLUGIN_REGISTRANT_
+#define GENERATED_PLUGIN_REGISTRANT_
+
+#include <flutter_linux/flutter_linux.h>
+
+// Registers Flutter plugins.
+void fl_register_plugins(FlPluginRegistry* registry);
+
+#endif  // GENERATED_PLUGIN_REGISTRANT_

+#
+# Generated file, do not edit.
+#
+
+list(APPEND FLUTTER_PLUGIN_LIST
+)
+
+set(PLUGIN_BUNDLED_LIBRARIES)
+
+foreach(plugin ${FLUTTER_PLUGIN_LIST})
+  add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/linux plugins/${plugin})
+  target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin)
+  list(APPEND PLUGIN_BUNDLED_LIBRARIES $<TARGET_FILE:${plugin}_plugin>)
+  list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries})
+endforeach(plugin)

+#include "my_application.h"
+
+int main(int argc, char** argv) {
+  // Only X11 is currently supported.
+  // Wayland support is being developed: https://github.com/flutter/flutter/issues/57932.
+  gdk_set_allowed_backends("x11");
+
+  g_autoptr(MyApplication) app = my_application_new();
+  return g_application_run(G_APPLICATION(app), argc, argv);
+}

+#include "my_application.h"
+
+#include <flutter_linux/flutter_linux.h>
+
+#include "flutter/generated_plugin_registrant.h"
+
+struct _MyApplication {
+  GtkApplication parent_instance;
+};
+
+G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION)
+
+// Implements GApplication::activate.
+static void my_application_activate(GApplication* application) {
+  GtkWindow* window =
+      GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application)));
+  GtkHeaderBar *header_bar = GTK_HEADER_BAR(gtk_header_bar_new());
+  gtk_widget_show(GTK_WIDGET(header_bar));
+  gtk_header_bar_set_title(header_bar, "example");
+  gtk_header_bar_set_show_close_button(header_bar, TRUE);
+  gtk_window_set_titlebar(window, GTK_WIDGET(header_bar));
+  gtk_window_set_default_size(window, 1280, 720);
+  gtk_widget_show(GTK_WIDGET(window));
+
+  g_autoptr(FlDartProject) project = fl_dart_project_new();
+
+  FlView* view = fl_view_new(project);
+  gtk_widget_show(GTK_WIDGET(view));
+  gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view));
+
+  fl_register_plugins(FL_PLUGIN_REGISTRY(view));
+
+  gtk_widget_grab_focus(GTK_WIDGET(view));
+}
+
+static void my_application_class_init(MyApplicationClass* klass) {
+  G_APPLICATION_CLASS(klass)->activate = my_application_activate;
+}
+
+static void my_application_init(MyApplication* self) {}
+
+MyApplication* my_application_new() {
+  return MY_APPLICATION(g_object_new(my_application_get_type(),
+                                     "application-id", APPLICATION_ID,
+                                     nullptr));
+}

+#ifndef FLUTTER_MY_APPLICATION_H_
+#define FLUTTER_MY_APPLICATION_H_
+
+#include <gtk/gtk.h>
+
+G_DECLARE_FINAL_TYPE(MyApplication, my_application, MY, APPLICATION,
+                     GtkApplication)
+
+/**
+ * my_application_new:
+ *
+ * Creates a new Flutter-based application.
+ *
+ * Returns: a new #MyApplication.
+ */
+MyApplication* my_application_new();
+
+#endif  // FLUTTER_MY_APPLICATION_H_

@@ -88,7 +88,7 @@ class GetObserver extends NavigatorObserver {
       value.route = route;
       value.route = route;
       value.isBack = false;
       value.isBack = false;
       value.removed = '';
       value.removed = '';
-      value.previous = '${previousRoute?.settings?.name}';
+      value.previous = previousRoute?.settings?.name ?? '';
       value.isSnackbar = isSnackbar;
       value.isSnackbar = isSnackbar;
       value.isBottomSheet = isBottomSheet;
       value.isBottomSheet = isBottomSheet;
       value.isDialog = isDialog;
       value.isDialog = isDialog;
@@ -119,12 +119,12 @@ class GetObserver extends NavigatorObserver {
 
 
     _routeSend.update((value) {
     _routeSend.update((value) {
       if (previousRoute is PageRoute)
       if (previousRoute is PageRoute)
-        value.current = '${previousRoute?.settings?.name}';
+        value.current = previousRoute?.settings?.name ?? '';
       value.args = route?.settings?.arguments;
       value.args = route?.settings?.arguments;
       value.route = previousRoute;
       value.route = previousRoute;
       value.isBack = true;
       value.isBack = true;
       value.removed = '';
       value.removed = '';
-      value.previous = '${route?.settings?.name}';
+      value.previous = route?.settings?.name ?? '';
       value.isSnackbar = false;
       value.isSnackbar = false;
       value.isBottomSheet = false;
       value.isBottomSheet = false;
       value.isDialog = false;
       value.isDialog = false;
@@ -142,7 +142,7 @@ class GetObserver extends NavigatorObserver {
     GetConfig.currentRoute = name(newRoute);
     GetConfig.currentRoute = name(newRoute);
 
 
     _routeSend.update((value) {
     _routeSend.update((value) {
-      if (newRoute is PageRoute) value.current = '${newRoute?.settings?.name}';
+      if (newRoute is PageRoute) value.current = newRoute?.settings?.name ?? '';
       value.args = newRoute?.settings?.arguments;
       value.args = newRoute?.settings?.arguments;
       value.route = newRoute;
       value.route = newRoute;
       value.isBack = false;
       value.isBack = false;
@@ -163,8 +163,8 @@ class GetObserver extends NavigatorObserver {
     _routeSend.update((value) {
     _routeSend.update((value) {
       value.route = previousRoute;
       value.route = previousRoute;
       value.isBack = false;
       value.isBack = false;
-      value.removed = '${route?.settings?.name}';
-      value.previous = '${route?.settings?.name}';
+      value.removed = route?.settings?.name ?? '';
+      value.previous = route?.settings?.name ?? '';
     });
     });
     if (routing != null) routing(_routeSend);
     if (routing != null) routing(_routeSend);
   }
   }

@@ -3,6 +3,8 @@ import 'package:flutter/widgets.dart';
 import 'package:get/src/state_manager/rx/rx_core/rx_interface.dart';
 import 'package:get/src/state_manager/rx/rx_core/rx_interface.dart';
 import '../rx_core/rx_impl.dart';
 import '../rx_core/rx_impl.dart';
 
 
+typedef WidgetCallback = Widget Function();
+
 /// The simplest reactive widget in GetX.
 /// The simplest reactive widget in GetX.
 ///
 ///
 /// Just pass your Rx variable in the root scope of the callback to have it
 /// Just pass your Rx variable in the root scope of the callback to have it
@@ -11,7 +13,7 @@ import '../rx_core/rx_impl.dart';
 /// final _name = "GetX".obs;
 /// final _name = "GetX".obs;
 /// Obx(() => Text( _name.value )),... ;
 /// Obx(() => Text( _name.value )),... ;
 class Obx extends StatefulWidget {
 class Obx extends StatefulWidget {
-  final Widget Function() builder;
+  final WidgetCallback builder;
 
 
   const Obx(this.builder);
   const Obx(this.builder);
   _ObxState createState() => _ObxState();
   _ObxState createState() => _ObxState();